Add support for websearch_to_tsquery in PG 11

Add a guide to the internals of the codebase
Add a CONTRIBUTING.md guide for contributors
2019-12-02 10:52:22 -05:00 · 2019-11-30 10:45:24 -05:00 · 2019-11-29 22:29:31 -05:00 · 2019-11-29 01:38:23 -05:00 · 2019-11-29 00:14:05 -05:00 · 2019-11-29 00:14:05 -05:00
60 changed files with 2278 additions and 561 deletions
--- a/.chglog/CHANGELOG.tpl.md
+++ b/.chglog/CHANGELOG.tpl.md
@ -0,0 +1,49 @@
+{{ if .Versions -}}
+<a name="unreleased"></a>
+## [Unreleased]
+
+{{ if .Unreleased.CommitGroups -}}
+{{ range .Unreleased.CommitGroups -}}
+### {{ .Title }}
+{{ range .Commits -}}
+- {{ if .Scope }}**{{ .Scope }}:** {{ end }}{{ .Subject }}
+{{ end }}
+{{ end -}}
+{{ end -}}
+{{ end -}}
+
+{{ range .Versions }}
+<a name="{{ .Tag.Name }}"></a>
+## {{ if .Tag.Previous }}[{{ .Tag.Name }}]{{ else }}{{ .Tag.Name }}{{ end }} - {{ datetime "2006-01-02" .Tag.Date }}
+{{ range .CommitGroups -}}
+### {{ .Title }}
+{{ range .Commits -}}
+- {{ if .Scope }}**{{ .Scope }}:** {{ end }}{{ .Subject }}
+{{ end }}
+{{ end -}}
+
+{{- if .MergeCommits -}}
+### Pull Requests
+{{ range .MergeCommits -}}
+- {{ .Header }}
+{{ end }}
+{{ end -}}
+
+{{- if .NoteGroups -}}
+{{ range .NoteGroups -}}
+### {{ .Title }}
+{{ range .Notes }}
+{{ .Body }}
+{{ end }}
+{{ end -}}
+{{ end -}}
+{{ end -}}
+
+{{- if .Versions }}
+[Unreleased]: {{ .Info.RepositoryURL }}/compare/{{ $latest := index .Versions 0 }}{{ $latest.Tag.Name }}...HEAD
+{{ range .Versions -}}
+{{ if .Tag.Previous -}}
+[{{ .Tag.Name }}]: {{ $.Info.RepositoryURL }}/compare/{{ .Tag.Previous.Name }}...{{ .Tag.Name }}
+{{ end -}}
+{{ end -}}
+{{ end -}}
--- a/.chglog/config.yml
+++ b/.chglog/config.yml
@ -0,0 +1,27 @@
+style: github
+template: CHANGELOG.tpl.md
+info:
+  title: CHANGELOG
+  repository_url: https://github.com/dosco/super-graph
+options:
+  commits:
+    # filters:
+    #   Type:
+    #     - feat
+    #     - fix
+    #     - perf
+    #     - refactor
+  commit_groups:
+    # title_maps:
+    #   feat: Features
+    #   fix: Bug Fixes
+    #   perf: Performance Improvements
+    #   refactor: Code Refactoring
+  header:
+    pattern: "^((\\w+)\\s.*)$"
+    pattern_maps:
+      - Subject
+      - Type
+  notes:
+    keywords:
+      - BREAKING CHANGE
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@ -0,0 +1,24 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: dosco
+
+---
+
+<!-- If you suspect this could be a bug, follow the template. -->
+
+### What version of Super Graph are you using? `super-graph version`
+
+
+### Have you tried reproducing the issue with the latest release?
+
+
+### What is the hardware spec (RAM, OS)?
+
+
+### Steps to reproduce the issue (config used to run Super Graph).
+
+
+### Expected behaviour and actual result.
--- a/.github/ISSUE_TEMPLATE/documentation.md
+++ b/.github/ISSUE_TEMPLATE/documentation.md
@ -0,0 +1,12 @@
+---
+name: Documentation
+about: Suggest how we can improve documentation
+title: ''
+labels: ''
+assignees: dosco
+
+---
+
+<!-- If you think the Super Graph documentation falls short https://supergraph.dev/guide.html please suggest ways we can improve it. -->
+
+<!-- explain it here. -->
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: dosco
+
+---
+
+## Experience Report
+
+Note: Feature requests are judged based on user experience this is similar to the [Go Experience Reports](https://github.com/golang/go/wiki/ExperienceReports). These reports should focus on the problems: they should not focus on and need not propose solutions.
+
+### What you wanted to do
+
+### What you actually did
+
+### Why that wasn't great, with examples
+
+### Any external references to support your case
--- a/.gitignore
+++ b/.gitignore
@ -27,8 +27,11 @@
 main
 .DS_Store
 .swp
+.release
 main
 super-graph
+supergraph
 *-fuzz.zip
 crashers
-suppressions
+suppressions
+release
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -0,0 +1,384 @@
+<a name="unreleased"></a>
+## [Unreleased]
+
+
+<a name="v0.12.4"></a>
+## [v0.12.4] - 2019-11-28
+### Move
+- Move license from MIT to Apache 2.0. Add Makefile
+
+
+<a name="v0.12.3"></a>
+## [v0.12.3] - 2019-11-26
+### Added
+- Added support for query names to the allow.list
+
+
+<a name="v0.12.2"></a>
+## [v0.12.2] - 2019-11-25
+### Fix
+- Fix bug with compiling anon queries
+
+
+<a name="v0.12.1"></a>
+## [v0.12.1] - 2019-11-22
+### Move
+- Move sql query logging from info to debug
+
+
+<a name="v0.12.0"></a>
+## [v0.12.0] - 2019-11-22
+### Use
+- Use logger error instead of panic in goja handlers
+
+
+<a name="v0.11.9"></a>
+## [v0.11.9] - 2019-11-22
+### Add
+- Add a db:reset command only for dev mode
+
+
+<a name="v0.11.8"></a>
+## [v0.11.8] - 2019-11-21
+### Optimize
+- Optimize db queries limit use of transactions
+
+
+<a name="v0.11.7"></a>
+## [v0.11.7] - 2019-11-19
+### Added
+- Added support for multi-root queries
+
+
+<a name="v0.11.6"></a>
+## [v0.11.6] - 2019-11-15
+### Fix
+- Fix issues with JWT auth
+- Fix bug with migration filename generation
+- Fix bug with migration file name
+
+
+<a name="v0.11.5"></a>
+## [v0.11.5] - 2019-11-10
+### Fix
+- Fix bug with migration template name
+
+
+<a name="v0.11.4"></a>
+## [v0.11.4] - 2019-11-10
+### Fix
+- Fix bug with creating new migrations
+
+
+<a name="v0.11.3"></a>
+## [v0.11.3] - 2019-11-09
+### Fix
+- Fix macro syntax bug in app templates
+
+
+<a name="v0.11.2"></a>
+## [v0.11.2] - 2019-11-07
+### Fix
+- Fix bugs and add new production mode
+
+
+<a name="v0.11.1"></a>
+## [v0.11.1] - 2019-11-05
+### Add
+- Add nested where clause to filter based on related tables
+
+### Block
+- Block unauthorized requests when 'anon' role is not defined
+
+### Update
+- Update docs and website with new features
+
+
+<a name="v0.11"></a>
+## [v0.11] - 2019-11-01
+### Add
+- Add config driven presets for insert, update and upsert
+- Add config driven presets for insert, update and upserta
+- Add RBAC option to disable functions eg. count
+- Add fuzz testing to 'serv' for the GQL hash parser
+- Add fuzz testing to 'jsn' and 'qcode'
+- Add ability to block queries and mutations by role
+- Add built in 'anon' and 'user' roles
+- Add role based access control
+
+### Allow
+- Allow config files to inherit from other config files
+
+### Change
+- Change config key inherit to inherits
+
+### Get
+- Get RBAC working for queries and mutations
+
+### Optimize
+- Optimize prepared statement flow for RBAC
+
+### Preserve
+- Preserve allow.list ordering on save
+
+### Update
+- Update filters section in guide
+
+### Pull Requests
+- Merge pull request [#11](https://github.com/dosco/super-graph/issues/11) from dosco/rbac
+
+
+<a name="v0.10.1"></a>
+## [v0.10.1] - 2019-10-06
+### Add
+- Add ability to set filters per operation / action
+- Add upsert mutation
+
+### Pull Requests
+- Merge pull request [#10](https://github.com/dosco/super-graph/issues/10) from FourSigma/sm-examples-folder
+
+
+<a name="v0.10"></a>
+## [v0.10] - 2019-10-04
+### Fix
+- Fix return values for bulk mutations and delete
+- Fix issues with mutation SQL
+- Fix broken demo app
+- Fix typo in 'across'
+
+### Remove
+- Remove extra link from README
+
+### Update
+- Update docs, getting started guide and mutations
+
+### Pull Requests
+- Merge pull request [#6](https://github.com/dosco/super-graph/issues/6) from muesli/typo-fixes
+
+
+<a name="v0.9"></a>
+## [v0.9] - 2019-10-01
+### Fix
+- Fix demo rails app broken build
+
+
+<a name="v0.8"></a>
+## [v0.8] - 2019-09-30
+### Fix
+- Fix invalid import bug
+
+### Update
+- Update documentation site
+
+
+<a name="v0.7"></a>
+## [v0.7] - 2019-09-29
+### Failure
+- Failure to prepare statements should be a warning
+
+### Fix
+- Fix duplicte column bug
+
+
+<a name="v0.6"></a>
+## [v0.6] - 2019-09-29
+### Add
+- Add database setup commands
+- Add binary compression back to Dockerfile
+- Add initialization command to setup new apps
+- Add migrate command
+- Add database seeding capability
+- Add session variable for user id
+- Add delete mutation
+- Add update mutation
+- Add insert mutation with bulk insert
+- Add GoTO Aug, 19 presentation
+- Add support for prepared statements
+- Add end-to-end benchmaking
+- Add object pooling for parser expressions
+- Add request / response debugging for remote joins
+- Add a presentation about GraphQL
+- Add validation for remote JSON
+- Add tracing for API stitching
+- Add REST API stitching
+- Add SQL query cacheing
+- Add support for GraphQL variables
+- Add fuzz testing to qcode
+- Add test for Rails Redis cookie store integration
+- Add an install guide
+
+### Change
+- Change fuzz test name to qcode
+- Change logo from PNG to SVG
+
+### Enabke
+- Enabke reload on config change
+
+### Fix
+- Fix missing config name bug
+- Fix new app templates
+- Fix help message for migrate
+- Fix session variable bug
+- Fix test failures in `psql` and `serv`
+- Fix demo docker services startup order
+- Fix wrong value for false token bug. Reported by [@ThisIsMissEm](https://github.com/ThisIsMissEm)
+- Fix allow.list file discovery bug
+- Fix bug with allow list path
+- Fix wrong value for use_allow_list in dev config
+- Fix startup bug in demo script
+- Fix url bug in allow list
+- Fix bug [#676](https://github.com/dosco/super-graph/issues/676) found by fuzzer
+- Fix race-condition in remote joins
+- Fix cookie passing in web ui
+- Fix bug with passing cookies in web ui
+- Fix null pointer with invalid argument values
+- Fix infinite loop bug in lexer
+- Fix null pointer issue found by fuzz test
+- Fix issue with fuzzbuzz config
+- Fix demo to run as memory only
+- Fix auth documentation
+- Fix issue with web ui sizing
+- Fix issue preventing docker-compose deploy
+- Fix try demo documentation
+
+### Futher
+- Futher reduce allocations across hot paths
+- Futher reduce allocations on the compiler hot path
+- Futher optimize json parsing and editing performance
+
+### Highlight
+- Highlight top features better on the site
+
+### Improve
+- Improve readability of json parser code
+- Improve the motivation section in the readme
+- Improve the demo experience
+
+### Make
+- Make remote joins use parallel http requests
+
+### Merge
+- Merge branch 'master' into optimize-psql
+
+### New
+- New low allocation fast json parsing and editing library
+
+### Optimize
+- Optimize lexer and fix bugs
+- Optimize the sql generator hot path
+
+### Reduce
+- Reduce alllocations done by the stack
+- Reduce steps to run the demo
+- Reduce allocations and improve perf over 50%
+
+### Remove
+- Remove unused packages
+- Remove the 'hello' test app folder
+- Remove other allocations in psql
+
+### Use
+- Use hash's as ids for table relationships
+
+### Watch
+- Watch and reload on config changes
+
+
+<a name="v0.5"></a>
+## [v0.5] - 2019-04-10
+### Add
+- Add supprt for new Rails 5.2 aes-256-gcm cookies
+- Add query support for ts_rank and ts_headline
+- Add full text search support using TSV indexes
+- Add missing assets folder
+- Add fetch by ID feature
+- Add documentation
+
+### Cleanup
+- Cleanup and redesign config files
+
+### Fix
+- Fix bug with auth config parsing
+
+### Redesign
+- Redesign config file architecture
+
+### Reduce
+- Reduce realloc of maps and slices
+
+### Update
+- Update docs with full-text search information
+
+
+<a name="v0.4"></a>
+## [v0.4] - 2019-04-01
+
+<a name="v0.3"></a>
+## [v0.3] - 2019-04-01
+### Add
+- Add SQL execution timing and tracing
+- Add support for HAVING with aggregate queries
+- Add aggregrate functions to GQL queries
+- Add Auth0 JWT support
+- Add React UI building to the docker build flow
+- Add compiler profiling
+- Add bechmarks for GQL to SQL compile
+- Add tests for gql to sql compile
+
+### Cleanup
+- Cleanup Dockerfile
+
+### Fix
+- Fix recurring packer issue docker hub builds
+- Fix issue with asset packer breaking Docker builds
+- Fix missing git package in Dockerfile
+- Fix docker ignore values
+- Fix image build failure on docker hub
+- Fix build issue in Dockerfile
+- Fix bugs and document the 'where' clause
+- Fix perf issue with inflections
+
+### Optimize
+- Optimize docker image
+
+### Pack
+- Pack web UI with app into a single binary
+
+### Upgrade
+- Upgrade web UI packages
+
+
+<a name="0.3"></a>
+## 0.3 - 2019-03-24
+### First
+- First commit
+
+### Fix
+- Fix license to MIT
+
+
+[Unreleased]: https://github.com/dosco/super-graph/compare/v0.12.4...HEAD
+[v0.12.4]: https://github.com/dosco/super-graph/compare/v0.12.3...v0.12.4
+[v0.12.3]: https://github.com/dosco/super-graph/compare/v0.12.2...v0.12.3
+[v0.12.2]: https://github.com/dosco/super-graph/compare/v0.12.1...v0.12.2
+[v0.12.1]: https://github.com/dosco/super-graph/compare/v0.12.0...v0.12.1
+[v0.12.0]: https://github.com/dosco/super-graph/compare/v0.11.9...v0.12.0
+[v0.11.9]: https://github.com/dosco/super-graph/compare/v0.11.8...v0.11.9
+[v0.11.8]: https://github.com/dosco/super-graph/compare/v0.11.7...v0.11.8
+[v0.11.7]: https://github.com/dosco/super-graph/compare/v0.11.6...v0.11.7
+[v0.11.6]: https://github.com/dosco/super-graph/compare/v0.11.5...v0.11.6
+[v0.11.5]: https://github.com/dosco/super-graph/compare/v0.11.4...v0.11.5
+[v0.11.4]: https://github.com/dosco/super-graph/compare/v0.11.3...v0.11.4
+[v0.11.3]: https://github.com/dosco/super-graph/compare/v0.11.2...v0.11.3
+[v0.11.2]: https://github.com/dosco/super-graph/compare/v0.11.1...v0.11.2
+[v0.11.1]: https://github.com/dosco/super-graph/compare/v0.11...v0.11.1
+[v0.11]: https://github.com/dosco/super-graph/compare/v0.10.1...v0.11
+[v0.10.1]: https://github.com/dosco/super-graph/compare/v0.10...v0.10.1
+[v0.10]: https://github.com/dosco/super-graph/compare/v0.9...v0.10
+[v0.9]: https://github.com/dosco/super-graph/compare/v0.8...v0.9
+[v0.8]: https://github.com/dosco/super-graph/compare/v0.7...v0.8
+[v0.7]: https://github.com/dosco/super-graph/compare/v0.6...v0.7
+[v0.6]: https://github.com/dosco/super-graph/compare/v0.5...v0.6
+[v0.5]: https://github.com/dosco/super-graph/compare/v0.4...v0.5
+[v0.4]: https://github.com/dosco/super-graph/compare/v0.3...v0.4
+[v0.3]: https://github.com/dosco/super-graph/compare/0.3...v0.3
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -0,0 +1,79 @@
+# Contributing to Super Graph
+
+Super Graph is a very approchable code-base and a project that is easy for almost
+anyone with basic GO knowledge to start contributing to. It is also a young project
+so a lot of high value work is there for the taking.
+
+Even the GraphQL to SQL compiler that is at the heart of Super Graph is essentially a text book compiler with clean and easy to read code. The data structures used by the lexer, parser and sql generator are easy to understand and modify. 
+
+Finally we do have a lot of test for critical parts of the codebase which makes it easy for you to modify with confidence. I'm always available for questions or any sort of guidance so feel fee to reach out over twitter or discord.
+
+* [Getting Started](#get-started)
+* [Setting Up the Development Environment](#get-setup)
+   * [Prerequisites](#prerequisites)
+   * [Get the Super Graph source](#get-source)
+   * [Start the development envoirnment ](#start-dev)
+   * [Testing](#testing)
+* [Contributing](#contributing)
+   * [Guidelines](#guidelines)
+   * [Code style](#code-style)
+
+## Getting Started {#get-started}
+
+- Read the [Getting Started Guide](https://supergraph.dev/guide.html#get-started)
+
+## Setting Up the Development Environment {#get-setup}
+
+### Prerequisites
+
+- Install [Git](https://git-scm.com/) (may be already installed on your system, or available through your OS package manager)
+- Install [Go 1.13 or above](https://golang.org/doc/install)
+- Install [Docker](https://docs.docker.com/v17.09/engine/installation/)
+
+### Get the Super Graph source {#get-source}
+
+The entire build flow uses `Makefile` there is a whole list of sub-commands you
+can use to build, test, install, lint, etc.
+
+```bash
+git clone https://github.com/dosco/super-graph 
+cd ./super-graph
+make help
+```
+
+### Start the development envoirnment {#start-dev}
+
+The entire development flow is packaged into a `docker-compose` work flow. The below `up` command will launch A Postgres database, a example e-commerce app in Rails and Super Graph in development mode. The `db:seed` Rails task will insert sample data into Postgres.
+
+```bash
+docker-compose -f demo.yml run rails_app rake db:create db:migrate db:seed
+docker-compose up
+```
+
+### Learn how the code works
+
+[Super Graph codebase explained](https://supergraph.dev/internals.html)
+
+### Testing and Linting {#testing}
+
+```
+make lint test
+```
+
+## Contributing
+
+- **Pull requests are welcome**, as long as you're willing to put in the effort to meet the guidelines.
+- Aim for clear, well written, maintainable code.
+- Simple and minimal approach to features, like Go.
+- Refactoring existing code now for better performance, better readability or better testability wins over adding a new feature.
+- Don't add a function to a module that you don't use right now, or doesn't clearly enable a planned functionality.
+- Don't ship a half done feature, which would require significant alterations to work fully.
+- Avoid [Technical debt](https://en.wikipedia.org/wiki/Technical_debt) like cancer.
+- Leave the code cleaner than when you began.
+
+### Code style
+- We're following [Go Code Review](https://github.com/golang/go/wiki/CodeReviewComments).
+- Use `go fmt` to format your code before committing.
+- If you see *any code* which clearly violates the style guide, please fix it and send a pull request. No need to ask for permission.
+- Avoid unnecessary vertical spaces. Use your judgment or follow the code review comments.
+- Wrap your code and comments to 100 characters, unless doing so makes the code less legible.
--- a/12
+++ b/12
@ -6,13 +6,13 @@ RUN yarn
 RUN yarn build

 # stage: 2
-FROM golang:1.13beta1-alpine as go-build
+FROM golang:1.13.4-alpine as go-build
 RUN apk update && \
+    apk add --no-cache make && \
    apk add --no-cache git && \
    apk add --no-cache upx=3.95-r2

-RUN go get -u github.com/rafaelsq/wtc && \
-    go get -u github.com/GeertJohan/go.rice/rice
+RUN GO111MODULE=off go get -u github.com/rafaelsq/wtc

 WORKDIR /app
 COPY . /app
@ -20,11 +20,9 @@ COPY . /app
 RUN mkdir -p /app/web/build
 COPY --from=react-build /web/build/ ./web/build/

-ENV GO111MODULE=on
 RUN go mod vendor
-RUN go generate ./... && \
-  CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o super-graph && \
-  echo "Compressing binary, will take a bit of time..." && \
+RUN make build
+RUN echo "Compressing binary, will take a bit of time..." && \
  upx --ultra-brute -qq super-graph && \
  upx -t super-graph

--- a/189
+++ b/189
@ -1,21 +1,176 @@
-The MIT License (MIT)
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/

-Copyright (c) 2019-present Vikram Rangnekar. twitter.com/dosco
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+   1. Definitions.

-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.

-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
--- a/103
+++ b/103
@ -0,0 +1,103 @@
+BUILD         ?= $(shell git rev-parse --short HEAD)
+BUILD_DATE    ?= $(shell git log -1 --format=%ci)
+BUILD_BRANCH  ?= $(shell git rev-parse --abbrev-ref HEAD)
+BUILD_VERSION ?= $(shell git describe --always --tags)
+
+GOPATH  ?= $(shell go env GOPATH)
+
+ifndef GOPATH
+override GOPATH = $(HOME)/go
+endif
+
+export GO111MODULE := on
+
+# Build-time Go variables
+version        = github.com/dosco/super-graph/serv.version
+gitBranch      = github.com/dosco/super-graph/serv.gitBranch
+lastCommitSHA  = github.com/dosco/super-graph/serv.lastCommitSHA
+lastCommitTime = github.com/dosco/super-graph/serv.lastCommitTime
+
+BUILD_FLAGS ?= -ldflags '-s -w -X ${lastCommitSHA}=${BUILD} -X "${lastCommitTime}=${BUILD_DATE}" -X "${version}=${BUILD_VERSION}" -X ${gitBranch}=${BUILD_BRANCH}'
+
+.PHONY: all build gen clean test run lint changlog release version help $(PLATFORMS)
+
+test:
+	@go test -v ./...
+
+BIN_DIR := $(GOPATH)/bin
+GORICE := $(BIN_DIR)/github.com/GeertJohan/go.rice
+GOLANGCILINT := $(BIN_DIR)/golangci-lint
+GITCHGLOG := $(BIN_DIR)/git-chglog
+
+$(GORICE):
+	@GO111MODULE=off go get -u github.com/GeertJohan/go.rice/rice
+
+$(GITCHGLOG):
+	@GO111MODULE=off go get -u github.com/git-chglog/git-chglog/cmd/git-chglog
+
+changelog: $(GITCHGLOG)
+	@git-chglog $(ARGS)
+
+$(GOLANGCILINT):
+	@GO111MODULE=off curl -sfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh| sh -s -- -b $(GOPATH)/bin v1.21.0
+
+lint: $(GOMETALINTER)
+	@golangci-lint run ./... --skip-dirs-use-default
+
+BINARY := super-graph
+LDFLAGS := -s -w
+PLATFORMS := windows linux darwin
+os = $(word 1, $@)
+
+$(PLATFORMS): lint test gen 
+	@mkdir -p release
+	@GOOS=$(os) GOARCH=amd64 go build $(BUILD_FLAGS) -o release/$(BINARY)-$(BUILD_VERSION)-$(os)-amd64
+
+release: windows linux darwin
+
+all: lint test $(BINARY)
+
+build: $(BINARY)
+
+gen: $(GORICE)
+	@go generate ./...
+
+$(BINARY): clean gen
+	@go build $(BUILD_FLAGS) -o $(BINARY)
+
+clean:
+	@rm -f $(BINARY)
+
+run: clean
+	@go run $(BUILD_FLAGS) main.go $(ARGS)
+
+install: gen
+	@echo $(GOPATH)
+	@echo "Commit Hash: `git rev-parse HEAD`"
+	@echo "Old Hash: `shasum $(GOPATH)/bin/$(BINARY) 2>/dev/null | cut -c -32`"
+	@go install $(BUILD_FLAGS)
+	@echo "New Hash:" `shasum $(GOPATH)/bin/$(BINARY) 2>/dev/null | cut -c -32`
+
+uninstall: clean
+	@go clean -i -x
+
+version:
+	@echo Super Graph ${BUILD_VERSION}
+	@echo Build: ${BUILD}
+	@echo Build date: ${BUILD_DATE}
+	@echo Branch: ${BUILD_BRANCH}
+	@echo Go version: $(shell go version)
+
+help:
+	@echo
+	@echo Build commands:
+	@echo " make build         - Build supergraph binary"
+	@echo " make install       - Install supergraph binary"
+	@echo " make uninstall     - Uninstall supergraph binary"
+	@echo " make [platform]    - Build for platform [linux|darwin|windows]"
+	@echo " make release       - Build all platforms"
+	@echo " make run           - Run supergraph (eg. make run ARGS=\"help\")"
+	@echo " make test          - Run all tests"
+	@echo " make changelog     - Generate changelog (eg. make changelog ARGS=\"help\")"
+	@echo " make help          - This help"
+	@echo
--- a/13
+++ b/13
@ -0,0 +1,13 @@
+Copyright 2019 Vikram Rangnekar
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
--- a/README.md
+++ b/README.md
@ -1,16 +1,24 @@
-<a href="https://supergraph.dev"><img src="https://supergraph.dev/hologram.svg" width="100" height="100" align="right" /></a>
+<!-- <a href="https://supergraph.dev"><img src="https://supergraph.dev/hologram.svg" width="100" height="100" align="right" /></a> -->

-# Super Graph - Instant GraphQL APIs for your apps. 
+<img src="docs/.vuepress/public/super-graph.png" width="250" />

-## Build web products faster. No code needed. GraphQL auto. transformed into efficient database queries.
+### Build web products faster. Secure high performance GraphQL

-![MIT license](https://img.shields.io/github/license/dosco/super-graph.svg)
+![Apache Public License 2.0](https://img.shields.io/github/license/dosco/super-graph.svg)
 ![Docker build](https://img.shields.io/docker/cloud/build/dosco/super-graph.svg)
 ![Cloud native](https://img.shields.io/badge/cloud--native-enabled-blue.svg)
 [![Discord Chat](https://img.shields.io/discord/628796009539043348.svg)](https://discord.gg/6pSWCTZ)  

+
+## What is Super Graph
+
+Super Graph is a micro-service that instantly and without code gives you a high performance and secure GraphQL API. Your GraphQL queries are auto translated into a single fast SQL query. No more writing API code as you develop your web frontend just make the query you need and Super Graph will do the rest.
+
+Super Graph has a rich feature set like integrating with your existing Ruby on Rails apps, joining your DB with data from remote APIs, Role and Attribute based access control, Supoport for JWT tokens, Built-in DB mutations and seeding and a lot more.
+
 ![GraphQL](docs/.vuepress/public/graphql.png?raw=true "")

+
 ## The story of Super Graph?

 After working on several products through my career I find that we spend way too much time on building API backends. Most APIs also require constant updating, this costs real time and money.
@ -25,8 +33,8 @@ This compiler is what sits at the heart of Super Graph with layers of useful fun

 ## Features

- Role based access control
- Works with Ruby-On-Rails databases
+- Role and Attribute based access control
+- Works with existing Ruby-On-Rails apps
 - Automatically learns database schemas and relationships
 - Full text search and aggregations
 - Rails authentication supported (Redis, Memcache, Cookie)
@ -41,6 +49,16 @@ This compiler is what sits at the heart of Super Graph with layers of useful fun
 - Database migrations tool
 - Database seeding tool

+## Get started
+
+```
+git clone https://github.com/dosco/super-graph 
+cd ./super-graph
+make install
+
+super-graph new <app_name>
+```
+
 ## Documentation

 [supergraph.dev](https://supergraph.dev)
@ -56,7 +74,7 @@ Twitter or Discord.

 ## License

-[MIT](http://opensource.org/licenses/MIT)
+[Apache Public License 2.0](https://opensource.org/licenses/Apache-2.0)

 Copyright (c) 2019-present Vikram Rangnekar

--- a/config/allow.list
+++ b/config/allow.list
@ -152,10 +152,33 @@ mutation {
  }
 }

-query {
+query getProducts {
  products {
    id
    name
+    price
+    description
+  }
+}
+
+query {
+  deals {
+    id
+    name
+    price
+  }
+}
+
+variables {
+	"beer": "smoke"
+}
+
+query beerSearch {
+  products(search: $beer) {
+    id
+    name
+    search_rank
+    search_headline_description
  }
 }

--- a/config/dev.yml
+++ b/config/dev.yml
@ -131,16 +131,17 @@ tables:
    name: me
    table: users

+  - name: deals
+    table: products
+
 roles_query: "SELECT * FROM users WHERE id = $user_id"

 roles:
  - name: anon
    tables:
-      - name: users
      - name: products
-        limit: 10
-
        query:
+          limit: 10
          columns: ["id", "name", "description" ]
          aggregation: false

@ -153,6 +154,13 @@ roles:
        delete:
          block: false

+      - name: deals
+
+        query:
+          limit: 3
+          columns: ["name", "description" ]
+          aggregation: false
+
  - name: user
    tables:
      - name: users
@ -163,7 +171,7 @@ roles:
        query:
          limit: 50
          filters: ["{ user_id: { eq: $user_id } }"]
-          columns: ["id", "name", "description" ]
+          columns: ["id", "name", "description", "search_rank", "search_headline_description" ]
          disable_functions: false

        insert:
--- a/docs/.vuepress/components/HomeLayout.vue
+++ b/docs/.vuepress/components/HomeLayout.vue
@ -8,15 +8,11 @@
        <div class="bg-bottom bg-no-repeat bg-cover">
          <div class="text-center md:text-left pt-24">
            <h1 v-if="data.heroText !== null" class="text-5xl font-bold text-black pb-0 uppercase">
-              {{ data.heroText || $title || 'Hello' }}
+              <img src="/super-graph.png" width="250" />
            </h1>
            
-            <p class="text-2xl text-gray-700 leading-tight pb-0">
-              {{ data.tagline || $description || 'Welcome to your VuePress site' }}
-            </p>
-
-            <p class="text-lg text-gray-600 leading-tight">
-              {{ data.longTagline }}
+            <p class="text-4xl text-gray-800 leading-tight mt-1">
+              Build web products faster. Secure high performance GraphQL
            </p>

            <NavLink
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@ -12,10 +12,10 @@ module.exports = {
    nav: [
      { text: 'Docs', link: '/guide' },
      { text: 'Deploy', link: '/deploy' },
+      { text: 'Internals', link: '/internals' },
      { text: 'Github', link: 'https://github.com/dosco/super-graph' },
      { text: 'Docker', link: 'https://hub.docker.com/r/dosco/super-graph/builds' },
      { text: 'Join Chat', link: 'https://discord.gg/NKdXBc' },
-
    ],
    serviceWorker: {
      updatePopup: true
--- a/docs/.vuepress/public/super-graph.png
+++ b/docs/.vuepress/public/super-graph.png
--- a/docs/README.md
+++ b/docs/README.md
@ -26,5 +26,5 @@ features:
 - title: Free and Open Source
  details: Not a VC funded startup. Not even a startup just good old open source code

-footer: MIT Licensed | Copyright © 2018-present Vikram Rangnekar
+footer: Apache Public License 2.0 | Copyright © 2018-present Vikram Rangnekar
 ---
--- a/docs/guide.md
+++ b/docs/guide.md
@ -4,13 +4,15 @@ sidebar: auto

 # Guide to Super Graph

-Get an instant high performance GraphQL API for Postgres. No code needed. GraphQL is automatically transformed into efficient database queries. Also Designed to integrate with your Rails apps.
+Super Graph is a micro-service that instantly and without code gives you a high performance and secure GraphQL API. Your GraphQL queries are auto translated into a single fast SQL query. No more writing API code as you develop your web frontend just make the query you need and Super Graph will do the rest.
+
+Super Graph has a rich feature set like integrating with your existing Ruby on Rails apps, joining your DB with data from remote APIs, Role and Attribute based access control, Supoport for JWT tokens, DB migrations, seeding and a lot more.


 ## Features

- Role based access control
- Works with Ruby-On-Rails databases
+- Role and Attribute based access control
+- Works with existing Ruby-On-Rails apps
 - Automatically learns database schemas and relationships
 - Full text search and aggregations
 - Rails authentication supported (Redis, Memcache, Cookie)
@ -25,6 +27,7 @@ Get an instant high performance GraphQL API for Postgres. No code needed. GraphQ
 - Database migrations tool
 - Database seeding tool

+
 ## Try the demo app

 ```bash
@ -147,9 +150,13 @@ Super Graph can generate your initial app for you. The generated app will have c
 You can then add your database schema to the migrations, maybe create some seed data using the seed script and launch Super Graph. You're now good to go and can start working on your UI frontend in React, Vue or whatever.

 ```bash
-# use the below command to download and install Super Graph. You will need Go 1.13 or above
-GO111MODULE=on go get -u github.com/dosco/super-graph
+# Download and install Super Graph. You will need Go 1.13 or above
+git clone https://github.com/dosco/super-graph && cd super-graph && make install
+```

+And then create and launch you're new app
+
+```bash
 # create a new app and change to it's directory
 super-graph new blog; cd blog

@ -1396,9 +1403,6 @@ brew install yarn
 # yarn install dependencies and build the web ui
 (cd web && yarn install && yarn build)

-# generate some stuff the go code needs
-go generate ./...
-
 # do this the only the time to setup the database
 docker-compose run rails_app rake db:create db:migrate db:seed

@ -1407,6 +1411,10 @@ docker-compose up

 ```

-## MIT License
+## Learn how the code works

-MIT Licensed | Copyright © 2018-present Vikram Rangnekar
+[Super Graph codebase explained](https://supergraph.dev/internals.html)
+
+## Apache License 2.0
+
+Apache Public License 2.0 | Copyright © 2018-present Vikram Rangnekar
--- a/docs/internals.md
+++ b/docs/internals.md
@ -0,0 +1,241 @@
+---
+sidebar: auto
+---
+
+# Super Graph Codebase Explained
+
+Super Graph code is made up of a number of packages. We have done our best to keep each package small and focused. Let us begin by looking at some of these packages.
+
+1. qcode - GraphQL lexer and parser.
+2. psql - SQL generator
+3. serv - HTTP Endpoint, Configs, CLI, etc
+4. rails - Rails cookie and session store decoders
+
+## QCODE
+
+This package contains the core of the GraphQL conpiler it handling the lexing and parsing of the GraphQL query transforming it into an internal representation called
+`QCode`.
+
+This is the first step of the compiling process the `func NewCompiler(c Config)` function creates a new instance of this compiler which has it's own config. 
+
+Keep in mind QCode has no knowledge of the Database structure it is designed to be a fast GraphQL parser. Care is taken to keep memory allocations to a minimum.
+
+```go
+const (
+	opQuery
+	opMutate
+  ...
+)
+
+type QCode struct {
+	Type      QType
+  Selects   []Select
+  ...
+}
+
+type Select struct {
+	ID         int32
+	ParentID   int32
+	Args       map[string]*Node
+	Name       string
+	FieldName  string
+	Cols       []Column
+	Where      *Exp
+	OrderBy    []*OrderBy
+	DistinctOn []string
+	Paging     Paging
+	Children   []int32
+	Functions  bool
+	Allowed    map[string]struct{}
+	PresetMap  map[string]string
+	PresetList []string
+}
+```
+
+But before the incoming GraphQL query can be turned into QCode it must first be tokenzied by the lexer `lex.go`. As the tokenzier walks the bytes of the query it generates tokens `item` structs which are then consumed by the next step the parser `parse.go`.
+
+```go
+type item struct {
+	typ  itemType 
+	pos  Pos
+	end  Pos
+}
+```
+
+For exmple a simple query like `query getUser { user { id } }` will be converted into several tokens like below.
+
+```go
+item{itemQuery, 0, 4} // query
+item{itemName, 6, 12} // getUser
+item{itemObjOpen, 16, 20} // {
+...
+```
+
+These tokens are then fed into the parser `parse.go` the parser does the work of generating an abstract syntax tree (AST) from the tokens. This AST is an internal representation (data structure) and is not exposed outside the package. Sinc the AST is a tree a stack `stack.go` is used to walk the tree and generate the QCode AST. The QCode data structure is also a tree (represented as an array). This is then returned to the caller of the compile function.
+
+```go
+type Operation struct {
+	Type    parserType
+	Name    string
+	Args    []Arg
+	Fields  []Field
+}
+
+type Field struct {
+	ID        int32
+	ParentID  int32
+	Name      string
+	Alias     string
+	Args      []Arg
+	Children  []int32
+}
+```
+
+## PSQL
+
+This package is responsible for generating Postgres SQL from the QCode AST. There are various GraphQL query types (Query, Mutation, etc). And several more sub types like single root or multi-root queries, various types of mutations (insert, update delete, bulk insert, etc). This package is designed to be able to generate SQL for all of those types.
+
+In addition to QCode variable data is also passed to the compile function within this package. Variables are decoded to derive what is being inserted and what kind of insert is it single or bulk. This information is not available in the GraphQL query its passed in seperatly via variables. This package is able to put all this together and generate the right SQL code.
+
+The entry point of this package is in `query.go`. The database schema must be passed in the config object when creating a new compiler instance `NewCompiler`. The functions to extract this schema from the database are also part of this package `tables.go`. The `GetTables` functions fetches all the tables from the database and `GetColumns` fetches columns and relationship information.
+
+```go
+func NewCompiler(conf Config) *Compiler {
+	return &Compiler{conf.Schema, conf.Vars}
+}
+
+func (co *Compiler) Compile(qc *qcode.QCode, w io.Writer, vars Variables) (uint32, error) {
+	switch qc.Type {
+	case qcode.QTQuery:
+		return co.compileQuery(qc, w)
+	case qcode.QTInsert, qcode.QTUpdate, qcode.QTDelete, qcode.QTUpsert:
+		return co.compileMutation(qc, w, vars)
+	}
+
+	return 0, fmt.Errorf("Unknown operation type %d", qc.Type)
+}
+```
+
+GraphQL, input is first converted to QCode.
+
+```graphql
+query {
+  user {
+    id
+  }
+  posts {
+    title
+  }
+}
+```
+
+SQL, in reality the generated SQL is far more complex single it has to be very efficient, leverage the power of Postgres, support RBAC (Role based access control) and all of this must be done in a single SQL query.
+
+```sql
+SELECT users.id, posts.title FROM users, posts;
+```
+
+## SERV
+
+The `serv` package constains most of code that turns the above compiler into an HTTP service. It also includes authentication middleware, remote join resolvers, config parsering, database migrations and seeding commands.
+
+Another big feature that this package handles is the `allow.list` management code. In production mode parsing the allow list file and registering prepared statements to adding GraphQL queries to this file in development mode.
+
+Currently the following global variables are referrenced across the package. In future I'd prefer to move these into a context struct and pass that around instead.
+
+```go
+var (
+	logger   zerolog.Logger  // logger for everything but errors
+	errlog   zerolog.Logger  // logger for errors includes line numbers
+	conf     *config         // parsed config
+	confPath string          // path to the config file
+	db       *pgxpool.Pool   // database connection pool
+	schema   *psql.DBSchema  // database tables, columns and relationships
+	qcompile *qcode.Compiler // qcode compiler
+	pcompile *psql.Compiler  // postgres sql compiler
+)
+```
+
+## Testing
+
+There are several unit tests and benchmark tests `parse_test.go`) included. There are also scripts included for memory `pprof_cpu.sh` and cpu `pprof_cpu.sh` profiling. 
+
+```go
+// Test to ensure synthetic tables gnerate the correct SQL
+func syntheticTables(t *testing.T) {
+	gql := `query {
+		me {
+			email
+		}
+	}`
+
+	sql := `SELECT json_object_agg('me', json_0) FROM (SELECT row_to_json((SELECT "json_row_0" FROM (SELECT ) AS "json_row_0")) AS "json_0" FROM (SELECT "users"."email" FROM "users" WHERE ((("users"."id") = '{{user_id}}' :: bigint)) LIMIT ('1') :: integer) AS "users_0" LIMIT ('1') :: integer) AS "sel_0"`
+
+	resSQL, err := compileGQLToPSQL(gql, nil, "user")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if string(resSQL) != sql {
+		t.Fatal(errNotExpected)
+	}
+}
+```
+
+You can run tests within each package or across the entire app. It is usually the fastest to first write a test and then build the feature to satisfy it.
+
+```
+go test -v ./...
+```
+
+Memory profiling can help find where allocations are happining within the package code.
+
+```bash
+$ cd ./psql
+$ ./pprof_mem.sh
+goos: darwin
+goarch: amd64
+pkg: github.com/dosco/super-graph/psql
+BenchmarkCompile-8                 52567             19401 ns/op            3918 B/op         61 allocs/op
+BenchmarkCompileParallel-8        219548              5684 ns/op            3938 B/op         61 allocs/op
+PASS
+ok      github.com/dosco/super-graph/psql       2.582s
+Type: alloc_space
+Time: Nov 29, 2019 at 11:59pm (EST)
+Entering interactive mode (type "help" for commands, "o" for options)
+(pprof) top
+Showing nodes accounting for 880.59MB, 80.63% of 1092.14MB total
+Dropped 33 nodes (cum <= 5.46MB)
+Showing top 10 nodes out of 35
+      flat  flat%   sum%        cum   cum%
+      22MB  2.01%  2.01%   903.57MB 82.73%  github.com/dosco/super-graph/qcode.(*Compiler).Compile
+         0     0%  2.01%   862.98MB 79.02%  github.com/dosco/super-graph/psql.BenchmarkCompileParallel.func1
+         0     0%  2.01%   862.98MB 79.02%  testing.(*B).RunParallel.func1
+  461.95MB 42.30% 44.31%   760.53MB 69.64%  github.com/dosco/super-graph/qcode.(*Compiler).compileQuery
+  396.63MB 36.32% 80.63%   396.63MB 36.32%  github.com/dosco/super-graph/util.NewStack
+         0     0% 80.63%   252.07MB 23.08%  github.com/dosco/super-graph/qcode.(*Compiler).compileArgs
+         0     0% 80.63%   228.15MB 20.89%  testing.(*B).runN
+         0     0% 80.63%   227.63MB 20.84%  github.com/dosco/super-graph/psql.BenchmarkCompile
+         0     0% 80.63%   227.63MB 20.84%  testing.(*B).launch
+         0     0% 80.63%   187.04MB 17.13%  github.com/dosco/super-graph/psql.(*Compiler).Compile
+```
+
+## Benchmarking
+
+Most packages contain benchmark tests to ensure new features don't introduce a significant regression to performance.
+
+```bash
+$ cd ./psql
+$ go test -v -run=xx -bench=.
+goos: darwin
+goarch: amd64
+pkg: github.com/dosco/super-graph/psql
+BenchmarkCompile-8                 60775             19076 ns/op            3919 B/op         61 allocs/op
+BenchmarkCompileParallel-8        207847              5172 ns/op            3937 B/op         61 allocs/op
+PASS
+ok      github.com/dosco/super-graph/psql       2.530s
+```
+
+## Reach out
+
+If you'd like me to explain other parts of the code please reach out over Twitter or Discord. I'll keep adding to this doc as I get time.
--- a/go.mod
+++ b/go.mod
@ -3,7 +3,6 @@ module github.com/dosco/super-graph
 require (
 	github.com/GeertJohan/go.rice v1.0.0
 	github.com/Masterminds/semver v1.5.0
-	github.com/OneOfOne/xxhash v1.2.5 // indirect
 	github.com/adjust/gorails v0.0.0-20171013043634-2786ed0c03d3
 	github.com/bradfitz/gomemcache v0.0.0-20190913173617-a41fca850d0b
 	github.com/brianvoe/gofakeit v3.18.0+incompatible
@ -12,32 +11,25 @@ require (
 	github.com/dgrijalva/jwt-go v3.2.0+incompatible
 	github.com/dlclark/regexp2 v1.2.0 // indirect
 	github.com/dop251/goja v0.0.0-20190912223329-aa89e6a4c733
-	github.com/dvyukov/go-fuzz v0.0.0-20191022152526-8cb203812681 // indirect
 	github.com/fsnotify/fsnotify v1.4.7
 	github.com/garyburd/redigo v1.6.0
 	github.com/go-sourcemap/sourcemap v2.1.2+incompatible // indirect
 	github.com/gobuffalo/flect v0.1.6
-	github.com/gorilla/websocket v1.4.1
-	github.com/jackc/fake v0.0.0-20150926172116-812a484cc733 // indirect
 	github.com/jackc/pgconn v1.0.1
 	github.com/jackc/pgtype v1.0.1
-	github.com/jackc/pgx v3.6.0+incompatible
 	github.com/jackc/pgx/v4 v4.0.1
-	github.com/jackc/tern v1.8.2
 	github.com/magiconair/properties v1.8.1 // indirect
 	github.com/pelletier/go-toml v1.4.0 // indirect
 	github.com/pkg/errors v0.8.1
 	github.com/rs/zerolog v1.15.0
-	github.com/spaolacci/murmur3 v1.1.0 // indirect
 	github.com/spf13/afero v1.2.2 // indirect
 	github.com/spf13/cobra v0.0.5
-	github.com/spf13/jwalterweatherman v1.1.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/spf13/viper v1.4.0
 	github.com/valyala/fasttemplate v1.0.1
 	golang.org/x/crypto v0.0.0-20190927123631-a832865fa7ad
-	golang.org/x/sys v0.0.0-20190927073244-c990c680b611 // indirect
-	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127
+	golang.org/x/sys v0.0.0-20191128015809-6d18c012aee9 // indirect
+	gopkg.in/yaml.v2 v2.2.7 // indirect
 )

 go 1.13
--- a/go.sum
+++ b/go.sum
@ -1,34 +1,28 @@
 cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/GeertJohan/go.incremental v1.0.0 h1:7AH+pY1XUgQE4Y1HcXYaMqAI0m9yrFqo/jt0CW30vsg=
 github.com/GeertJohan/go.incremental v1.0.0/go.mod h1:6fAjUhbVuX1KcMD3c8TEgVUqmo4seqhv0i0kdATSkM0=
 github.com/GeertJohan/go.rice v1.0.0 h1:KkI6O9uMaQU3VEKaj01ulavtF7o1fWT7+pk/4voiMLQ=
 github.com/GeertJohan/go.rice v1.0.0/go.mod h1:eH6gbSOAUv07dQuZVnBmoDP8mgsM1rtixis4Tib9if0=
-github.com/Masterminds/semver v1.4.2 h1:WBLTQ37jOCzSLtXNdoo8bNM8876KhNqOKvrlGITgsTc=
-github.com/Masterminds/semver v1.4.2/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y=
 github.com/Masterminds/semver v1.5.0 h1:H65muMkzWKEuNDnfl9d70GUjFniHKHRbFPGBuZ3QEww=
 github.com/Masterminds/semver v1.5.0/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y=
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
-github.com/OneOfOne/xxhash v1.2.5 h1:zl/OfRA6nftbBK9qTohYBJ5xvw6C/oNKizR7cZGl3cI=
-github.com/OneOfOne/xxhash v1.2.5/go.mod h1:eZbhyaAYD41SGSSsnmcpxVoRiQ/MPUTjUdIIOT9Um7Q=
 github.com/adjust/gorails v0.0.0-20171013043634-2786ed0c03d3 h1:+qz9Ga6l6lKw6fgvk5RMV5HQznSLvI8Zxajwdj4FhFg=
 github.com/adjust/gorails v0.0.0-20171013043634-2786ed0c03d3/go.mod h1:FlkD11RtgMTYjVuBnb7cxoHmQGqvPpCsr2atC88nl/M=
+github.com/akavel/rsrc v0.8.0 h1:zjWn7ukO9Kc5Q62DOJCcxGpXC18RawVtYAGdz2aLlfw=
 github.com/akavel/rsrc v0.8.0/go.mod h1:uLoCtb9J+EyAqh+26kdrTgmzRBFPGOolLWKpdxkKq+c=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
 github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
-github.com/bradfitz/gomemcache v0.0.0-20180710155616-bc664df96737 h1:rRISKWyXfVxvoa702s91Zl5oREZTrR3yv+tXrrX7G/g=
-github.com/bradfitz/gomemcache v0.0.0-20180710155616-bc664df96737/go.mod h1:PmM6Mmwb0LSuEubjR8N7PtNe1KxZLtOUHtbeikc5h60=
 github.com/bradfitz/gomemcache v0.0.0-20190913173617-a41fca850d0b h1:L/QXpzIa3pOvUGt1D1lA5KjYhPBAN/3iWdP7xeFS9F0=
 github.com/bradfitz/gomemcache v0.0.0-20190913173617-a41fca850d0b/go.mod h1:H0wQNHz2YrLsuXOZozoeDmnHXkNCRmMW0gwFWDfEZDA=
 github.com/brianvoe/gofakeit v3.18.0+incompatible h1:wDOmHc9DLG4nRjUVVaxA+CEglKOW72Y5+4WNxUIkjM8=
 github.com/brianvoe/gofakeit v3.18.0+incompatible/go.mod h1:kfwdRA90vvNhPutZWfH7WPaDzUjz+CZFqG+rPkOjGOc=
 github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
 github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
-github.com/cespare/xxhash/v2 v2.0.0 h1:Eb1IiuHmi3FhT12NKfqCQXSXRqc4NTMvgJoREemrSt4=
-github.com/cespare/xxhash/v2 v2.0.0/go.mod h1:MaMeaVDXZNmTpkOyhVs3/WfjgobkbQgfrVnrr3DyZL0=
 github.com/cespare/xxhash/v2 v2.1.0 h1:yTUvW7Vhb89inJ+8irsUqiWjh8iT6sQPZiQzI6ReGkA=
 github.com/cespare/xxhash/v2 v2.1.0/go.mod h1:dgIUBU3pDso/gPgZ1osOZ0iQf77oPR28Tjxl5dIMyVM=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
@ -41,6 +35,7 @@ github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3Ee
 github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
 github.com/coreos/go-systemd v0.0.0-20190719114852-fd7a80b32e1f/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
 github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
+github.com/cpuguy83/go-md2man v1.0.10 h1:BSKMNlYxDvnunlTymqtgONjNnaRV1sTpcovwwjF22jk=
 github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
 github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
 github.com/daaku/go.zipexe v1.0.0 h1:VSOgZtH418pH9L16hC/JrgSNJbbAL26pj7lmD1+CGdY=
@ -57,8 +52,6 @@ github.com/dlclark/regexp2 v1.2.0 h1:8sAhBGEM0dRWogWqWyQeIJnxjWO6oIjl8FKqREDsGfk
 github.com/dlclark/regexp2 v1.2.0/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
 github.com/dop251/goja v0.0.0-20190912223329-aa89e6a4c733 h1:cyNc40Dx5YNEO94idePU8rhVd3dn+sd04Arh0kDBAaw=
 github.com/dop251/goja v0.0.0-20190912223329-aa89e6a4c733/go.mod h1:Mw6PkjjMXWbTj+nnj4s3QPXq1jaT0s5pC0iFD4+BOAA=
-github.com/dvyukov/go-fuzz v0.0.0-20191022152526-8cb203812681 h1:3WV5aRRj1ELP3RcLlBp/v0WJTuy47OQMkL9GIQq8QEE=
-github.com/dvyukov/go-fuzz v0.0.0-20191022152526-8cb203812681/go.mod h1:11Gm+ccJnvAhCNLlf5+cS9KjtbaD5I5zaZpFMsTHWTw=
 github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/garyburd/redigo v1.6.0 h1:0VruCpn7yAIIu7pWVClQC8wxCJEcG3nyzpMSHKi1PQc=
@ -70,8 +63,6 @@ github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V
 github.com/go-sourcemap/sourcemap v2.1.2+incompatible h1:0b/xya7BKGhXuqFESKM4oIiRo9WOt2ebz7KxfreD6ug=
 github.com/go-sourcemap/sourcemap v2.1.2+incompatible/go.mod h1:F8jJfvm2KbVjc5NqelyYJmf/v5J0dwNLS2mL4sNA1Jg=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/gobuffalo/flect v0.1.1 h1:GTZJjJufv9FxgRs1+0Soo3wj+Md3kTUmTER/YE4uINA=
-github.com/gobuffalo/flect v0.1.1/go.mod h1:8JCgGVbRjJhVgD6399mQr4fx5rRfGKVzFjbj6RE/9UI=
 github.com/gobuffalo/flect v0.1.6 h1:D7KWNRFiCknJKA495/e1BO7oxqf8tbieaLv/ehoZ/+g=
 github.com/gobuffalo/flect v0.1.6/go.mod h1:W3K3X9ksuZfir8f/LrfVtWmCDQFfayuylOJ7sz/Fj80=
 github.com/gofrs/uuid v3.2.0+incompatible h1:y12jRkkFxsd7GpqdSZ+/KCs/fJbqpEXSGd4+jfEaewE=
@ -87,8 +78,6 @@ github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/gorilla/websocket v1.4.0 h1:WDFjx/TMzVgy9VdMMQi2K2Emtwi2QcUQsztZ/zLaH/Q=
 github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
-github.com/gorilla/websocket v1.4.1 h1:q7AeDBpnBk8AogcD4DSag/Ukw/KV+YhzLj2bP5HvKCM=
-github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
 github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
@ -100,8 +89,6 @@ github.com/jackc/chunkreader v1.0.0 h1:4s39bBR8ByfqH+DKm8rQA3E1LHZWB9XWcrz8fqaZb
 github.com/jackc/chunkreader v1.0.0/go.mod h1:RT6O25fNZIuasFJRyZ4R/Y2BbhasbmZXF9QQ7T3kePo=
 github.com/jackc/chunkreader/v2 v2.0.0 h1:DUwgMQuuPnS0rhMXenUtZpqZqrR/30NWY+qQvTpSvEs=
 github.com/jackc/chunkreader/v2 v2.0.0/go.mod h1:odVSm741yZoC3dpHEUXIqA9tQRhFrgOHwnPIn9lDKlk=
-github.com/jackc/fake v0.0.0-20150926172116-812a484cc733 h1:vr3AYkKovP8uR8AvSGGUK1IDqRa5lAAvEkZG1LKaCRc=
-github.com/jackc/fake v0.0.0-20150926172116-812a484cc733/go.mod h1:WrMFNQdiFJ80sQsxDoMokWK1W5TQtxBFNpzWTD84ibQ=
 github.com/jackc/pgconn v0.0.0-20190420214824-7e0022ef6ba3/go.mod h1:jkELnwuX+w9qN5YIfX0fl88Ehu4XC3keFuOJJk9pcnA=
 github.com/jackc/pgconn v0.0.0-20190824142844-760dd75542eb/go.mod h1:lLjNuW/+OfW9/pnVKPazfWOgNfH2aPem8YQ7ilXGvJE=
 github.com/jackc/pgconn v0.0.0-20190831204454-2fabfa3c18b7/go.mod h1:ZJKsE/KZfsUgOEh9hBm+xYTstcNHg7UPMVJqRfQxq4s=
@ -126,9 +113,6 @@ github.com/jackc/pgtype v0.0.0-20190824184912-ab885b375b90/go.mod h1:KcahbBH1nCM
 github.com/jackc/pgtype v0.0.0-20190828014616-a8802b16cc59/go.mod h1:MWlu30kVJrUS8lot6TQqcg7mtthZ9T0EoIBFiJcmcyw=
 github.com/jackc/pgtype v1.0.1 h1:7GWB9n3DdnO3TIbj59wMAE9QcHPL4cy/Bbtk5P1Noow=
 github.com/jackc/pgtype v1.0.1/go.mod h1:5m2OfMh1wTK7x+Fk952IDmI4nw3nPrvtQdM0ZT4WpC0=
-github.com/jackc/pgx v0.0.0-20180217033919-55ca9db5d578/go.mod h1:0ZGrqGqkRlliWnWB4zKnWtjbSWbGkVEFm4TeybAXq+I=
-github.com/jackc/pgx v3.6.0+incompatible h1:bJeo4JdVbDAW8KB2m8XkFeo8CPipREoG37BwEoKGz+Q=
-github.com/jackc/pgx v3.6.0+incompatible/go.mod h1:0ZGrqGqkRlliWnWB4zKnWtjbSWbGkVEFm4TeybAXq+I=
 github.com/jackc/pgx/v4 v4.0.0-20190420224344-cc3461e65d96/go.mod h1:mdxmSJJuR08CZQyj1PVQBHy9XOp5p8/SHH6a0psbY9Y=
 github.com/jackc/pgx/v4 v4.0.0-20190421002000-1b8f0016e912/go.mod h1:no/Y67Jkk/9WuGR0JG/JseM9irFbnEPbuWV2EELPNuM=
 github.com/jackc/pgx/v4 v4.0.0-pre1.0.20190824185557-6972a5742186/go.mod h1:X+GQnOEnf1dqHGpw7JmHqHc1NxDoalibchSk9/RWuDc=
@ -138,8 +122,7 @@ github.com/jackc/puddle v0.0.0-20190413234325-e4ced69a3a2b/go.mod h1:m4B5Dj62Y0f
 github.com/jackc/puddle v0.0.0-20190608224051-11cab39313c9/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
 github.com/jackc/puddle v1.0.0 h1:rbjAshlgKscNa7j0jAM0uNQflis5o2XUogPMVAwtcsM=
 github.com/jackc/puddle v1.0.0/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
-github.com/jackc/tern v1.8.2 h1:+d9eK83fRS0dbf6nt+2tjILYF4FKG1O5xTFB8Lzc66U=
-github.com/jackc/tern v1.8.2/go.mod h1:AMppp2oyCT6rYnJHLLMmPWwahfFvdIVi6mr9gH81Nxs=
+github.com/jessevdk/go-flags v1.4.0 h1:4IU2WS7AumrZ/40jfhf4QVDMsQwqA7VEHozFRrGARJA=
 github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
@ -163,23 +146,25 @@ github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czP
 github.com/magiconair/properties v1.8.1 h1:ZC2Vc7/ZFkGmsVC9KvOjumD+G5lXy2RtTKyzRKO2BQ4=
 github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ=
+github.com/mattn/go-colorable v0.1.2 h1:/bC9yWikZXAL9uJdulbSfyVNIR3n3trXl+v8+1sx8mU=
 github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
 github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
 github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
 github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.9 h1:d5US/mDsogSGW37IV293h//ZFaeajb69h+EHFsv2xGg=
 github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/nkovacs/streamquote v0.0.0-20170412213628-49af9bddb229 h1:E2B8qYyeSgv5MXpmzZXRNp8IAQ4vjxIjhpAf5hv/tAg=
 github.com/nkovacs/streamquote v0.0.0-20170412213628-49af9bddb229/go.mod h1:0aYXnNPJ8l7uZxf45rWW1a/uME32OF0rhiYGNQ2oF2E=
 github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
 github.com/pelletier/go-toml v1.2.0 h1:T5zMGML61Wp+FlcbWjRDT7yAxhJNAiPPLOFECq181zc=
 github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
 github.com/pelletier/go-toml v1.4.0 h1:u3Z1r+oOXJIkxqw34zVhyPgjBsm6X2wn21NWs/HfSeg=
 github.com/pelletier/go-toml v1.4.0/go.mod h1:PN7xzY2wHTK0K9p34ErDQMlFxa51Fk0OUruD3k1mMwo=
-github.com/pkg/errors v0.0.0-20171018195549-f15c970de5b7/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
@ -199,6 +184,7 @@ github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ=
 github.com/rs/zerolog v1.13.0/go.mod h1:YbFCdg8HfsridGWAh22vktObvhZbQsZXe4/zB0OKkWU=
 github.com/rs/zerolog v1.15.0 h1:uPRuwkWF4J6fGsJ2R0Gn2jB1EQiav9k3S6CSdygQJXY=
 github.com/rs/zerolog v1.15.0/go.mod h1:xYTKnLHcpfU2225ny5qZjxnj9NvkumZYjJHlAThCjNc=
+github.com/russross/blackfriday v1.5.2 h1:HyvC0ARfnZBqnXwABFeSZHpKvJHJJfPz81GNueLj0oo=
 github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
 github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
 github.com/shopspring/decimal v0.0.0-20180709203117-cd690d0c9e24 h1:pntxY8Ary0t43dCZ5dqY4YTJCObLY1kIXl0uzMv+7DE=
@ -208,22 +194,16 @@ github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMB
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
 github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
-github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI=
-github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/spf13/afero v1.1.2 h1:m8/z1t7/fwjysjQRYbP0RD+bUIF/8tJwPdEZsI83ACI=
 github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
 github.com/spf13/afero v1.2.2 h1:5jhuqJyZCZf2JRofRvN/nIFgIWNzPa3/Vz8mYylgbWc=
 github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk=
 github.com/spf13/cast v1.3.0 h1:oget//CVOEoFewqQxwr0Ej5yjygnqGkvggSE/gB35Q8=
 github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
-github.com/spf13/cobra v0.0.0-20160114030619-9c9300901990/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
 github.com/spf13/cobra v0.0.5 h1:f0B+LkLX6DtmRH1isoNA9VTtNUK9K8xYd28JNNfOv/s=
 github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU=
 github.com/spf13/jwalterweatherman v1.0.0 h1:XHEdyB+EcvlqZamSM4ZOMGlc93t6AcsBEu9Gc1vn7yk=
 github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
-github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk=
-github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo=
-github.com/spf13/pflag v0.0.0-20151218134703-7f60f83a2c81/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
 github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
@ -247,8 +227,6 @@ github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6Kllzaw
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
 github.com/valyala/fasttemplate v1.0.1 h1:tY9CJiPnMXf1ERmG2EyK7gNUd+c6RKGD0IfU8WdUSz8=
 github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
-github.com/vaughan0/go-ini v0.0.0-20130923145212-a98ad7ee00ec h1:DGmKwyZwEB8dI7tbLt/I/gQuP559o/0FrAkHKlQM/Ks=
-github.com/vaughan0/go-ini v0.0.0-20130923145212-a98ad7ee00ec/go.mod h1:owBmyHYMLkxyrugmfwE/DLJyW8Ro9mkphwuVErQ0iUw=
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
 github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
 github.com/zenazn/goji v0.9.0/go.mod h1:7S9M489iMyHBNxwZnk9/EHS098H4/F6TATF2mIxtB1Q=
@ -258,7 +236,6 @@ go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
 go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
 go.uber.org/zap v1.9.1/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
 go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
-golang.org/x/crypto v0.0.0-20151201002508-7b85b097bf75/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9 h1:mKdxBk7AujPs8kU4m80U72y/zjbZ3UcXC7dClwKbUI0=
 golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
@ -303,8 +280,8 @@ golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456 h1:ng0gs1AKnRRuEMZoTLLlbOd+C17zUDepwGQBb/n+JVg=
 golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190927073244-c990c680b611 h1:q9u40nxWT5zRClI/uU9dHCiYGottAg6Nzz4YUQyHxdA=
-golang.org/x/sys v0.0.0-20190927073244-c990c680b611/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191128015809-6d18c012aee9 h1:ZBzSG/7F4eNKz2L3GE9o300RX0Az1Bw5HF7PDraD+qU=
+golang.org/x/sys v0.0.0-20191128015809-6d18c012aee9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
@ -335,4 +312,6 @@ gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bl
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.7 h1:VUgggvou5XRW9mHwD/yXxIYSMtY0zoKQf/v226p2nyo=
+gopkg.in/yaml.v2 v2.2.7/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
--- a/jsn/filter.go
+++ b/jsn/filter.go
@ -139,7 +139,7 @@ func Filter(w *bytes.Buffer, b []byte, keys []string) error {
 			}

 			if sk > 0 && sk < len(cb) {
-				_, err = w.Write(cb[sk:len(cb)])
+				_, err = w.Write(cb[sk:])
 			} else {
 				_, err = w.Write(cb)
 			}
--- a/jsn/fuzz_test.go
+++ b/jsn/fuzz_test.go
@ -55,6 +55,6 @@ func TestFuzzCrashers(t *testing.T) {
 	}

 	for _, f := range crashers {
-		unifiedTest([]byte(f))
+		_ = unifiedTest([]byte(f))
 	}
 }
--- a/jsn/json_test.go
+++ b/jsn/json_test.go
@ -191,11 +191,11 @@ func TestGet(t *testing.T) {
 	}

 	for i := range expected {
-		if bytes.Equal(values[i].Key, expected[i].Key) == false {
+		if !bytes.Equal(values[i].Key, expected[i].Key) {
 			t.Error(string(values[i].Key), " != ", string(expected[i].Key))
 		}

-		if bytes.Equal(values[i].Value, expected[i].Value) == false {
+		if !bytes.Equal(values[i].Value, expected[i].Value) {
 			t.Error(string(values[i].Value), " != ", string(expected[i].Value))
 		}
 	}
@ -225,7 +225,10 @@ func TestValue(t *testing.T) {

 func TestFilter1(t *testing.T) {
 	var b bytes.Buffer
-	Filter(&b, []byte(input2), []string{"id", "full_name", "embed"})
+	err := Filter(&b, []byte(input2), []string{"id", "full_name", "embed"})
+	if err != nil {
+		t.Error(err)
+	}

 	expected := `[{"id": 1,"full_name": "Sidney Stroman","embed": {"id": 8,"full_name": "Caroll Orn Sr.","email": "joannarau@hegmann.io","__twitter_id": "ABC123"}},{"id": 2,"full_name": "Jerry Dickinson"}]`

@ -238,7 +241,10 @@ func TestFilter2(t *testing.T) {
 	value := `[{"id":1,"customer_id":"cus_2TbMGf3cl0","object":"charge","amount":100,"amount_refunded":0,"date":"01/01/2019","application":null,"billing_details":{"address":"1 Infinity Drive","zipcode":"94024"}},   {"id":2,"customer_id":"cus_2TbMGf3cl0","object":"charge","amount":150,"amount_refunded":0,"date":"02/18/2019","billing_details":{"address":"1 Infinity Drive","zipcode":"94024"}},{"id":3,"customer_id":"cus_2TbMGf3cl0","object":"charge","amount":150,"amount_refunded":50,"date":"03/21/2019","billing_details":{"address":"1 Infinity Drive","zipcode":"94024"}}]`

 	var b bytes.Buffer
-	Filter(&b, []byte(value), []string{"id"})
+	err := Filter(&b, []byte(value), []string{"id"})
+	if err != nil {
+		t.Error(err)
+	}

 	expected := `[{"id":1},{"id":2},{"id":3}]`

@ -253,7 +259,7 @@ func TestStrip(t *testing.T) {

 	expected := []byte(`[{"id":1,"embed":{"id":8}},{"id":2},{"id":3},{"id":4},{"id":5},{"id":6},{"id":7},{"id":8},{"id":9},{"id":10},{"id":11},{"id":12},{"id":13}]`)

-	if bytes.Equal(value1, expected) == false {
+	if !bytes.Equal(value1, expected) {
 		t.Log(value1)
 		t.Error("[Valid path] Does not match expected json")
 	}
@ -261,7 +267,7 @@ func TestStrip(t *testing.T) {
 	path2 := [][]byte{[]byte("boo"), []byte("hoo")}
 	value2 := Strip([]byte(input3), path2)

-	if bytes.Equal(value2, []byte(input3)) == false {
+	if !bytes.Equal(value2, []byte(input3)) {
 		t.Log(value2)
 		t.Error("[Invalid path] Does not match expected json")
 	}
--- a/jsn/replace.go
+++ b/jsn/replace.go
@ -16,8 +16,12 @@ func Replace(w *bytes.Buffer, b []byte, from, to []Field) error {
 	tmap := make(map[uint64]int, len(from))

 	for i, f := range from {
-		h.Write(f.Key)
-		h.Write(f.Value)
+		if _, err := h.Write(f.Key); err != nil {
+			return err
+		}
+		if _, err := h.Write(f.Value); err != nil {
+			return err
+		}

 		tmap[h.Sum64()] = i
 		h.Reset()
@ -50,7 +54,9 @@ func Replace(w *bytes.Buffer, b []byte, from, to []Field) error {

 		case state == expectKeyClose && b[i] == '"':
 			state = expectColon
-			h.Write(b[(s + 1):i])
+			if _, err := h.Write(b[(s + 1):i]); err != nil {
+				return err
+			}
 			we = s

 		case state == expectColon && b[i] == ':':
@ -106,7 +112,9 @@ func Replace(w *bytes.Buffer, b []byte, from, to []Field) error {
 		if e != 0 {
 			e++

-			h.Write(b[s:e])
+			if _, err := h.Write(b[s:e]); err != nil {
+				return err
+			}
 			n, ok := tmap[h.Sum64()]
 			h.Reset()

--- a/jsn/validate.go
+++ b/jsn/validate.go
@ -2,7 +2,6 @@ package jsn

 import (
 	"fmt"
-	"reflect"
 	"strconv"
 	"strings"
 	"unsafe"
@ -333,15 +332,6 @@ func b2s(b []byte) string {
 	return *(*string)(unsafe.Pointer(&b))
 }

-func s2b(s string) []byte {
-	strh := (*reflect.StringHeader)(unsafe.Pointer(&s))
-	var sh reflect.SliceHeader
-	sh.Data = strh.Data
-	sh.Len = strh.Len
-	sh.Cap = strh.Len
-	return *(*[]byte)(unsafe.Pointer(&sh))
-}
-
 const maxStartEndStringLen = 80

 func startEndString(s string) string {
--- a/migrate/migrate.go
+++ b/migrate/migrate.go
@ -244,7 +244,6 @@ func (m *Migrator) AppendMigration(name, upSQL, downSQL string) {
 			UpSQL:    upSQL,
 			DownSQL:  downSQL,
 		})
-	return
 }

 // Migrate runs pending migrations
@ -315,7 +314,7 @@ func (m *Migrator) MigrateTo(targetVersion int32) (err error) {
 		if err != nil {
 			return err
 		}
-		defer tx.Rollback(ctx)
+		defer tx.Rollback(ctx) //nolint: errcheck

 		// Fire on start callback
 		if m.OnStart != nil {
@ -332,7 +331,9 @@ func (m *Migrator) MigrateTo(targetVersion int32) (err error) {
 		}

 		// Reset all database connection settings. Important to do before updating version as search_path may have been changed.
-		tx.Exec(ctx, "reset all")
+		if _, err := tx.Exec(ctx, "reset all"); err != nil {
+			return err
+		}

 		// Add one to the version
 		_, err = tx.Exec(ctx, "update "+m.versionTable+" set version=$1", sequence)
@ -352,16 +353,14 @@ func (m *Migrator) MigrateTo(targetVersion int32) (err error) {
 }

 func (m *Migrator) GetCurrentVersion() (v int32, err error) {
-	ctx := context.Background()
+	err = m.conn.QueryRow(context.Background(),
+		"select version from "+m.versionTable).Scan(&v)

-	err = m.conn.QueryRow(ctx, "select version from "+m.versionTable).Scan(&v)
 	return v, err
 }

 func (m *Migrator) ensureSchemaVersionTableExists() (err error) {
-	ctx := context.Background()
-
-	_, err = m.conn.Exec(ctx, fmt.Sprintf(`
+	_, err = m.conn.Exec(context.Background(), fmt.Sprintf(`
    create table if not exists %s(version int4 not null);

    insert into %s(version)
--- a/psql/mutate.go
+++ b/psql/mutate.go
@ -1,3 +1,4 @@
+//nolint:errcheck
 package psql

 import (
@ -19,7 +20,7 @@ func (co *Compiler) compileMutation(qc *qcode.QCode, w io.Writer, vars Variables
 	c := &compilerContext{w, qc.Selects, co}
 	root := &qc.Selects[0]

-	ti, err := c.schema.GetTable(root.Table)
+	ti, err := c.schema.GetTable(root.Name)
 	if err != nil {
 		return 0, err
 	}
--- a/psql/psql_test.go
+++ b/psql/psql_test.go
@ -27,8 +27,11 @@ func TestMain(m *testing.M) {
 			"token",
 		},
 	})
+	if err != nil {
+		log.Fatal(err)
+	}

-	qcompile.AddRole("user", "product", qcode.TRConfig{
+	err = qcompile.AddRole("user", "product", qcode.TRConfig{
 		Query: qcode.QueryConfig{
 			Columns: []string{"id", "name", "price", "users", "customers"},
 			Filters: []string{
@ -54,27 +57,39 @@ func TestMain(m *testing.M) {
 			},
 		},
 	})
+	if err != nil {
+		log.Fatal(err)
+	}

-	qcompile.AddRole("anon", "product", qcode.TRConfig{
+	err = qcompile.AddRole("anon", "product", qcode.TRConfig{
 		Query: qcode.QueryConfig{
 			Columns: []string{"id", "name"},
 		},
 	})
+	if err != nil {
+		log.Fatal(err)
+	}

-	qcompile.AddRole("anon1", "product", qcode.TRConfig{
+	err = qcompile.AddRole("anon1", "product", qcode.TRConfig{
 		Query: qcode.QueryConfig{
 			Columns:          []string{"id", "name", "price"},
 			DisableFunctions: true,
 		},
 	})
+	if err != nil {
+		log.Fatal(err)
+	}

-	qcompile.AddRole("user", "users", qcode.TRConfig{
+	err = qcompile.AddRole("user", "users", qcode.TRConfig{
 		Query: qcode.QueryConfig{
 			Columns: []string{"id", "full_name", "avatar", "email", "products"},
 		},
 	})
+	if err != nil {
+		log.Fatal(err)
+	}

-	qcompile.AddRole("bad_dude", "users", qcode.TRConfig{
+	err = qcompile.AddRole("bad_dude", "users", qcode.TRConfig{
 		Query: qcode.QueryConfig{
 			Filters:          []string{"false"},
 			DisableFunctions: true,
@ -86,8 +101,11 @@ func TestMain(m *testing.M) {
 			Filters: []string{"false"},
 		},
 	})
+	if err != nil {
+		log.Fatal(err)
+	}

-	qcompile.AddRole("user", "mes", qcode.TRConfig{
+	err = qcompile.AddRole("user", "mes", qcode.TRConfig{
 		Query: qcode.QueryConfig{
 			Columns: []string{"id", "full_name", "avatar"},
 			Filters: []string{
@ -95,8 +113,11 @@ func TestMain(m *testing.M) {
 			},
 		},
 	})
+	if err != nil {
+		log.Fatal(err)
+	}

-	qcompile.AddRole("user", "customers", qcode.TRConfig{
+	err = qcompile.AddRole("user", "customers", qcode.TRConfig{
 		Query: qcode.QueryConfig{
 			Columns: []string{"id", "email", "full_name", "products"},
 		},
@ -157,9 +178,10 @@ func TestMain(m *testing.M) {
 	}

 	schema := &DBSchema{
-		t:  make(map[string]*DBTableInfo),
-		rm: make(map[string]map[string]*DBRel),
-		al: make(map[string]struct{}),
+		ver: 110000,
+		t:   make(map[string]*DBTableInfo),
+		rm:  make(map[string]map[string]*DBRel),
+		al:  make(map[string]struct{}),
 	}

 	aliases := map[string][]string{
@ -167,7 +189,9 @@ func TestMain(m *testing.M) {
 	}

 	for i, t := range tables {
-		schema.updateSchema(t, columns[i], aliases)
+		if err := schema.updateSchema(t, columns[i], aliases); err != nil {
+			log.Fatal(err)
+		}
 	}

 	vars := NewVariables(map[string]string{
--- a/psql/query.go
+++ b/psql/query.go
@ -1,3 +1,4 @@
+//nolint:errcheck
 package psql

 import (
@ -6,10 +7,8 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"math"
 	"strings"

-	"github.com/cespare/xxhash/v2"
 	"github.com/dosco/super-graph/qcode"
 	"github.com/dosco/super-graph/util"
 )
@ -137,7 +136,7 @@ func (co *Compiler) compileQuery(qc *qcode.QCode, w io.Writer) (uint32, error) {
 				io.WriteString(c.w, `(`)
 			}

-			ti, err := c.schema.GetTable(sel.Table)
+			ti, err := c.schema.GetTable(sel.Name)
 			if err != nil {
 				return 0, err
 			}
@ -167,7 +166,7 @@ func (co *Compiler) compileQuery(qc *qcode.QCode, w io.Writer) (uint32, error) {
 		} else {
 			sel := &c.s[(id - closeBlock)]

-			ti, err := c.schema.GetTable(sel.Table)
+			ti, err := c.schema.GetTable(sel.Name)
 			if err != nil {
 				return 0, err
 			}
@ -190,6 +189,11 @@ func (co *Compiler) compileQuery(qc *qcode.QCode, w io.Writer) (uint32, error) {
 				}
 			}

+			if len(sel.Args) != 0 {
+				for _, v := range sel.Args {
+					qcode.FreeNode(v)
+				}
+			}
 		}
 	}

@ -213,7 +217,7 @@ func (c *compilerContext) processChildren(sel *qcode.Select, ti *DBTableInfo) (u
 	for _, id := range sel.Children {
 		child := &c.s[id]

-		rel, err := c.schema.GetRel(child.Table, ti.Name)
+		rel, err := c.schema.GetRel(child.Name, ti.Name)
 		if err != nil {
 			skipped |= (1 << uint(id))
 			continue
@ -249,8 +253,8 @@ func (c *compilerContext) renderSelect(sel *qcode.Select, ti *DBTableInfo) (uint
 	hasOrder := len(sel.OrderBy) != 0

 	// SELECT
-	if ti.Singular == false {
-		//fmt.Fprintf(w, `SELECT coalesce(json_agg("%s"`, c.sel.Table)
+	if !ti.Singular {
+		//fmt.Fprintf(w, `SELECT coalesce(json_agg("%s"`, c.sel.Name)
 		io.WriteString(c.w, `SELECT coalesce(json_agg("`)
 		io.WriteString(c.w, "json_")
 		int2string(c.w, sel.ID)
@ -263,7 +267,7 @@ func (c *compilerContext) renderSelect(sel *qcode.Select, ti *DBTableInfo) (uint
 			}
 		}

-		//fmt.Fprintf(w, `), '[]') AS "%s" FROM (`, c.sel.Table)
+		//fmt.Fprintf(w, `), '[]') AS "%s" FROM (`, c.sel.Name)
 		io.WriteString(c.w, `), '[]')`)
 		aliasWithID(c.w, "json", sel.ID)
 		io.WriteString(c.w, ` FROM (`)
@ -297,7 +301,7 @@ func (c *compilerContext) renderSelect(sel *qcode.Select, ti *DBTableInfo) (uint
 	io.WriteString(c.w, `)`)
 	aliasWithID(c.w, "json_row", sel.ID)

-	//fmt.Fprintf(w, `)) AS "%s"`, c.sel.Table)
+	//fmt.Fprintf(w, `)) AS "%s"`, c.sel.Name)
 	io.WriteString(c.w, `))`)
 	aliasWithID(c.w, "json", sel.ID)
 	// END-ROW-TO-JSON
@ -351,7 +355,7 @@ func (c *compilerContext) renderSelectClose(sel *qcode.Select, ti *DBTableInfo)
 		io.WriteString(c.w, `') :: integer`)
 	}

-	if ti.Singular == false {
+	if !ti.Singular {
 		//fmt.Fprintf(w, `) AS "json_agg_%d"`, c.sel.ID)
 		io.WriteString(c.w, `)`)
 		aliasWithID(c.w, "json_agg", sel.ID)
@ -366,16 +370,16 @@ func (c *compilerContext) renderLateralJoin(sel *qcode.Select) error {
 }

 func (c *compilerContext) renderLateralJoinClose(sel *qcode.Select) error {
-	//fmt.Fprintf(w, `) AS "%s_%d_join" ON ('true')`, c.sel.Table, c.sel.ID)
+	//fmt.Fprintf(w, `) AS "%s_%d_join" ON ('true')`, c.sel.Name, c.sel.ID)
 	io.WriteString(c.w, `)`)
-	aliasWithIDSuffix(c.w, sel.Table, sel.ID, "_join")
+	aliasWithIDSuffix(c.w, sel.Name, sel.ID, "_join")
 	io.WriteString(c.w, ` ON ('true')`)
 	return nil
 }

 func (c *compilerContext) renderJoin(sel *qcode.Select, ti *DBTableInfo) error {
 	parent := &c.s[sel.ParentID]
-	return c.renderJoinByName(ti.Name, parent.Table, parent.ID)
+	return c.renderJoinByName(ti.Name, parent.Name, parent.ID)
 }

 func (c *compilerContext) renderJoinByName(table, parent string, id int32) error {
@ -396,7 +400,7 @@ func (c *compilerContext) renderJoinByName(table, parent string, id int32) error
 	}

 	//fmt.Fprintf(w, ` LEFT OUTER JOIN "%s" ON (("%s"."%s") = ("%s_%d"."%s"))`,
-	//rel.Through, rel.Through, rel.ColT, c.parent.Table, c.parent.ID, rel.Col1)
+	//rel.Through, rel.Through, rel.ColT, c.parent.Name, c.parent.ID, rel.Col1)
 	io.WriteString(c.w, ` LEFT OUTER JOIN "`)
 	io.WriteString(c.w, rel.Through)
 	io.WriteString(c.w, `" ON ((`)
@ -417,7 +421,7 @@ func (c *compilerContext) renderColumns(sel *qcode.Select, ti *DBTableInfo) {
 	for _, col := range sel.Cols {
 		n := funcPrefixLen(col.Name)
 		if n != 0 {
-			if sel.Functions == false {
+			if !sel.Functions {
 				continue
 			}
 			if len(sel.Allowed) != 0 {
@ -437,7 +441,7 @@ func (c *compilerContext) renderColumns(sel *qcode.Select, ti *DBTableInfo) {
 			io.WriteString(c.w, ", ")
 		}
 		//fmt.Fprintf(w, `"%s_%d"."%s" AS "%s"`,
-		//c.sel.Table, c.sel.ID, col.Name, col.FieldName)
+		//c.sel.Name, c.sel.ID, col.Name, col.FieldName)
 		colWithTableIDAlias(c.w, ti.Name, sel.ID, col.Name, col.FieldName)
 		i++
 	}
@ -449,7 +453,7 @@ func (c *compilerContext) renderRemoteRelColumns(sel *qcode.Select, ti *DBTableI
 	for _, id := range sel.Children {
 		child := &c.s[id]

-		rel, err := c.schema.GetRel(child.Table, sel.Table)
+		rel, err := c.schema.GetRel(child.Name, sel.Name)
 		if err != nil || rel.Type != RelRemote {
 			continue
 		}
@ -457,7 +461,7 @@ func (c *compilerContext) renderRemoteRelColumns(sel *qcode.Select, ti *DBTableI
 			io.WriteString(c.w, ", ")
 		}
 		//fmt.Fprintf(w, `"%s_%d"."%s" AS "%s"`,
-		//c.sel.Table, c.sel.ID, rel.Col1, rel.Col2)
+		//c.sel.Name, c.sel.ID, rel.Col1, rel.Col2)
 		colWithTableID(c.w, ti.Name, sel.ID, rel.Col1)
 		alias(c.w, rel.Col2)
 		i++
@ -479,10 +483,10 @@ func (c *compilerContext) renderJoinedColumns(sel *qcode.Select, ti *DBTableInfo
 		childSel := &c.s[id]

 		//fmt.Fprintf(w, `"%s_%d_join"."%s" AS "%s"`,
-		//s.Table, s.ID, s.Table, s.FieldName)
+		//s.Name, s.ID, s.Name, s.FieldName)
 		//if cti.Singular {
 		io.WriteString(c.w, `"`)
-		io.WriteString(c.w, childSel.Table)
+		io.WriteString(c.w, childSel.Name)
 		io.WriteString(c.w, `_`)
 		int2string(c.w, childSel.ID)
 		io.WriteString(c.w, `_join"."json_`)
@ -516,36 +520,54 @@ func (c *compilerContext) renderBaseSelect(sel *qcode.Select, ti *DBTableInfo,
 			if isSearch {
 				switch {
 				case cn == "search_rank":
+					if len(sel.Allowed) != 0 {
+						if _, ok := sel.Allowed[cn]; !ok {
+							continue
+						}
+					}
 					cn = ti.TSVCol
 					arg := sel.Args["search"]

 					if i != 0 {
 						io.WriteString(c.w, `, `)
 					}
-					//fmt.Fprintf(w, `ts_rank("%s"."%s", to_tsquery('%s')) AS %s`,
-					//c.sel.Table, cn, arg.Val, col.Name)
+					//fmt.Fprintf(w, `ts_rank("%s"."%s", websearch_to_tsquery('%s')) AS %s`,
+					//c.sel.Name, cn, arg.Val, col.Name)
 					io.WriteString(c.w, `ts_rank(`)
 					colWithTable(c.w, ti.Name, cn)
-					io.WriteString(c.w, `, to_tsquery('`)
+					if c.schema.ver >= 110000 {
+						io.WriteString(c.w, `, websearch_to_tsquery('`)
+					} else {
+						io.WriteString(c.w, `, to_tsquery('`)
+					}
 					io.WriteString(c.w, arg.Val)
-					io.WriteString(c.w, `')`)
+					io.WriteString(c.w, `'))`)
 					alias(c.w, col.Name)
 					i++

 				case strings.HasPrefix(cn, "search_headline_"):
-					cn = cn[16:]
+					cn1 := cn[16:]
+					if len(sel.Allowed) != 0 {
+						if _, ok := sel.Allowed[cn1]; !ok {
+							continue
+						}
+					}
 					arg := sel.Args["search"]

 					if i != 0 {
 						io.WriteString(c.w, `, `)
 					}
-					//fmt.Fprintf(w, `ts_headline("%s"."%s", to_tsquery('%s')) AS %s`,
-					//c.sel.Table, cn, arg.Val, col.Name)
-					io.WriteString(c.w, `ts_headlinek(`)
-					colWithTable(c.w, ti.Name, cn)
-					io.WriteString(c.w, `, to_tsquery('`)
+					//fmt.Fprintf(w, `ts_headline("%s"."%s", websearch_to_tsquery('%s')) AS %s`,
+					//c.sel.Name, cn, arg.Val, col.Name)
+					io.WriteString(c.w, `ts_headline(`)
+					colWithTable(c.w, ti.Name, cn1)
+					if c.schema.ver >= 110000 {
+						io.WriteString(c.w, `, websearch_to_tsquery('`)
+					} else {
+						io.WriteString(c.w, `, to_tsquery('`)
+					}
 					io.WriteString(c.w, arg.Val)
-					io.WriteString(c.w, `')`)
+					io.WriteString(c.w, `'))`)
 					alias(c.w, col.Name)
 					i++

@ -576,7 +598,7 @@ func (c *compilerContext) renderBaseSelect(sel *qcode.Select, ti *DBTableInfo,
 					fn := cn[0 : pl-1]
 					isAgg = true

-					//fmt.Fprintf(w, `%s("%s"."%s") AS %s`, fn, c.sel.Table, cn, col.Name)
+					//fmt.Fprintf(w, `%s("%s"."%s") AS %s`, fn, c.sel.Name, cn, col.Name)
 					io.WriteString(c.w, fn)
 					io.WriteString(c.w, `(`)
 					colWithTable(c.w, ti.Name, cn1)
@ -588,7 +610,7 @@ func (c *compilerContext) renderBaseSelect(sel *qcode.Select, ti *DBTableInfo,
 			}
 		} else {
 			groupBy = append(groupBy, n)
-			//fmt.Fprintf(w, `"%s"."%s"`, c.sel.Table, cn)
+			//fmt.Fprintf(w, `"%s"."%s"`, c.sel.Name, cn)
 			if i != 0 {
 				io.WriteString(c.w, `, `)
 			}
@ -610,18 +632,18 @@ func (c *compilerContext) renderBaseSelect(sel *qcode.Select, ti *DBTableInfo,

 	io.WriteString(c.w, ` FROM `)

-	//fmt.Fprintf(w, ` FROM "%s"`, c.sel.Table)
+	//fmt.Fprintf(w, ` FROM "%s"`, c.sel.Name)
 	io.WriteString(c.w, `"`)
 	io.WriteString(c.w, ti.Name)
 	io.WriteString(c.w, `"`)

-	// if tn, ok := c.tmap[sel.Table]; ok {
-	// 	//fmt.Fprintf(w, ` FROM "%s" AS "%s"`, tn, c.sel.Table)
-	// 	tableWithAlias(c.w, ti.Name, sel.Table)
+	// if tn, ok := c.tmap[sel.Name]; ok {
+	// 	//fmt.Fprintf(w, ` FROM "%s" AS "%s"`, tn, c.sel.Name)
+	// 	tableWithAlias(c.w, ti.Name, sel.Name)
 	// } else {
-	// 	//fmt.Fprintf(w, ` FROM "%s"`, c.sel.Table)
+	// 	//fmt.Fprintf(w, ` FROM "%s"`, c.sel.Name)
 	// 	io.WriteString(c.w, `"`)
-	// 	io.WriteString(c.w, sel.Table)
+	// 	io.WriteString(c.w, sel.Name)
 	// 	io.WriteString(c.w, `"`)
 	// }

@ -661,7 +683,7 @@ func (c *compilerContext) renderBaseSelect(sel *qcode.Select, ti *DBTableInfo,
 				if i != 0 {
 					io.WriteString(c.w, `, `)
 				}
-				//fmt.Fprintf(w, `"%s"."%s"`, c.sel.Table, c.sel.Cols[id].Name)
+				//fmt.Fprintf(w, `"%s"."%s"`, c.sel.Name, c.sel.Cols[id].Name)
 				colWithTable(c.w, ti.Name, sel.Cols[id].Name)
 			}
 		}
@ -691,9 +713,10 @@ func (c *compilerContext) renderBaseSelect(sel *qcode.Select, ti *DBTableInfo,
 		io.WriteString(c.w, `') :: integer`)
 	}

-	//fmt.Fprintf(w, `) AS "%s_%d"`, c.sel.Table, c.sel.ID)
+	//fmt.Fprintf(w, `) AS "%s_%d"`, c.sel.Name, c.sel.ID)
 	io.WriteString(c.w, `)`)
 	aliasWithID(c.w, ti.Name, sel.ID)
+
 	return nil
 }

@ -708,17 +731,17 @@ func (c *compilerContext) renderOrderByColumns(sel *qcode.Select, ti *DBTableInf

 		col := sel.OrderBy[i].Col
 		//fmt.Fprintf(w, `"%s_%d"."%s" AS "%s_%d_%s_ob"`,
-		//c.sel.Table, c.sel.ID, c,
-		//c.sel.Table, c.sel.ID, c)
+		//c.sel.Name, c.sel.ID, c,
+		//c.sel.Name, c.sel.ID, c)
 		colWithTableID(c.w, ti.Name, sel.ID, col)
 		io.WriteString(c.w, ` AS `)
-		tableIDColSuffix(c.w, sel.Table, sel.ID, col, "_ob")
+		tableIDColSuffix(c.w, sel.Name, sel.ID, col, "_ob")
 	}
 }

 func (c *compilerContext) renderRelationship(sel *qcode.Select, ti *DBTableInfo) error {
 	parent := c.s[sel.ParentID]
-	return c.renderRelationshipByName(ti.Name, parent.Table, parent.ID)
+	return c.renderRelationshipByName(ti.Name, parent.Name, parent.ID)
 }

 func (c *compilerContext) renderRelationshipByName(table, parent string, id int32) error {
@ -730,7 +753,7 @@ func (c *compilerContext) renderRelationshipByName(table, parent string, id int3
 	switch rel.Type {
 	case RelBelongTo:
 		//fmt.Fprintf(w, `(("%s"."%s") = ("%s_%d"."%s"))`,
-		//c.sel.Table, rel.Col1, c.parent.Table, c.parent.ID, rel.Col2)
+		//c.sel.Name, rel.Col1, c.parent.Name, c.parent.ID, rel.Col2)
 		io.WriteString(c.w, `((`)
 		colWithTable(c.w, table, rel.Col1)
 		io.WriteString(c.w, `) = (`)
@ -743,7 +766,7 @@ func (c *compilerContext) renderRelationshipByName(table, parent string, id int3

 	case RelOneToMany:
 		//fmt.Fprintf(w, `(("%s"."%s") = ("%s_%d"."%s"))`,
-		//c.sel.Table, rel.Col1, c.parent.Table, c.parent.ID, rel.Col2)
+		//c.sel.Name, rel.Col1, c.parent.Name, c.parent.ID, rel.Col2)
 		io.WriteString(c.w, `((`)
 		colWithTable(c.w, table, rel.Col1)
 		io.WriteString(c.w, `) = (`)
@ -757,7 +780,7 @@ func (c *compilerContext) renderRelationshipByName(table, parent string, id int3
 	case RelOneToManyThrough:
 		// This requires the through table to be joined onto this select
 		//fmt.Fprintf(w, `(("%s"."%s") = ("%s"."%s"))`,
-		//c.sel.Table, rel.Col1, rel.Through, rel.Col2)
+		//c.sel.Name, rel.Col1, rel.Through, rel.Col2)
 		io.WriteString(c.w, `((`)
 		colWithTable(c.w, table, rel.Col1)
 		io.WriteString(c.w, `) = (`)
@ -826,7 +849,7 @@ func (c *compilerContext) renderWhere(sel *qcode.Select, ti *DBTableInfo) error
 					}

 				} else {
-					//fmt.Fprintf(w, `(("%s"."%s") `, c.sel.Table, val.Col)
+					//fmt.Fprintf(w, `(("%s"."%s") `, c.sel.Name, val.Col)
 					if err := c.renderOp(val, sel, ti); err != nil {
 						return err
 					}
@ -940,6 +963,7 @@ func (c *compilerContext) renderOp(ex *qcode.Exp, sel *qcode.Select, ti *DBTable
 			io.WriteString(c.w, `IS NOT NULL)`)
 		}
 		return nil
+
 	case qcode.OpEqID:
 		if len(ti.PrimaryCol) == 0 {
 			return fmt.Errorf("no primary key column defined for %s", ti.Name)
@ -952,17 +976,22 @@ func (c *compilerContext) renderOp(ex *qcode.Exp, sel *qcode.Select, ti *DBTable
 		colWithTable(c.w, ti.Name, ti.PrimaryCol)
 		//io.WriteString(c.w, ti.PrimaryCol)
 		io.WriteString(c.w, `) =`)
+
 	case qcode.OpTsQuery:
 		if len(ti.TSVCol) == 0 {
 			return fmt.Errorf("no tsv column defined for %s", ti.Name)
 		}
-		if col, ok = ti.Columns[ti.TSVCol]; !ok {
+		if _, ok = ti.Columns[ti.TSVCol]; !ok {
 			return fmt.Errorf("no tsv column '%s' found ", ti.TSVCol)
 		}
-		//fmt.Fprintf(w, `(("%s") @@ to_tsquery('%s'))`, c.ti.TSVCol, val.Val)
-		io.WriteString(c.w, `(("`)
-		io.WriteString(c.w, ti.TSVCol)
-		io.WriteString(c.w, `") @@ to_tsquery('`)
+		//fmt.Fprintf(w, `(("%s") @@ websearch_to_tsquery('%s'))`, c.ti.TSVCol, val.Val)
+		io.WriteString(c.w, `((`)
+		colWithTable(c.w, ti.Name, ti.TSVCol)
+		if c.schema.ver >= 110000 {
+			io.WriteString(c.w, `) @@ websearch_to_tsquery('`)
+		} else {
+			io.WriteString(c.w, `) @@ to_tsquery('`)
+		}
 		io.WriteString(c.w, ex.Val)
 		io.WriteString(c.w, `'))`)
 		return nil
@ -991,27 +1020,27 @@ func (c *compilerContext) renderOrderBy(sel *qcode.Select, ti *DBTableInfo) erro

 		switch ob.Order {
 		case qcode.OrderAsc:
-			//fmt.Fprintf(w, `"%s_%d.ob.%s" ASC`, sel.Table, sel.ID, ob.Col)
+			//fmt.Fprintf(w, `"%s_%d.ob.%s" ASC`, sel.Name, sel.ID, ob.Col)
 			tableIDColSuffix(c.w, ti.Name, sel.ID, ob.Col, "_ob")
 			io.WriteString(c.w, ` ASC`)
 		case qcode.OrderDesc:
-			//fmt.Fprintf(w, `"%s_%d.ob.%s" DESC`, sel.Table, sel.ID, ob.Col)
+			//fmt.Fprintf(w, `"%s_%d.ob.%s" DESC`, sel.Name, sel.ID, ob.Col)
 			tableIDColSuffix(c.w, ti.Name, sel.ID, ob.Col, "_ob")
 			io.WriteString(c.w, ` DESC`)
 		case qcode.OrderAscNullsFirst:
-			//fmt.Fprintf(w, `"%s_%d.ob.%s" ASC NULLS FIRST`, sel.Table, sel.ID, ob.Col)
+			//fmt.Fprintf(w, `"%s_%d.ob.%s" ASC NULLS FIRST`, sel.Name, sel.ID, ob.Col)
 			tableIDColSuffix(c.w, ti.Name, sel.ID, ob.Col, "_ob")
 			io.WriteString(c.w, ` ASC NULLS FIRST`)
 		case qcode.OrderDescNullsFirst:
-			//fmt.Fprintf(w, `%s_%d.ob.%s DESC NULLS FIRST`, sel.Table, sel.ID, ob.Col)
+			//fmt.Fprintf(w, `%s_%d.ob.%s DESC NULLS FIRST`, sel.Name, sel.ID, ob.Col)
 			tableIDColSuffix(c.w, ti.Name, sel.ID, ob.Col, "_ob")
 			io.WriteString(c.w, ` DESC NULLLS FIRST`)
 		case qcode.OrderAscNullsLast:
-			//fmt.Fprintf(w, `"%s_%d.ob.%s ASC NULLS LAST`, sel.Table, sel.ID, ob.Col)
+			//fmt.Fprintf(w, `"%s_%d.ob.%s ASC NULLS LAST`, sel.Name, sel.ID, ob.Col)
 			tableIDColSuffix(c.w, ti.Name, sel.ID, ob.Col, "_ob")
 			io.WriteString(c.w, ` ASC NULLS LAST`)
 		case qcode.OrderDescNullsLast:
-			//fmt.Fprintf(w, `%s_%d.ob.%s DESC NULLS LAST`, sel.Table, sel.ID, ob.Col)
+			//fmt.Fprintf(w, `%s_%d.ob.%s DESC NULLS LAST`, sel.Name, sel.ID, ob.Col)
 			tableIDColSuffix(c.w, ti.Name, sel.ID, ob.Col, "_ob")
 			io.WriteString(c.w, ` DESC NULLS LAST`)
 		default:
@ -1027,7 +1056,7 @@ func (c *compilerContext) renderDistinctOn(sel *qcode.Select, ti *DBTableInfo) {
 		if i != 0 {
 			io.WriteString(c.w, `, `)
 		}
-		//fmt.Fprintf(w, `"%s_%d.ob.%s"`, c.sel.Table, c.sel.ID, c.sel.DistinctOn[i])
+		//fmt.Fprintf(w, `"%s_%d.ob.%s"`, c.sel.Name, c.sel.ID, c.sel.DistinctOn[i])
 		tableIDColSuffix(c.w, ti.Name, sel.ID, sel.DistinctOn[i], "_ob")
 	}
 	io.WriteString(c.w, `) `)
@ -1139,22 +1168,6 @@ func aliasWithIDSuffix(w io.Writer, alias string, id int32, suffix string) {
 	io.WriteString(w, `"`)
 }

-func colWithAlias(w io.Writer, col, alias string) {
-	io.WriteString(w, `"`)
-	io.WriteString(w, col)
-	io.WriteString(w, `" AS "`)
-	io.WriteString(w, alias)
-	io.WriteString(w, `"`)
-}
-
-func tableWithAlias(w io.Writer, table, alias string) {
-	io.WriteString(w, `"`)
-	io.WriteString(w, table)
-	io.WriteString(w, `" AS "`)
-	io.WriteString(w, alias)
-	io.WriteString(w, `"`)
-}
-
 func colWithTable(w io.Writer, table, col string) {
 	io.WriteString(w, `"`)
 	io.WriteString(w, table)
@ -1185,20 +1198,6 @@ func colWithTableIDAlias(w io.Writer, table string, id int32, col, alias string)
 	io.WriteString(w, `"`)
 }

-func colWithTableIDSuffixAlias(w io.Writer, table string, id int32,
-	suffix, col, alias string) {
-	io.WriteString(w, `"`)
-	io.WriteString(w, table)
-	io.WriteString(w, `_`)
-	int2string(w, id)
-	io.WriteString(w, suffix)
-	io.WriteString(w, `"."`)
-	io.WriteString(w, col)
-	io.WriteString(w, `" AS "`)
-	io.WriteString(w, alias)
-	io.WriteString(w, `"`)
-}
-
 func tableIDColSuffix(w io.Writer, table string, id int32, col, suffix string) {
 	io.WriteString(w, `"`)
 	io.WriteString(w, table)
@ -1223,7 +1222,7 @@ func int2string(w io.Writer, val int32) {
 	for val2 > 0 {
 		temp *= 10
 		temp += val2 % 10
-		val2 = int32(math.Floor(float64(val2 / 10)))
+		val2 = int32(float64(val2 / 10))
 	}

 	val3 := temp
@ -1233,11 +1232,3 @@ func int2string(w io.Writer, val int32) {
 		w.Write([]byte{charset[d]})
 	}
 }
-
-func relID(h *xxhash.Digest, child, parent string) uint64 {
-	h.WriteString(child)
-	h.WriteString(parent)
-	v := h.Sum64()
-	h.Reset()
-	return v
-}
--- a/psql/query_test.go
+++ b/psql/query_test.go
@ -142,15 +142,17 @@ func fetchByID(t *testing.T) {

 func searchQuery(t *testing.T) {
 	gql := `query {
-		products(search: "Imperial") {
+		products(search: "ale") {
 			id
 			name
+			search_rank
+			search_headline_description
 		}
 	}`

-	sql := `SELECT json_object_agg('products', json_0) FROM (SELECT coalesce(json_agg("json_0"), '[]') AS "json_0" FROM (SELECT row_to_json((SELECT "json_row_0" FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name") AS "json_row_0")) AS "json_0" FROM (SELECT "products"."id", "products"."name" FROM "products" WHERE ((("products"."price") > 0) AND (("products"."price") < 8) AND (("tsv") @@ to_tsquery('Imperial'))) LIMIT ('20') :: integer) AS "products_0" LIMIT ('20') :: integer) AS "json_agg_0") AS "sel_0"`
+	sql := `SELECT json_object_agg('products', json_0) FROM (SELECT coalesce(json_agg("json_0"), '[]') AS "json_0" FROM (SELECT row_to_json((SELECT "json_row_0" FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "products_0"."search_rank" AS "search_rank", "products_0"."search_headline_description" AS "search_headline_description") AS "json_row_0")) AS "json_0" FROM (SELECT "products"."id", "products"."name", ts_rank("products"."tsv", websearch_to_tsquery('ale')) AS "search_rank", ts_headline("products"."description", websearch_to_tsquery('ale')) AS "search_headline_description" FROM "products" WHERE ((("products"."tsv") @@ websearch_to_tsquery('ale'))) LIMIT ('20') :: integer) AS "products_0" LIMIT ('20') :: integer) AS "json_agg_0") AS "sel_0"`

-	resSQL, err := compileGQLToPSQL(gql, nil, "user")
+	resSQL, err := compileGQLToPSQL(gql, nil, "admin")
 	if err != nil {
 		t.Fatal(err)
 	}
@ -171,7 +173,7 @@ func oneToMany(t *testing.T) {
 		}
 	}`

-	sql := `SELECT json_object_agg('users', json_0) FROM (SELECT coalesce(json_agg("json_0"), '[]') AS "json_0" FROM (SELECT row_to_json((SELECT "json_row_0" FROM (SELECT "users_0"."email" AS "email", "products_1_join"."json_1" AS "products") AS "json_row_0")) AS "json_0" FROM (SELECT "users"."email", "users"."id" FROM "users" LIMIT ('20') :: integer) AS "users_0" LEFT OUTER JOIN LATERAL (SELECT coalesce(json_agg("json_1"), '[]') AS "json_1" FROM (SELECT row_to_json((SELECT "json_row_1" FROM (SELECT "products_1"."name" AS "name", "products_1"."price" AS "price") AS "json_row_1")) AS "json_1" FROM (SELECT "products"."name", "products"."price" FROM "products" WHERE ((("products"."user_id") = ("users_0"."id"))) LIMIT ('20') :: integer) AS "products_1" LIMIT ('20') :: integer) AS "json_agg_1") AS "products_1_join" ON ('true') LIMIT ('20') :: integer) AS "json_agg_0") AS "sel_0"`
+	sql := `SELECT json_object_agg('users', json_0) FROM (SELECT coalesce(json_agg("json_0"), '[]') AS "json_0" FROM (SELECT row_to_json((SELECT "json_row_0" FROM (SELECT "users_0"."email" AS "email", "products_1_join"."json_1" AS "products") AS "json_row_0")) AS "json_0" FROM (SELECT "users"."email", "users"."id" FROM "users" LIMIT ('20') :: integer) AS "users_0" LEFT OUTER JOIN LATERAL (SELECT coalesce(json_agg("json_1"), '[]') AS "json_1" FROM (SELECT row_to_json((SELECT "json_row_1" FROM (SELECT "products_1"."name" AS "name", "products_1"."price" AS "price") AS "json_row_1")) AS "json_1" FROM (SELECT "products"."name", "products"."price" FROM "products" WHERE ((("products"."user_id") = ("users_0"."id")) AND (("products"."price") > 0) AND (("products"."price") < 8)) LIMIT ('20') :: integer) AS "products_1" LIMIT ('20') :: integer) AS "json_agg_1") AS "products_1_join" ON ('true') LIMIT ('20') :: integer) AS "json_agg_0") AS "sel_0"`

 	resSQL, err := compileGQLToPSQL(gql, nil, "user")
 	if err != nil {
@ -240,7 +242,7 @@ func manyToManyReverse(t *testing.T) {
 		}
 	}`

-	sql := `SELECT json_object_agg('customers', json_0) FROM (SELECT coalesce(json_agg("json_0"), '[]') AS "json_0" FROM (SELECT row_to_json((SELECT "json_row_0" FROM (SELECT "customers_0"."email" AS "email", "customers_0"."full_name" AS "full_name", "products_1_join"."json_1" AS "products") AS "json_row_0")) AS "json_0" FROM (SELECT "customers"."email", "customers"."full_name", "customers"."id" FROM "customers" LIMIT ('20') :: integer) AS "customers_0" LEFT OUTER JOIN LATERAL (SELECT coalesce(json_agg("json_1"), '[]') AS "json_1" FROM (SELECT row_to_json((SELECT "json_row_1" FROM (SELECT "products_1"."name" AS "name") AS "json_row_1")) AS "json_1" FROM (SELECT "products"."name" FROM "products" LEFT OUTER JOIN "purchases" ON (("purchases"."customer_id") = ("customers_0"."id")) WHERE ((("products"."id") = ("purchases"."product_id"))) LIMIT ('20') :: integer) AS "products_1" LIMIT ('20') :: integer) AS "json_agg_1") AS "products_1_join" ON ('true') LIMIT ('20') :: integer) AS "json_agg_0") AS "sel_0"`
+	sql := `SELECT json_object_agg('customers', json_0) FROM (SELECT coalesce(json_agg("json_0"), '[]') AS "json_0" FROM (SELECT row_to_json((SELECT "json_row_0" FROM (SELECT "customers_0"."email" AS "email", "customers_0"."full_name" AS "full_name", "products_1_join"."json_1" AS "products") AS "json_row_0")) AS "json_0" FROM (SELECT "customers"."email", "customers"."full_name", "customers"."id" FROM "customers" LIMIT ('20') :: integer) AS "customers_0" LEFT OUTER JOIN LATERAL (SELECT coalesce(json_agg("json_1"), '[]') AS "json_1" FROM (SELECT row_to_json((SELECT "json_row_1" FROM (SELECT "products_1"."name" AS "name") AS "json_row_1")) AS "json_1" FROM (SELECT "products"."name" FROM "products" LEFT OUTER JOIN "purchases" ON (("purchases"."customer_id") = ("customers_0"."id")) WHERE ((("products"."id") = ("purchases"."product_id")) AND (("products"."price") > 0) AND (("products"."price") < 8)) LIMIT ('20') :: integer) AS "products_1" LIMIT ('20') :: integer) AS "json_agg_1") AS "products_1_join" ON ('true') LIMIT ('20') :: integer) AS "json_agg_0") AS "sel_0"`

 	resSQL, err := compileGQLToPSQL(gql, nil, "user")
 	if err != nil {
--- a/psql/tables.go
+++ b/psql/tables.go
@ -3,6 +3,7 @@ package psql
 import (
 	"context"
 	"fmt"
+	"strconv"
 	"strings"

 	"github.com/gobuffalo/flect"
@ -144,9 +145,10 @@ ORDER BY id;`
 }

 type DBSchema struct {
-	t  map[string]*DBTableInfo
-	rm map[string]map[string]*DBRel
-	al map[string]struct{}
+	ver int
+	t   map[string]*DBTableInfo
+	rm  map[string]map[string]*DBRel
+	al  map[string]struct{}
 }

 type DBTableInfo struct {
@ -184,10 +186,22 @@ func NewDBSchema(db *pgxpool.Pool, aliases map[string][]string) (*DBSchema, erro

 	dbc, err := db.Acquire(context.Background())
 	if err != nil {
-		return nil, fmt.Errorf("error acquiring connection from pool")
+		return nil, fmt.Errorf("error acquiring connection from pool: %w", err)
 	}
 	defer dbc.Release()

+	var version string
+
+	err = dbc.QueryRow(context.Background(), `SHOW server_version_num`).Scan(&version)
+	if err != nil {
+		return nil, fmt.Errorf("error fetching version: %w", err)
+	}
+
+	schema.ver, err = strconv.Atoi(version)
+	if err != nil {
+		return nil, err
+	}
+
 	tables, err := GetTables(dbc)
 	if err != nil {
 		return nil, err
@ -199,7 +213,9 @@ func NewDBSchema(db *pgxpool.Pool, aliases map[string][]string) (*DBSchema, erro
 			return nil, err
 		}

-		schema.updateSchema(t, cols, aliases)
+		if err := schema.updateSchema(t, cols, aliases); err != nil {
+			return nil, err
+		}
 	}

 	return schema, nil
@ -208,7 +224,7 @@ func NewDBSchema(db *pgxpool.Pool, aliases map[string][]string) (*DBSchema, erro
 func (s *DBSchema) updateSchema(
 	t *DBTable,
 	cols []*DBColumn,
-	aliases map[string][]string) {
+	aliases map[string][]string) error {

 	// Foreign key columns in current table
 	colByID := make(map[int16]*DBColumn)
@ -281,12 +297,16 @@ func (s *DBSchema) updateSchema(
 			// Belongs-to relation between current table and the
 			// table in the foreign key
 			rel1 := &DBRel{RelBelongTo, "", "", c.Name, fc.Name}
-			s.SetRel(ct, ft, rel1)
+			if err := s.SetRel(ct, ft, rel1); err != nil {
+				return err
+			}

 			// One-to-many relation between the foreign key table and the
 			// the current table
 			rel2 := &DBRel{RelOneToMany, "", "", fc.Name, c.Name}
-			s.SetRel(ft, ct, rel2)
+			if err := s.SetRel(ft, ct, rel2); err != nil {
+				return err
+			}

 			jcols = append(jcols, c)
 		}
@ -301,42 +321,54 @@ func (s *DBSchema) updateSchema(
 	if len(jcols) > 1 {
 		for i := range jcols {
 			for n := range jcols {
-				if n != i {
-					s.updateSchemaOTMT(ct, jcols[i], jcols[n], colByID)
+				if n == i {
+					continue
+				}
+				err := s.updateSchemaOTMT(ct, jcols[i], jcols[n], colByID)
+				if err != nil {
+					return err
 				}
 			}
 		}
 	}
+
+	return nil
 }

 func (s *DBSchema) updateSchemaOTMT(
 	ct string,
 	col1, col2 *DBColumn,
-	colByID map[int16]*DBColumn) {
+	colByID map[int16]*DBColumn) error {

 	t1 := strings.ToLower(col1.FKeyTable)
 	t2 := strings.ToLower(col2.FKeyTable)

 	fc1, ok := colByID[col1.FKeyColID[0]]
 	if !ok {
-		return
+		return fmt.Errorf("expected column id '%d' not found", col1.FKeyColID[0])
 	}
 	fc2, ok := colByID[col2.FKeyColID[0]]
 	if !ok {
-		return
+		return fmt.Errorf("expected column id '%d' not found", col2.FKeyColID[0])
 	}

 	// One-to-many-through relation between 1nd foreign key table and the
 	// 2nd foreign key table
 	//rel1 := &DBRel{RelOneToManyThrough, ct, fc1.Name, col1.Name}
 	rel1 := &DBRel{RelOneToManyThrough, ct, col2.Name, fc2.Name, col1.Name}
-	s.SetRel(t1, t2, rel1)
+	if err := s.SetRel(t1, t2, rel1); err != nil {
+		return err
+	}

 	// One-to-many-through relation between 2nd foreign key table and the
 	// 1nd foreign key table
 	//rel2 := &DBRel{RelOneToManyThrough, ct, col2.Name, fc2.Name}
 	rel2 := &DBRel{RelOneToManyThrough, ct, col1.Name, fc1.Name, col2.Name}
-	s.SetRel(t2, t1, rel2)
+	if err := s.SetRel(t2, t1, rel2); err != nil {
+		return err
+	}
+
+	return nil
 }

 func (s *DBSchema) GetTable(table string) (*DBTableInfo, error) {
--- a/qcode/config.go
+++ b/qcode/config.go
@ -8,7 +8,6 @@ import (

 type Config struct {
 	Blocklist []string
-	KeepArgs  bool
 }

 type QueryConfig struct {
@ -116,7 +115,7 @@ func listToMap(list []string) map[string]struct{} {

 func mapToList(m map[string]string) []string {
 	list := []string{}
-	for k, _ := range m {
+	for k := range m {
 		list = append(list, strings.ToLower(k))
 	}
 	sort.Strings(list)
--- a/qcode/lex.go
+++ b/qcode/lex.go
@ -461,7 +461,7 @@ func (i *item) String() string {
 	case itemStringVal:
 		v = "string"
 	}
-	return fmt.Sprintf("%s", v)
+	return v
 }

 /*
--- a/qcode/parse.go
+++ b/qcode/parse.go
@ -26,13 +26,13 @@ const (
 	opQuery
 	opMutate
 	opSub
-	nodeStr
-	nodeInt
-	nodeFloat
-	nodeBool
-	nodeObj
-	nodeList
-	nodeVar
+	NodeStr
+	NodeInt
+	NodeFloat
+	NodeBool
+	NodeObj
+	NodeList
+	NodeVar
 )

 type Operation struct {
@ -85,7 +85,6 @@ type Parser struct {
 	input []byte // the string being scanned
 	pos   int
 	items []item
-	depth int
 	err   error
 }

@ -185,15 +184,6 @@ func (p *Parser) ignore() {
 	p.pos = n
 }

-func (p *Parser) current() item {
-	return p.items[p.pos]
-}
-
-func (p *Parser) eof() bool {
-	n := p.pos + 1
-	return p.items[n].typ == itemEOF
-}
-
 func (p *Parser) peek(types ...itemType) bool {
 	n := p.pos + 1
 	if p.items[n].typ == itemEOF {
@ -250,7 +240,7 @@ func (p *Parser) parseOp() (*Operation, error) {
 		p.ignore()

 		for n := 0; n < 10; n++ {
-			if p.peek(itemName) == false {
+			if !p.peek(itemName) {
 				break
 			}

@ -275,7 +265,7 @@ func (p *Parser) parseQueryOp() (*Operation, error) {
 	var err error

 	for n := 0; n < 10; n++ {
-		if p.peek(itemName) == false {
+		if !p.peek(itemName) {
 			break
 		}

@ -306,7 +296,7 @@ func (p *Parser) parseFields(fields []Field) ([]Field, error) {
 			continue
 		}

-		if p.peek(itemName) == false {
+		if !p.peek(itemName) {
 			return nil, errors.New("expecting an alias or field name")
 		}

@ -374,13 +364,13 @@ func (p *Parser) parseArgs(args []Arg) ([]Arg, error) {
 			p.ignore()
 			break
 		}
-		if p.peek(itemName) == false {
+		if !p.peek(itemName) {
 			return nil, errors.New("expecting an argument name")
 		}
 		args = append(args, Arg{Name: p.val(p.next())})
 		arg := &args[(len(args) - 1)]

-		if p.peek(itemColon) == false {
+		if !p.peek(itemColon) {
 			return nil, errors.New("missing ':' after argument name")
 		}
 		p.ignore()
@ -423,7 +413,7 @@ func (p *Parser) parseList() (*Node, error) {
 		return nil, errors.New("List cannot be empty")
 	}

-	parent.Type = nodeList
+	parent.Type = NodeList
 	parent.Children = nodes

 	return parent, nil
@ -441,12 +431,12 @@ func (p *Parser) parseObj() (*Node, error) {
 			break
 		}

-		if p.peek(itemName) == false {
+		if !p.peek(itemName) {
 			return nil, errors.New("expecting an argument name")
 		}
 		nodeName := p.val(p.next())

-		if p.peek(itemColon) == false {
+		if !p.peek(itemColon) {
 			return nil, errors.New("missing ':' after Field argument name")
 		}
 		p.ignore()
@ -460,7 +450,7 @@ func (p *Parser) parseObj() (*Node, error) {
 		nodes = append(nodes, node)
 	}

-	parent.Type = nodeObj
+	parent.Type = NodeObj
 	parent.Children = nodes

 	return parent, nil
@ -483,17 +473,17 @@ func (p *Parser) parseValue() (*Node, error) {

 	switch item.typ {
 	case itemIntVal:
-		node.Type = nodeInt
+		node.Type = NodeInt
 	case itemFloatVal:
-		node.Type = nodeFloat
+		node.Type = NodeFloat
 	case itemStringVal:
-		node.Type = nodeStr
+		node.Type = NodeStr
 	case itemBoolVal:
-		node.Type = nodeBool
+		node.Type = NodeBool
 	case itemName:
-		node.Type = nodeStr
+		node.Type = NodeStr
 	case itemVariable:
-		node.Type = nodeVar
+		node.Type = NodeVar
 	default:
 		return nil, fmt.Errorf("expecting a number, string, object, list or variable as an argument value (not %s)", p.val(p.next()))
 	}
@ -524,19 +514,19 @@ func (t parserType) String() string {
 		v = "mutation"
 	case opSub:
 		v = "subscription"
-	case nodeStr:
+	case NodeStr:
 		v = "node-string"
-	case nodeInt:
+	case NodeInt:
 		v = "node-int"
-	case nodeFloat:
+	case NodeFloat:
 		v = "node-float"
-	case nodeBool:
+	case NodeBool:
 		v = "node-bool"
-	case nodeVar:
+	case NodeVar:
 		v = "node-var"
-	case nodeObj:
+	case NodeObj:
 		v = "node-obj"
-	case nodeList:
+	case NodeList:
 		v = "node-list"
 	}
 	return fmt.Sprintf("<%s>", v)
--- a/qcode/parse_test.go
+++ b/qcode/parse_test.go
@ -7,13 +7,16 @@ import (

 func TestCompile1(t *testing.T) {
 	qc, _ := NewCompiler(Config{})
-	qc.AddRole("user", "product", TRConfig{
+	err := qc.AddRole("user", "product", TRConfig{
 		Query: QueryConfig{
 			Columns: []string{"id", "Name"},
 		},
 	})
+	if err != nil {
+		t.Error(err)
+	}

-	_, err := qc.Compile([]byte(`
+	_, err = qc.Compile([]byte(`
 	{ product(id: 15) {
 			id
 			name
@ -26,13 +29,16 @@ func TestCompile1(t *testing.T) {

 func TestCompile2(t *testing.T) {
 	qc, _ := NewCompiler(Config{})
-	qc.AddRole("user", "product", TRConfig{
+	err := qc.AddRole("user", "product", TRConfig{
 		Query: QueryConfig{
 			Columns: []string{"ID"},
 		},
 	})
+	if err != nil {
+		t.Error(err)
+	}

-	_, err := qc.Compile([]byte(`
+	_, err = qc.Compile([]byte(`
 	query { product(id: 15) {
 			id
 			name
@ -45,13 +51,16 @@ func TestCompile2(t *testing.T) {

 func TestCompile3(t *testing.T) {
 	qc, _ := NewCompiler(Config{})
-	qc.AddRole("user", "product", TRConfig{
+	err := qc.AddRole("user", "product", TRConfig{
 		Query: QueryConfig{
 			Columns: []string{"ID"},
 		},
 	})
+	if err != nil {
+		t.Error(err)
+	}

-	_, err := qc.Compile([]byte(`
+	_, err = qc.Compile([]byte(`
 	mutation {
 		product(id: 15, name: "Test") {
 			id
--- a/qcode/qcode.go
+++ b/qcode/qcode.go
@ -39,7 +39,7 @@ type Select struct {
 	ID         int32
 	ParentID   int32
 	Args       map[string]*Node
-	Table      string
+	Name       string
 	FieldName  string
 	Cols       []Column
 	Where      *Exp
@ -157,7 +157,6 @@ const (
 type Compiler struct {
 	tr map[string]map[string]*trval
 	bl map[string]struct{}
-	ka bool
 }

 var expPool = sync.Pool{
@ -165,7 +164,7 @@ var expPool = sync.Pool{
 }

 func NewCompiler(c Config) (*Compiler, error) {
-	co := &Compiler{ka: c.KeepArgs}
+	co := &Compiler{}
 	co.tr = make(map[string]map[string]*trval)
 	co.bl = make(map[string]struct{}, len(c.Blocklist))

@ -301,7 +300,7 @@ func (com *Compiler) compileQuery(qc *QCode, op *Operation, role string) error {
 		selects = append(selects, Select{
 			ID:        id,
 			ParentID:  parentID,
-			Table:     field.Name,
+			Name:      field.Name,
 			Children:  make([]int32, 0, 5),
 			Allowed:   trv.allowedColumns(action),
 			Functions: true,
@ -325,7 +324,7 @@ func (com *Compiler) compileQuery(qc *QCode, op *Operation, role string) error {
 		if len(field.Alias) != 0 {
 			s.FieldName = field.Alias
 		} else {
-			s.FieldName = s.Table
+			s.FieldName = s.Name
 		}

 		err := com.compileArgs(qc, s, field.Args)
@ -334,9 +333,10 @@ func (com *Compiler) compileQuery(qc *QCode, op *Operation, role string) error {
 		}

 		// Order is important addFilters must come after compileArgs
+		com.addFilters(qc, s, role)
+
 		if s.ParentID == -1 {
 			qc.Roots = append(qc.Roots, s.ID)
-			com.addFilters(qc, s, role)
 		} else {
 			p := &selects[s.ParentID]
 			p.Children = append(p.Children, s.ID)
@ -379,11 +379,13 @@ func (com *Compiler) compileQuery(qc *QCode, op *Operation, role string) error {
 	return nil
 }

-func (com *Compiler) addFilters(qc *QCode, root *Select, role string) {
+func (com *Compiler) addFilters(qc *QCode, sel *Select, role string) {
 	var fil *Exp

-	if trv, ok := com.tr[role][root.Table]; ok {
+	if trv, ok := com.tr[role][sel.Name]; ok {
 		fil = trv.filter(qc.Type)
+	} else {
+		return
 	}

 	if fil == nil {
@ -393,60 +395,61 @@ func (com *Compiler) addFilters(qc *QCode, root *Select, role string) {
 	switch fil.Op {
 	case OpNop:
 	case OpFalse:
-		root.Where = fil
+		sel.Where = fil

 	default:
-		if root.Where != nil {
-			ow := root.Where
+		if sel.Where != nil {
+			ow := sel.Where

-			root.Where = expPool.Get().(*Exp)
-			root.Where.Reset()
-			root.Where.Op = OpAnd
-			root.Where.Children = root.Where.childrenA[:2]
-			root.Where.Children[0] = fil
-			root.Where.Children[1] = ow
+			sel.Where = expPool.Get().(*Exp)
+			sel.Where.Reset()
+			sel.Where.Op = OpAnd
+			sel.Where.Children = sel.Where.childrenA[:2]
+			sel.Where.Children[0] = fil
+			sel.Where.Children[1] = ow
 		} else {
-			root.Where = fil
+			sel.Where = fil
 		}
 	}
 }

 func (com *Compiler) compileArgs(qc *QCode, sel *Select, args []Arg) error {
 	var err error
-
-	if com.ka {
-		sel.Args = make(map[string]*Node, len(args))
-	}
+	var ka bool

 	for i := range args {
 		arg := &args[i]

 		switch arg.Name {
 		case "id":
-			err = com.compileArgID(sel, arg)
+			err, ka = com.compileArgID(sel, arg)
+
 		case "search":
-			err = com.compileArgSearch(sel, arg)
+			err, ka = com.compileArgSearch(sel, arg)
+
 		case "where":
-			err = com.compileArgWhere(sel, arg)
+			err, ka = com.compileArgWhere(sel, arg)
+
 		case "orderby", "order_by", "order":
-			err = com.compileArgOrderBy(sel, arg)
+			err, ka = com.compileArgOrderBy(sel, arg)
+
 		case "distinct_on", "distinct":
-			err = com.compileArgDistinctOn(sel, arg)
+			err, ka = com.compileArgDistinctOn(sel, arg)
+
 		case "limit":
-			err = com.compileArgLimit(sel, arg)
+			err, ka = com.compileArgLimit(sel, arg)
+
 		case "offset":
-			err = com.compileArgOffset(sel, arg)
+			err, ka = com.compileArgOffset(sel, arg)
+		}
+
+		if !ka {
+			nodePool.Put(arg.Val)
 		}

 		if err != nil {
 			return err
 		}
-
-		if sel.Args != nil {
-			sel.Args[arg.Name] = arg.Val
-		} else {
-			nodePool.Put(arg.Val)
-		}
 	}

 	return nil
@ -454,7 +457,7 @@ func (com *Compiler) compileArgs(qc *QCode, sel *Select, args []Arg) error {

 func (com *Compiler) setMutationType(qc *QCode, args []Arg) error {
 	setActionVar := func(arg *Arg) error {
-		if arg.Val.Type != nodeVar {
+		if arg.Val.Type != NodeVar {
 			return fmt.Errorf("value for argument '%s' must be a variable", arg.Name)
 		}
 		qc.ActionVar = arg.Val.Val
@ -477,7 +480,7 @@ func (com *Compiler) setMutationType(qc *QCode, args []Arg) error {
 		case "delete":
 			qc.Type = QTDelete

-			if arg.Val.Type != nodeBool {
+			if arg.Val.Type != NodeBool {
 				return fmt.Errorf("value for argument '%s' must be a boolean", arg.Name)
 			}

@ -492,7 +495,7 @@ func (com *Compiler) setMutationType(qc *QCode, args []Arg) error {
 }

 func (com *Compiler) compileArgObj(st *util.Stack, arg *Arg) (*Exp, error) {
-	if arg.Val.Type != nodeObj {
+	if arg.Val.Type != NodeObj {
 		return nil, fmt.Errorf("expecting an object")
 	}

@ -544,11 +547,6 @@ func (com *Compiler) compileArgNode(st *util.Stack, node *Node, usePool bool) (*
 		} else {
 			node.exp.Children = append(node.exp.Children, ex)
 		}
-
-	}
-
-	if com.ka {
-		return root, nil
 	}

 	pushChild(st, nil, node)
@ -569,13 +567,13 @@ func (com *Compiler) compileArgNode(st *util.Stack, node *Node, usePool bool) (*
 	return root, nil
 }

-func (com *Compiler) compileArgID(sel *Select, arg *Arg) error {
+func (com *Compiler) compileArgID(sel *Select, arg *Arg) (error, bool) {
 	if sel.ID != 0 {
-		return nil
+		return nil, false
 	}

 	if sel.Where != nil && sel.Where.Op == OpEqID {
-		return nil
+		return nil, false
 	}

 	ex := expPool.Get().(*Exp)
@ -585,30 +583,41 @@ func (com *Compiler) compileArgID(sel *Select, arg *Arg) error {
 	ex.Val = arg.Val.Val

 	switch arg.Val.Type {
-	case nodeStr:
+	case NodeStr:
 		ex.Type = ValStr
-	case nodeInt:
+	case NodeInt:
 		ex.Type = ValInt
-	case nodeFloat:
+	case NodeFloat:
 		ex.Type = ValFloat
-	case nodeVar:
+	case NodeVar:
 		ex.Type = ValVar
 	default:
-		return fmt.Errorf("expecting a string, int, float or variable")
+		return fmt.Errorf("expecting a string, int, float or variable"), false
 	}

 	sel.Where = ex
-	return nil
+	return nil, false
 }

-func (com *Compiler) compileArgSearch(sel *Select, arg *Arg) error {
+func (com *Compiler) compileArgSearch(sel *Select, arg *Arg) (error, bool) {
 	ex := expPool.Get().(*Exp)
 	ex.Reset()

 	ex.Op = OpTsQuery
-	ex.Type = ValStr
 	ex.Val = arg.Val.Val

+	if arg.Val.Type == NodeVar {
+		ex.Type = ValVar
+	} else {
+		ex.Type = ValStr
+	}
+
+	if sel.Args == nil {
+		sel.Args = make(map[string]*Node)
+	}
+
+	sel.Args[arg.Name] = arg.Val
+
 	if sel.Where != nil {
 		ow := sel.Where

@ -621,16 +630,16 @@ func (com *Compiler) compileArgSearch(sel *Select, arg *Arg) error {
 	} else {
 		sel.Where = ex
 	}
-	return nil
+	return nil, true
 }

-func (com *Compiler) compileArgWhere(sel *Select, arg *Arg) error {
+func (com *Compiler) compileArgWhere(sel *Select, arg *Arg) (error, bool) {
 	st := util.NewStack()
 	var err error

 	ex, err := com.compileArgObj(st, arg)
 	if err != nil {
-		return err
+		return err, false
 	}

 	if sel.Where != nil {
@ -646,12 +655,12 @@ func (com *Compiler) compileArgWhere(sel *Select, arg *Arg) error {
 		sel.Where = ex
 	}

-	return nil
+	return nil, false
 }

-func (com *Compiler) compileArgOrderBy(sel *Select, arg *Arg) error {
-	if arg.Val.Type != nodeObj {
-		return fmt.Errorf("expecting an object")
+func (com *Compiler) compileArgOrderBy(sel *Select, arg *Arg) (error, bool) {
+	if arg.Val.Type != NodeObj {
+		return fmt.Errorf("expecting an object"), false
 	}

 	st := util.NewStack()
@ -669,23 +678,19 @@ func (com *Compiler) compileArgOrderBy(sel *Select, arg *Arg) error {
 		node, ok := intf.(*Node)

 		if !ok || node == nil {
-			return fmt.Errorf("17: unexpected value %v (%t)", intf, intf)
+			return fmt.Errorf("17: unexpected value %v (%t)", intf, intf), false
 		}

 		if _, ok := com.bl[node.Name]; ok {
-			if !com.ka {
-				nodePool.Put(node)
-			}
+			nodePool.Put(node)
 			continue
 		}

-		if node.Type == nodeObj {
+		if node.Type == NodeObj {
 			for i := range node.Children {
 				st.Push(node.Children[i])
 			}
-			if !com.ka {
-				nodePool.Put(node)
-			}
+			nodePool.Put(node)
 			continue
 		}

@ -705,65 +710,60 @@ func (com *Compiler) compileArgOrderBy(sel *Select, arg *Arg) error {
 		case "desc_nulls_last":
 			ob.Order = OrderDescNullsLast
 		default:
-			return fmt.Errorf("valid values include asc, desc, asc_nulls_first and desc_nulls_first")
+			return fmt.Errorf("valid values include asc, desc, asc_nulls_first and desc_nulls_first"), false
 		}

 		setOrderByColName(ob, node)
 		sel.OrderBy = append(sel.OrderBy, ob)
-
-		if !com.ka {
-			nodePool.Put(node)
-		}
+		nodePool.Put(node)
 	}
-	return nil
+	return nil, false
 }

-func (com *Compiler) compileArgDistinctOn(sel *Select, arg *Arg) error {
+func (com *Compiler) compileArgDistinctOn(sel *Select, arg *Arg) (error, bool) {
 	node := arg.Val

 	if _, ok := com.bl[node.Name]; ok {
-		return nil
+		return nil, false
 	}

-	if node.Type != nodeList && node.Type != nodeStr {
-		return fmt.Errorf("expecting a list of strings or just a string")
+	if node.Type != NodeList && node.Type != NodeStr {
+		return fmt.Errorf("expecting a list of strings or just a string"), false
 	}

-	if node.Type == nodeStr {
+	if node.Type == NodeStr {
 		sel.DistinctOn = append(sel.DistinctOn, node.Val)
 	}

 	for i := range node.Children {
 		sel.DistinctOn = append(sel.DistinctOn, node.Children[i].Val)
-		if !com.ka {
-			nodePool.Put(node.Children[i])
-		}
+		nodePool.Put(node.Children[i])
 	}

-	return nil
+	return nil, false
 }

-func (com *Compiler) compileArgLimit(sel *Select, arg *Arg) error {
+func (com *Compiler) compileArgLimit(sel *Select, arg *Arg) (error, bool) {
 	node := arg.Val

-	if node.Type != nodeInt {
-		return fmt.Errorf("expecting an integer")
+	if node.Type != NodeInt {
+		return fmt.Errorf("expecting an integer"), false
 	}

 	sel.Paging.Limit = node.Val

-	return nil
+	return nil, false
 }

-func (com *Compiler) compileArgOffset(sel *Select, arg *Arg) error {
+func (com *Compiler) compileArgOffset(sel *Select, arg *Arg) (error, bool) {
 	node := arg.Val

-	if node.Type != nodeInt {
-		return fmt.Errorf("expecting an integer")
+	if node.Type != NodeInt {
+		return fmt.Errorf("expecting an integer"), false
 	}

 	sel.Paging.Offset = node.Val
-	return nil
+	return nil, false
 }

 var zeroTrv = &trval{}
@ -878,17 +878,17 @@ func newExp(st *util.Stack, node *Node, usePool bool) (*Exp, error) {

 	if ex.Op != OpAnd && ex.Op != OpOr && ex.Op != OpNot {
 		switch node.Type {
-		case nodeStr:
+		case NodeStr:
 			ex.Type = ValStr
-		case nodeInt:
+		case NodeInt:
 			ex.Type = ValInt
-		case nodeBool:
+		case NodeBool:
 			ex.Type = ValBool
-		case nodeFloat:
+		case NodeFloat:
 			ex.Type = ValFloat
-		case nodeList:
+		case NodeList:
 			ex.Type = ValList
-		case nodeVar:
+		case NodeVar:
 			ex.Type = ValVar
 		default:
 			return nil, fmt.Errorf("[Where] valid values include string, int, float, boolean and list: %s", node.Type)
@ -902,13 +902,13 @@ func newExp(st *util.Stack, node *Node, usePool bool) (*Exp, error) {
 func setListVal(ex *Exp, node *Node) {
 	if len(node.Children) != 0 {
 		switch node.Children[0].Type {
-		case nodeStr:
+		case NodeStr:
 			ex.ListType = ValStr
-		case nodeInt:
+		case NodeInt:
 			ex.ListType = ValInt
-		case nodeBool:
+		case NodeBool:
 			ex.ListType = ValBool
-		case nodeFloat:
+		case NodeFloat:
 			ex.ListType = ValFloat
 		}
 	}
@ -921,7 +921,7 @@ func setWhereColName(ex *Exp, node *Node) {
 	var list []string

 	for n := node.Parent; n != nil; n = n.Parent {
-		if n.Type != nodeObj {
+		if n.Type != NodeObj {
 			continue
 		}
 		if len(n.Name) != 0 {
--- a/serv/allow.go
+++ b/serv/allow.go
@ -18,6 +18,8 @@ const (
 )

 type allowItem struct {
+	name string
+	hash string
 	uri  string
 	gql  string
 	vars json.RawMessage
@ -94,7 +96,7 @@ func initAllowList(cpath string) {
 }

 func (al *allowList) add(req *gqlReq) {
-	if al.active == false || len(req.ref) == 0 || len(req.Query) == 0 {
+	if len(req.ref) == 0 || len(req.Query) == 0 {
 		return
 	}

@ -119,11 +121,39 @@ func (al *allowList) add(req *gqlReq) {
 	}
 }

-func (al *allowList) load() {
-	if al.active == false {
-		return
+func (al *allowList) upsert(query, vars []byte, uri string) {
+	q := string(query)
+	hash := gqlHash(q, vars, "")
+	name := gqlName(q)
+
+	var key string
+
+	if len(name) == 0 {
+		key = hash
+	} else {
+		key = name
 	}

+	if i, ok := al.index[key]; !ok {
+		al.list = append(al.list, &allowItem{
+			name: name,
+			hash: hash,
+			uri:  uri,
+			gql:  q,
+			vars: vars,
+		})
+		al.index[key] = len(al.list) - 1
+	} else {
+		item := al.list[i]
+		item.name = name
+		item.hash = hash
+		item.gql = q
+		item.vars = vars
+
+	}
+}
+
+func (al *allowList) load() {
 	b, err := ioutil.ReadFile(al.filepath)
 	if err != nil {
 		log.Fatal(err)
@ -172,21 +202,7 @@ func (al *allowList) load() {

 			if c == 0 {
 				if ty == AL_QUERY {
-					q := string(b[s:(e + 1)])
-					key := gqlHash(q, varBytes, "")
-
-					if idx, ok := al.index[key]; !ok {
-						al.list = append(al.list, &allowItem{
-							uri:  uri,
-							gql:  q,
-							vars: varBytes,
-						})
-						al.index[key] = len(al.list) - 1
-					} else {
-						item := al.list[idx]
-						item.gql = q
-						item.vars = varBytes
-					}
+					al.upsert(b[s:(e+1)], varBytes, uri)
 					varBytes = nil

 				} else if ty == AL_VARS {
@ -204,19 +220,35 @@ func (al *allowList) load() {
 }

 func (al *allowList) save(item *allowItem) {
-	if al.active == false {
-		return
+	var err error
+
+	item.hash = gqlHash(item.gql, item.vars, "")
+	item.name = gqlName(item.gql)
+
+	if len(item.name) == 0 {
+		key := item.hash
+
+		if _, ok := al.index[key]; ok {
+			return
+		}
+
+		al.list = append(al.list, item)
+		al.index[key] = len(al.list) - 1
+
+	} else {
+		key := item.name
+
+		if i, ok := al.index[key]; ok {
+			if al.list[i].hash == item.hash {
+				return
+			}
+			al.list[i] = item
+		} else {
+			al.list = append(al.list, item)
+			al.index[key] = len(al.list) - 1
+		}
 	}

-	key := gqlHash(item.gql, item.vars, "")
-
-	if _, ok := al.index[key]; ok {
-		return
-	}
-
-	al.list = append(al.list, item)
-	al.index[key] = len(al.list) - 1
-
 	f, err := os.Create(al.filepath)
 	if err != nil {
 		logger.Warn().Err(err).Msgf("Failed to write allow list: %s", al.filepath)
@ -241,22 +273,35 @@ func (al *allowList) save(item *allowItem) {
 		k := keys[i]
 		v := urlMap[k]

-		f.WriteString(fmt.Sprintf("# %s\n\n", k))
+		if _, err := f.WriteString(fmt.Sprintf("# %s\n\n", k)); err != nil {
+			logger.Error().Err(err).Send()
+			return
+		}

 		for i := range v {
-			if len(v[i].vars) != 0 && bytes.Equal(v[i].vars, []byte("{}")) == false {
+			if len(v[i].vars) != 0 && !bytes.Equal(v[i].vars, []byte("{}")) {
 				vj, err := json.MarshalIndent(v[i].vars, "", "\t")
 				if err != nil {
 					logger.Warn().Err(err).Msg("Failed to write allow list 'vars' to file")
 					continue
 				}
-				f.WriteString(fmt.Sprintf("variables %s\n\n", vj))
+
+				_, err = f.WriteString(fmt.Sprintf("variables %s\n\n", vj))
+				if err != nil {
+					logger.Error().Err(err).Send()
+					return
+				}
 			}

 			if v[i].gql[0] == '{' {
-				f.WriteString(fmt.Sprintf("query %s\n\n", v[i].gql))
+				_, err = f.WriteString(fmt.Sprintf("query %s\n\n", v[i].gql))
 			} else {
-				f.WriteString(fmt.Sprintf("%s\n\n", v[i].gql))
+				_, err = f.WriteString(fmt.Sprintf("%s\n\n", v[i].gql))
+			}
+
+			if err != nil {
+				logger.Error().Err(err).Send()
+				return
 			}
 		}
 	}
--- a/serv/auth_jwt.go
+++ b/serv/auth_jwt.go
@ -11,8 +11,7 @@ import (

 const (
 	authHeader     = "Authorization"
-	jwtBase    int = iota
-	jwtAuth0
+	jwtAuth0   int = iota + 1
 )

 func jwtHandler(next http.HandlerFunc) http.HandlerFunc {
--- a/serv/cmd.go
+++ b/serv/cmd.go
@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"runtime"
 	"strings"

 	"github.com/dosco/super-graph/psql"
@ -22,14 +23,22 @@ const (
 )

 var (
-	logger   zerolog.Logger
-	errlog   zerolog.Logger
-	conf     *config
-	confPath string
-	db       *pgxpool.Pool
-	schema   *psql.DBSchema
-	qcompile *qcode.Compiler
-	pcompile *psql.Compiler
+	// These variables are set using -ldflags
+	version        string
+	gitBranch      string
+	lastCommitSHA  string
+	lastCommitTime string
+)
+
+var (
+	logger   zerolog.Logger  // logger for everything but errors
+	errlog   zerolog.Logger  // logger for errors includes line numbers
+	conf     *config         // parsed config
+	confPath string          // path to the config file
+	db       *pgxpool.Pool   // database connection pool
+	schema   *psql.DBSchema  // database tables, columns and relationships
+	qcompile *qcode.Compiler // qcode compiler
+	pcompile *psql.Compiler  // postgres sql compiler
 )

 func Init() {
@ -37,7 +46,7 @@ func Init() {

 	rootCmd := &cobra.Command{
 		Use:   "super-graph",
-		Short: "An instant high-performance GraphQL API. No code needed. https://supergraph.dev",
+		Short: BuildDetails(),
 	}

 	rootCmd.AddCommand(&cobra.Command{
@ -133,6 +142,12 @@ e.g. db:migrate -+1
 		Run:   cmdConfDump,
 	})

+	rootCmd.AddCommand(&cobra.Command{
+		Use:   "version",
+		Short: "Super Graph binary version information",
+		Run:   cmdVersion,
+	})
+
 	rootCmd.Flags().StringVar(&confPath,
 		"path", "./config", "path to config files")

@ -169,7 +184,10 @@ func initConf() (*config, error) {
 		}

 		vi.SetConfigName(getConfigName())
-		vi.MergeInConfig()
+
+		if err := vi.MergeInConfig(); err != nil {
+			return nil, err
+		}
 	}

 	c := &config{}
@ -290,3 +308,27 @@ func initConfOnce() {
 		}
 	}
 }
+
+func cmdVersion(cmd *cobra.Command, args []string) {
+	fmt.Printf("%s\n", BuildDetails())
+}
+
+func BuildDetails() string {
+	return fmt.Sprintf(`
+Super Graph %v 
+For documentation, visit https://supergraph.dev
+
+Commit SHA-1          : %v
+Commit timestamp      : %v
+Branch                : %v
+Go version            : %v
+
+Licensed under the Apache Public License 2.0
+Copyright 2015-2019 Vikram Rangnekar.
+`,
+		version,
+		lastCommitSHA,
+		lastCommitTime,
+		gitBranch,
+		runtime.Version())
+}
--- a/serv/cmd_conf.go
+++ b/serv/cmd_conf.go
@ -9,7 +9,7 @@ import (

 func cmdConfDump(cmd *cobra.Command, args []string) {
 	if len(args) != 1 {
-		cmd.Help()
+		cmd.Help() //nolint: errcheck
 		os.Exit(1)
 	}

--- a/serv/cmd_migrate.go
+++ b/serv/cmd_migrate.go
@ -14,19 +14,6 @@ import (
 	"github.com/spf13/cobra"
 )

-var sampleMigration = `-- This is a sample migration.
-
-create table users(
-  id serial primary key,
-  fullname varchar not null,
-  email varchar not null
-);
-
---- create above / drop below ----
-
-drop table users;
-`
-
 var newMigrationText = `-- Write your migrate up statements here

 ---- create above / drop below ----
@ -48,7 +35,7 @@ func cmdDBSetup(cmd *cobra.Command, args []string) {
 		return
 	}

-	if os.IsNotExist(err) == false {
+	if !os.IsNotExist(err) {
 		errlog.Fatal().Err(err).Msgf("unable to check if '%s' exists", sfile)
 	}

@ -108,7 +95,7 @@ func cmdDBDrop(cmd *cobra.Command, args []string) {

 func cmdDBNew(cmd *cobra.Command, args []string) {
 	if len(args) != 1 {
-		cmd.Help()
+		cmd.Help() //nolint: errcheck
 		os.Exit(1)
 	}

@ -142,7 +129,7 @@ func cmdDBNew(cmd *cobra.Command, args []string) {

 func cmdDBMigrate(cmd *cobra.Command, args []string) {
 	if len(args) == 0 {
-		cmd.Help()
+		cmd.Help() //nolint: errcheck
 		os.Exit(1)
 	}

@ -211,7 +198,7 @@ func cmdDBMigrate(cmd *cobra.Command, args []string) {
 		err = m.MigrateTo(currentVersion + mustParseDestination(dest[1:]))

 	} else {
-		cmd.Help()
+		cmd.Help() //nolint: errcheck
 		os.Exit(1)
 	}

--- a/serv/cmd_new.go
+++ b/serv/cmd_new.go
@ -16,7 +16,7 @@ import (

 func cmdNew(cmd *cobra.Command, args []string) {
 	if len(args) != 1 {
-		cmd.Help()
+		cmd.Help() //nolint: errcheck
 		os.Exit(1)
 	}

@ -115,13 +115,17 @@ func (t *Templ) get(name string) ([]byte, error) {
 	b := bytes.Buffer{}
 	tmpl := fasttemplate.New(v, "{%", "%}")

-	tmpl.ExecuteFunc(&b, func(w io.Writer, tag string) (int, error) {
+	_, err := tmpl.ExecuteFunc(&b, func(w io.Writer, tag string) (int, error) {
 		if val, ok := t.data[strings.TrimSpace(tag)]; ok {
 			return w.Write([]byte(val))
 		}
 		return 0, fmt.Errorf("unknown template variable '%s'", tag)
 	})

+	if err != nil {
+		return nil, err
+	}
+
 	return b.Bytes(), nil
 }

@ -133,7 +137,7 @@ func ifNotExists(filePath string, doFn func(string) error) {
 		return
 	}

-	if os.IsNotExist(err) == false {
+	if !os.IsNotExist(err) {
 		errlog.Fatal().Err(err).Msgf("unable to check if '%s' exists", filePath)
 	}

--- a/serv/cmd_seed.go
+++ b/serv/cmd_seed.go
@ -43,7 +43,7 @@ func cmdDBSeed(cmd *cobra.Command, args []string) {
 	vm.Set("graphql", graphQLFunc)

 	console := vm.NewObject()
-	console.Set("log", logFunc)
+	console.Set("log", logFunc) //nolint: errcheck
 	vm.Set("console", console)

 	fake := vm.NewObject()
@ -100,7 +100,7 @@ func graphQLFunc(query string, data interface{}, opt map[string]string) map[stri
 	if err != nil {
 		errlog.Fatal().Err(err).Send()
 	}
-	defer tx.Rollback(c)
+	defer tx.Rollback(c) //nolint: errcheck

 	if conf.DB.SetUserID {
 		if err := setLocalUserID(c, tx); err != nil {
@ -110,7 +110,7 @@ func graphQLFunc(query string, data interface{}, opt map[string]string) map[stri

 	var root []byte

-	if err = tx.QueryRow(c, finalSQL).Scan(&root); err != nil {
+	if err = tx.QueryRow(context.Background(), finalSQL).Scan(&root); err != nil {
 		errlog.Fatal().Err(err).Msg("sql query failed")
 	}

@ -128,6 +128,7 @@ func graphQLFunc(query string, data interface{}, opt map[string]string) map[stri
 	return val
 }

+//nolint: errcheck
 func logFunc(args ...interface{}) {
 	for _, arg := range args {
 		if _, ok := arg.(map[string]interface{}); ok {
@ -144,6 +145,7 @@ func logFunc(args ...interface{}) {
 	}
 }

+//nolint: errcheck
 func setFakeFuncs(f *goja.Object) {
 	gofakeit.Seed(0)

--- a/serv/config.go
+++ b/serv/config.go
@ -173,9 +173,10 @@ func newConfig(name string) *viper.Viper {
 	vi.SetDefault("database.schema", "public")

 	vi.SetDefault("env", "development")
-	vi.BindEnv("env", "GO_ENV")
-	vi.BindEnv("HOST", "HOST")
-	vi.BindEnv("PORT", "PORT")
+
+	vi.BindEnv("env", "GO_ENV") //nolint: errcheck
+	vi.BindEnv("HOST", "HOST")  //nolint: errcheck
+	vi.BindEnv("PORT", "PORT")  //nolint: errcheck

 	vi.SetDefault("auth.rails.max_idle", 80)
 	vi.SetDefault("auth.rails.max_active", 12000)
--- a/serv/core.go
+++ b/serv/core.go
@ -16,10 +16,6 @@ import (
 	"github.com/valyala/fasttemplate"
 )

-const (
-	empty = ""
-)
-
 type coreContext struct {
 	req gqlReq
 	res gqlResp
@ -85,10 +81,10 @@ func (c *coreContext) resolvePreparedSQL() ([]byte, *stmt, error) {
 	useTx := useRoleQuery || conf.DB.SetUserID

 	if useTx {
-		if tx, err = db.Begin(c); err != nil {
+		if tx, err = db.Begin(context.Background()); err != nil {
 			return nil, nil, err
 		}
-		defer tx.Rollback(c)
+		defer tx.Rollback(c) //nolint: errcheck
 	}

 	if conf.DB.SetUserID {
@ -126,9 +122,9 @@ func (c *coreContext) resolvePreparedSQL() ([]byte, *stmt, error) {
 	}

 	if useTx {
-		row = tx.QueryRow(c, ps.sd.SQL, vars...)
+		row = tx.QueryRow(context.Background(), ps.sd.SQL, vars...)
 	} else {
-		row = db.QueryRow(c, ps.sd.SQL, vars...)
+		row = db.QueryRow(context.Background(), ps.sd.SQL, vars...)
 	}

 	if mutation || anonQuery {
@ -150,7 +146,7 @@ func (c *coreContext) resolvePreparedSQL() ([]byte, *stmt, error) {
 	c.req.role = role

 	if useTx {
-		if err := tx.Commit(c); err != nil {
+		if err := tx.Commit(context.Background()); err != nil {
 			return nil, nil, err
 		}
 	}
@ -170,10 +166,10 @@ func (c *coreContext) resolveSQL() ([]byte, *stmt, error) {
 	useTx := useRoleQuery || conf.DB.SetUserID

 	if useTx {
-		if tx, err = db.Begin(c); err != nil {
+		if tx, err = db.Begin(context.Background()); err != nil {
 			return nil, nil, err
 		}
-		defer tx.Rollback(c)
+		defer tx.Rollback(context.Background()) //nolint: errcheck
 	}

 	if conf.DB.SetUserID {
@ -219,9 +215,9 @@ func (c *coreContext) resolveSQL() ([]byte, *stmt, error) {
 	defaultRole := c.req.role

 	if useTx {
-		row = tx.QueryRow(c, finalSQL)
+		row = tx.QueryRow(context.Background(), finalSQL)
 	} else {
-		row = db.QueryRow(c, finalSQL)
+		row = db.QueryRow(context.Background(), finalSQL)
 	}

 	if len(stmts) == 1 {
@ -241,14 +237,14 @@ func (c *coreContext) resolveSQL() ([]byte, *stmt, error) {
 	}

 	if useTx {
-		if err := tx.Commit(c); err != nil {
+		if err := tx.Commit(context.Background()); err != nil {
 			return nil, nil, err
 		}
 	}

-	// if conf.Production == false {
-	// 	_allowList.add(&c.req)
-	// }
+	if !conf.Production {
+		_allowList.add(&c.req)
+	}

 	if len(stmts) > 1 {
 		if st = findStmt(role, stmts); st == nil {
@ -267,7 +263,7 @@ func (c *coreContext) resolveSQL() ([]byte, *stmt, error) {

 func (c *coreContext) executeRoleQuery(tx pgx.Tx) (string, error) {
 	var role string
-	row := tx.QueryRow(c, "_sg_get_role", c.req.role, 1)
+	row := tx.QueryRow(context.Background(), "_sg_get_role", c.req.role, 1)

 	if err := row.Scan(&role); err != nil {
 		return "", err
@ -304,7 +300,7 @@ func (c *coreContext) addTrace(sel []qcode.Select, id int32, st time.Time) {

 	n--
 	for i := id; ; i = sel[i].ParentID {
-		path[n] = sel[i].Table
+		path[n] = sel[i].Name
 		if sel[i].ParentID == -1 {
 			break
 		}
@ -314,7 +310,7 @@ func (c *coreContext) addTrace(sel []qcode.Select, id int32, st time.Time) {
 	tr := resolver{
 		Path:        path,
 		ParentType:  "Query",
-		FieldName:   sel[id].Table,
+		FieldName:   sel[id].Name,
 		ReturnType:  "object",
 		StartOffset: 1,
 		Duration:    du,
@ -324,6 +320,15 @@ func (c *coreContext) addTrace(sel []qcode.Select, id int32, st time.Time) {
 		append(c.res.Extensions.Tracing.Execution.Resolvers, tr)
 }

+func setLocalUserID(c context.Context, tx pgx.Tx) error {
+	var err error
+	if v := c.Value(userIDKey); v != nil {
+		_, err = tx.Exec(context.Background(), fmt.Sprintf(`SET LOCAL "user.id" = %s;`, v))
+	}
+
+	return err
+}
+
 func parentFieldIds(h *xxhash.Digest, sel []qcode.Select, skipped uint32) (
 	[][]byte,
 	map[uint64]*qcode.Select) {
@ -348,12 +353,12 @@ func parentFieldIds(h *xxhash.Digest, sel []qcode.Select, skipped uint32) (
 	for i := range sel {
 		s := &sel[i]

-		if isSkipped(skipped, uint32(s.ID)) == false {
+		if !isSkipped(skipped, uint32(s.ID)) {
 			continue
 		}

 		p := sel[s.ParentID]
-		k := mkkey(h, s.Table, p.Table)
+		k := mkkey(h, s.Name, p.Name)

 		if r, ok := rmap[k]; ok {
 			fm[n] = r.IDField
@ -367,15 +372,6 @@ func parentFieldIds(h *xxhash.Digest, sel []qcode.Select, skipped uint32) (
 	return fm, sm
 }

-func setLocalUserID(c context.Context, tx pgx.Tx) error {
-	var err error
-	if v := c.Value(userIDKey); v != nil {
-		_, err = tx.Exec(c, fmt.Sprintf(`SET LOCAL "user.id" = %s;`, v))
-	}
-
-	return err
-}
-
 func isSkipped(n uint32, pos uint32) bool {
 	return ((n & (1 << pos)) != 0)
 }
--- a/serv/core_build.go
+++ b/serv/core_build.go
@ -59,9 +59,7 @@ func buildRoleStmt(gql, vars []byte, role string) ([]stmt, error) {

 	// For the 'anon' role in production only compile
 	// queries for tables defined in the config file.
-	if conf.Production &&
-		ro.Name == "anon" &&
-		hasTablesWithConfig(qc, ro) == false {
+	if conf.Production && ro.Name == "anon" && !hasTablesWithConfig(qc, ro) {
 		return nil, errors.New("query contains tables with no 'anon' role config")
 	}

@ -99,6 +97,10 @@ func buildMultiStmt(gql, vars []byte) ([]stmt, error) {
 	for i := 0; i < len(conf.Roles); i++ {
 		role := &conf.Roles[i]

+		if role.Name == "anon" {
+			continue
+		}
+
 		qc, err := qcompile.Compile(gql, role.Name)
 		if err != nil {
 			return nil, err
@ -126,10 +128,9 @@ func buildMultiStmt(gql, vars []byte) ([]stmt, error) {
 	return stmts, nil
 }

+//nolint: errcheck
 func renderUserQuery(
 	stmts []stmt, vars map[string]json.RawMessage) (string, error) {
-
-	var err error
 	w := &bytes.Buffer{}

 	io.WriteString(w, `SELECT "_sg_auth_info"."role", (CASE "_sg_auth_info"."role" `)
@ -142,11 +143,7 @@ func renderUserQuery(
 		io.WriteString(w, `WHEN '`)
 		io.WriteString(w, s.role.Name)
 		io.WriteString(w, `' THEN (`)
-
-		s.skipped, err = pcompile.Compile(s.qc, w, psql.Variables(vars))
-		if err != nil {
-			return "", err
-		}
+		io.WriteString(w, s.sql)
 		io.WriteString(w, `) `)
 	}

@ -176,7 +173,7 @@ func renderUserQuery(

 func hasTablesWithConfig(qc *qcode.QCode, role *configRole) bool {
 	for _, id := range qc.Roots {
-		t, err := schema.GetTable(qc.Selects[id].Table)
+		t, err := schema.GetTable(qc.Selects[id].Name)
 		if err != nil {
 			return false
 		}
--- a/serv/core_remote.go
+++ b/serv/core_remote.go
@ -80,7 +80,7 @@ func resolveRemote(

 	// then use the Table nme in the Select and it's parent
 	// to find the resolver to use for this relationship
-	k2 := mkkey(h, s.Table, p.Table)
+	k2 := mkkey(h, s.Name, p.Name)

 	r, ok := rmap[k2]
 	if !ok {
@ -148,7 +148,7 @@ func resolveRemotes(

 		// then use the Table nme in the Select and it's parent
 		// to find the resolver to use for this relationship
-		k2 := mkkey(h, s.Table, p.Table)
+		k2 := mkkey(h, s.Name, p.Name)

 		r, ok := rmap[k2]
 		if !ok {
@ -167,7 +167,7 @@ func resolveRemotes(

 			b, err := r.Fn(hdr, id)
 			if err != nil {
-				cerr = fmt.Errorf("%s: %s", s.Table, err)
+				cerr = fmt.Errorf("%s: %s", s.Name, err)
 				return
 			}

@ -180,7 +180,7 @@ func resolveRemotes(
 			if len(s.Cols) != 0 {
 				err = jsn.Filter(&ob, b, colsToList(s.Cols))
 				if err != nil {
-					cerr = fmt.Errorf("%s: %s", s.Table, err)
+					cerr = fmt.Errorf("%s: %s", s.Name, err)
 					return
 				}

--- a/serv/fuzz.go
+++ b/serv/fuzz.go
@ -4,6 +4,7 @@ package serv

 func Fuzz(data []byte) int {
 	gql := string(data)
+	gqlName(gql)
 	gqlHash(gql, nil, "")

 	return 1
--- a/serv/fuzz_test.go
+++ b/serv/fuzz_test.go
@ -10,6 +10,7 @@ func TestFuzzCrashers(t *testing.T) {
 	}

 	for _, f := range crashers {
+		_ = gqlName(f)
 		gqlHash(f, nil, "")
 	}
 }
--- a/serv/http.go
+++ b/serv/http.go
@ -8,8 +8,6 @@ import (
 	"net/http"
 	"strings"
 	"time"
-
-	"github.com/gorilla/websocket"
 )

 const (
@ -20,7 +18,6 @@ const (
 )

 var (
-	upgrader        = websocket.Upgrader{}
 	errUnauthorized = errors.New("not authorized")
 )

@ -33,8 +30,6 @@ type gqlReq struct {
 	hdr    http.Header
 }

-type variables map[string]json.RawMessage
-
 type gqlResp struct {
 	Error      string          `json:"message,omitempty"`
 	Data       json.RawMessage `json:"data,omitempty"`
@ -69,7 +64,8 @@ type resolver struct {
 func apiv1Http(w http.ResponseWriter, r *http.Request) {
 	ctx := &coreContext{Context: r.Context()}

-	if conf.AuthFailBlock && authCheck(ctx) == false {
+	//nolint: errcheck
+	if conf.AuthFailBlock && !authCheck(ctx) {
 		w.WriteHeader(http.StatusUnauthorized)
 		json.NewEncoder(w).Encode(gqlResp{Error: errUnauthorized.Error()})
 		return
@ -97,6 +93,7 @@ func apiv1Http(w http.ResponseWriter, r *http.Request) {

 	err = ctx.handleReq(w, r)

+	//nolint: errcheck
 	if err == errUnauthorized {
 		w.WriteHeader(http.StatusUnauthorized)
 		json.NewEncoder(w).Encode(gqlResp{Error: err.Error()})
@ -110,6 +107,7 @@ func apiv1Http(w http.ResponseWriter, r *http.Request) {
 	}
 }

+//nolint: errcheck
 func errorResp(w http.ResponseWriter, err error) {
 	json.NewEncoder(w).Encode(gqlResp{Error: err.Error()})
 }
--- a/serv/introsp.go
+++ b/serv/introsp.go
@ -2,6 +2,7 @@ package serv

 import "net/http"

+//nolint: errcheck
 func introspect(w http.ResponseWriter) {
 	w.Header().Set("Content-Type", "application/json")
 	w.Write([]byte(`{
--- a/serv/prepare.go
+++ b/serv/prepare.go
@ -23,21 +23,20 @@ var (
 )

 func initPreparedList() {
-	c := context.Background()
 	_preparedList = make(map[string]*preparedItem)

-	tx, err := db.Begin(c)
+	tx, err := db.Begin(context.Background())
 	if err != nil {
 		errlog.Fatal().Err(err).Send()
 	}
-	defer tx.Rollback(c)
+	defer tx.Rollback(context.Background()) //nolint: errcheck

-	err = prepareRoleStmt(c, tx)
+	err = prepareRoleStmt(tx)
 	if err != nil {
 		errlog.Fatal().Err(err).Msg("failed to prepare get role statement")
 	}

-	if err := tx.Commit(c); err != nil {
+	if err := tx.Commit(context.Background()); err != nil {
 		errlog.Fatal().Err(err).Send()
 	}

@ -48,7 +47,7 @@ func initPreparedList() {
 			continue
 		}

-		err := prepareStmt(c, v.gql, v.vars)
+		err := prepareStmt(v.gql, v.vars)
 		if err == nil {
 			success++
 			continue
@ -66,15 +65,15 @@ func initPreparedList() {
 			success, len(_allowList.list))
 }

-func prepareStmt(c context.Context, gql string, vars []byte) error {
+func prepareStmt(gql string, vars []byte) error {
 	qt := qcode.GetQType(gql)
 	q := []byte(gql)

-	tx, err := db.Begin(c)
+	tx, err := db.Begin(context.Background())
 	if err != nil {
 		return err
 	}
-	defer tx.Rollback(c)
+	defer tx.Rollback(context.Background()) //nolint: errcheck

 	switch qt {
 	case qcode.QTQuery:
@ -83,7 +82,7 @@ func prepareStmt(c context.Context, gql string, vars []byte) error {
 			return err
 		}

-		err = prepare(c, tx, &stmts1[0], gqlHash(gql, vars, "user"))
+		err = prepare(tx, &stmts1[0], gqlHash(gql, vars, "user"))
 		if err != nil {
 			return err
 		}
@ -93,7 +92,7 @@ func prepareStmt(c context.Context, gql string, vars []byte) error {
 			return err
 		}

-		err = prepare(c, tx, &stmts2[0], gqlHash(gql, vars, "anon"))
+		err = prepare(tx, &stmts2[0], gqlHash(gql, vars, "anon"))
 		if err != nil {
 			return err
 		}
@ -105,24 +104,30 @@ func prepareStmt(c context.Context, gql string, vars []byte) error {
 				return err
 			}

-			err = prepare(c, tx, &stmts[0], gqlHash(gql, vars, role.Name))
+			err = prepare(tx, &stmts[0], gqlHash(gql, vars, role.Name))
 			if err != nil {
 				return err
 			}
 		}
 	}

-	if err := tx.Commit(c); err != nil {
+	if len(vars) == 0 {
+		logger.Debug().Msgf("Building prepared statement for:\n %s", gql)
+	} else {
+		logger.Debug().Msgf("Building prepared statement:\n %s\n%s", vars, gql)
+	}
+
+	if err := tx.Commit(context.Background()); err != nil {
 		return err
 	}

 	return nil
 }

-func prepare(c context.Context, tx pgx.Tx, st *stmt, key string) error {
+func prepare(tx pgx.Tx, st *stmt, key string) error {
 	finalSQL, am := processTemplate(st.sql)

-	sd, err := tx.Prepare(c, "", finalSQL)
+	sd, err := tx.Prepare(context.Background(), "", finalSQL)
 	if err != nil {
 		return err
 	}
@ -135,7 +140,8 @@ func prepare(c context.Context, tx pgx.Tx, st *stmt, key string) error {
 	return nil
 }

-func prepareRoleStmt(c context.Context, tx pgx.Tx) error {
+// nolint: errcheck
+func prepareRoleStmt(tx pgx.Tx) error {
 	if len(conf.RolesQuery) == 0 {
 		return nil
 	}
@ -160,7 +166,7 @@ func prepareRoleStmt(c context.Context, tx pgx.Tx) error {

 	roleSQL, _ := processTemplate(w.String())

-	_, err := tx.Prepare(c, "_sg_get_role", roleSQL)
+	_, err := tx.Prepare(context.Background(), "_sg_get_role", roleSQL)
 	if err != nil {
 		return err
 	}
--- a/serv/reload.go
+++ b/serv/reload.go
@ -108,7 +108,7 @@ func Do(log func(string, ...interface{}), additional ...dir) error {
 				// Ensure that we use the correct events, as they are not uniform across
 				// platforms. See https://github.com/fsnotify/fsnotify/issues/74

-				if conf.Production == false && strings.HasSuffix(event.Name, "/allow.list") {
+				if !conf.Production && strings.HasSuffix(event.Name, "/allow.list") {
 					continue
 				}

--- a/serv/rice-box.go
+++ b/serv/rice-box.go
--- a/serv/serv.go
+++ b/serv/serv.go
@ -24,7 +24,6 @@ func initCompilers(c *config) (*qcode.Compiler, *psql.Compiler, error) {

 	conf := qcode.Config{
 		Blocklist: c.DB.Blocklist,
-		KeepArgs:  false,
 	}

 	qc, err := qcode.NewCompiler(conf)
@ -76,12 +75,16 @@ func initCompilers(c *config) (*qcode.Compiler, *psql.Compiler, error) {
 				delete.Filters = blockFilter
 			}

-			qc.AddRole(r.Name, t.Name, qcode.TRConfig{
+			err := qc.AddRole(r.Name, t.Name, qcode.TRConfig{
 				Query:  query,
 				Insert: insert,
 				Update: update,
 				Delete: delete,
 			})
+
+			if err != nil {
+				return nil, nil, err
+			}
 		}
 	}

@ -94,7 +97,7 @@ func initCompilers(c *config) (*qcode.Compiler, *psql.Compiler, error) {
 }

 func initWatcher(cpath string) {
-	if conf.WatchAndReload == false {
+	if !conf.WatchAndReload {
 		return
 	}

@ -151,6 +154,8 @@ func startHTTP() {
 	})

 	logger.Info().
+		Str("version", version).
+		Str("git_branch", gitBranch).
 		Str("host_post", hostPort).
 		Str("app_name", conf.AppName).
 		Str("env", conf.Env).
--- a/serv/utils.go
+++ b/serv/utils.go
@ -12,6 +12,7 @@ import (
 	"github.com/dosco/super-graph/jsn"
 )

+// nolint: errcheck
 func mkkey(h *xxhash.Digest, k1 string, k2 string) uint64 {
 	h.WriteString(k1)
 	h.WriteString(k2)
@ -21,6 +22,7 @@ func mkkey(h *xxhash.Digest, k1 string, k2 string) uint64 {
 	return v
 }

+// nolint: errcheck
 func gqlHash(b string, vars []byte, role string) string {
 	b = strings.TrimSpace(b)
 	h := sha1.New()
@ -64,7 +66,7 @@ func gqlHash(b string, vars []byte, role string) string {
 		} else {
 			starting = false
 			s = e
-			for e < len(b) && ws(b[e]) == false {
+			for e < len(b) && !ws(b[e]) {
 				e++
 			}
 			if e != 0 {
@ -81,7 +83,7 @@ func gqlHash(b string, vars []byte, role string) string {
 		io.WriteString(h, role)
 	}

-	if vars == nil || len(vars) == 0 {
+	if len(vars) == 0 {
 		return hex.EncodeToString(h.Sum(nil))
 	}

@ -106,6 +108,30 @@ func al(b byte) bool {
 	return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || (b >= '0' && b <= '9')
 }

+func gqlName(b string) string {
+	state, s := 0, 0
+
+	for i := 0; i < len(b); i++ {
+		switch {
+		case state == 2 && b[i] == '{':
+			return b[s:i]
+		case state == 2 && b[i] == ' ':
+			return b[s:i]
+		case state == 1 && b[i] == '{':
+			return ""
+		case state == 1 && b[i] != ' ':
+			s = i
+			state = 2
+		case state == 1 && b[i] == ' ':
+			continue
+		case i != 0 && b[i] == ' ' && (b[i-1] == 'n' || b[i-1] == 'y'):
+			state = 1
+		}
+	}
+
+	return ""
+}
+
 func findStmt(role string, stmts []stmt) *stmt {
 	for i := range stmts {
 		if stmts[i].role.Name != role {
--- a/serv/utils_test.go
+++ b/serv/utils_test.go
@ -229,3 +229,80 @@ func TestGQLHashWithVars2(t *testing.T) {
 		t.Fatal("Hashes don't match they should")
 	}
 }
+
+func TestGQLName1(t *testing.T) {
+	var q = `
+	query {
+		products(
+			distinct: [price]
+			where: { id: { and: { greater_or_equals: 20, lt: 28 } } }
+		) { id name } }`
+
+	name := gqlName(q)
+
+	if len(name) != 0 {
+		t.Fatal("Name should be empty, not ", name)
+	}
+}
+
+func TestGQLName2(t *testing.T) {
+	var q = `
+	query hakuna_matata {
+		products(
+			distinct: [price]
+			where: { id: { and: { greater_or_equals: 20, lt: 28 } } }
+		) {
+			id
+			name
+		}
+	}`
+
+	name := gqlName(q)
+
+	if name != "hakuna_matata" {
+		t.Fatal("Name should be 'hakuna_matata', not ", name)
+	}
+}
+
+func TestGQLName3(t *testing.T) {
+	var q = `
+	mutation means{ users { id } }`
+
+	// var v2 = `   { products( limit: 30, order_by: { price: desc }, distinct: [ price ] where: { id: { and: { greater_or_equals: 20, lt: 28 } } }) { id name price user { id email } } } `
+
+	name := gqlName(q)
+
+	if name != "means" {
+		t.Fatal("Name should be 'means', not ", name)
+	}
+}
+
+func TestGQLName4(t *testing.T) {
+	var q = `
+	query no_worries 
+		users {
+			id
+		}
+	}`
+
+	name := gqlName(q)
+
+	if name != "no_worries" {
+		t.Fatal("Name should be 'no_worries', not ", name)
+	}
+}
+
+func TestGQLName5(t *testing.T) {
+	var q = `
+	    {
+		users {
+			id
+		}
+	}`
+
+	name := gqlName(q)
+
+	if len(name) != 0 {
+		t.Fatal("Name should be empty, not ", name)
+	}
+}
Author	SHA1	Message	Date
Vikram Rangnekar	6029c5e05c	Add support for `websearch_to_tsquery` in PG 11	2019-12-02 10:52:22 -05:00
Vikram Rangnekar	9140e597e1	Add a guide to the internals of the codebase	2019-11-30 10:45:24 -05:00
Vikram Rangnekar	94593c9cce	Add a CONTRIBUTING.md guide for contributors	2019-11-29 22:29:31 -05:00
Vikram Rangnekar	a96c211fe5	Refactor rename 'Select.Table `to` Select.Name`	2019-11-29 01:38:23 -05:00
Vikram Rangnekar	6d47f0df8e	Fix for missing filters on nested selectors	2019-11-29 00:14:05 -05:00
Vikram Rangnekar	e82bdbed65	Add a CHANGLOG.md	2019-11-29 00:14:05 -05:00
Vikram Rangnekar	ef51b99fc7	Add issue templates	2019-11-28 16:47:56 -05:00
Vikram Rangnekar	9ebd03fa8c	Move license from MIT to Apache 2.0. Add Makefile	2019-11-28 01:25:46 -05:00
Vikram Rangnekar	aff2a13ba4	Added support for query names to the allow.list	2019-11-26 01:36:19 -05:00