fix: remove multi-line graphql query in log

This PR changes the generated SQL so that it's also compatible with CockroachDB.
Notable changes:
* use `SELECT to_jsonb("__sr_0".*)`  instead of `SELECT to_jsonb("__sr_0")`
* don't use `json_populate_record`, use the `CAST` and `->>` instead.  For example:

  instead of: `SELECT "t"."full_name", "t"."email" FROM "_sg_input" i, json_populate_record(NULL::users, i.j) t`

  do: `CAST( i.j ->>'full_name' AS character varying), CAST( i.j ->>'email' AS character varying) FROM "_sg_input" i`

This PR also adds some integration tests against an actual database instance.  If you have the cockroachdb binary installed on your PATH,
the test suite will startup a temporary cockroachdb instance on a random port to test against.  It is stopped and the tmp data files are deleted once the test ends.  It will also run the integration tests against database
pointed at by your `SG_POSTGRESQL_TEST_URL` environment variable if it’s set.

Also includes some small formatting changes introduced by `gofmt -w .`

.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 -}}

.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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,24 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+<!-- 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.

.github/ISSUE_TEMPLATE/documentation.md

@@ -0,0 +1,12 @@
+---
+name: Documentation
+about: Suggest how we can improve documentation
+title: ''
+labels: bug, docs
+assignees: ''
+
+---
+
+<!-- If you think the Super Graph documentation falls short https://supergraph.dev/guide.html please suggest ways we can improve it. -->
+
+<!-- explain it here. -->

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,14 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: enhancement
+assignees: ''
+
+---
+
+<!-- Please only use this template for submitting feature requests -->
+
+**What would you like to be added**:
+
+**Why is this needed**:

.gitignore

@@ -24,11 +24,15 @@
 /demo/tmp
 
 .vscode
-main
 .DS_Store
 .swp
+.release
 main
 super-graph
 *-fuzz.zip
 crashers
-suppressions
+suppressions
+release
+.gofuzz
+*-fuzz.zip
+

CHANGELOG.md

@@ -0,0 +1,424 @@
+<a name="unreleased"></a>
+## [Unreleased]
+
+### Add
+- Add config driven custom table relationships
+- Add support for `websearch_to_tsquery` in PG 11
+
+### Create
+- Create CODE_OF_CONDUCT.md
+
+### Fix
+- Fix bug with remote join example
+- Fix grammer / syntax
+
+### Update
+- Update issue templates
+- Update CONTRIBUTING.md
+- Update issue templates
+- Update feature_request.md
+
+
+<a name="v0.12.6"></a>
+## [v0.12.6] - 2019-12-02
+### Add
+- Add support for `websearch_to_tsquery` in PG 11
+
+
+<a name="v0.12.5"></a>
+## [v0.12.5] - 2019-11-30
+### Add
+- Add a guide to the internals of the codebase
+- Add a CONTRIBUTING.md guide for contributors
+- Add a CHANGLOG.md
+- Add issue templates
+
+### Fix
+- Fix for missing filters on nested selectors
+
+### Refactor
+- Refactor rename 'Select.Table` to `Select.Name`
+
+
+<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.6...HEAD
+[v0.12.6]: https://github.com/dosco/super-graph/compare/v0.12.5...v0.12.6
+[v0.12.5]: https://github.com/dosco/super-graph/compare/v0.12.4...v0.12.5
+[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

CODE_OF_CONDUCT.md

@@ -0,0 +1,3 @@
+# Code of Conduct
+
+Be excellent to each other. Treat others the way you'd like to be treated. We are all here to learn, build great software and make new friends.

CONTRIBUTING.md

@@ -0,0 +1,82 @@
+# 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](#getting-started)
+* [Setting Up the Development Environment](#setup-development-environment)
+   * [Prerequisites](#prerequisites)
+   * [Get the Super Graph source](#get-source-code)
+   * [Start the development envoirnment ](#start-the-development-envoirnment)
+   * [Testing](#testing-and-linting)
+* [Contributing](#contributing)
+   * [Guidelines](#guidelines)
+   * [Code style](#code-style)
+
+## Getting Started
+
+- Read the [Getting Started Guide](https://supergraph.dev/guide.html#get-started)
+
+## Setup Development Environment
+
+### 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 source code
+
+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
+
+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
+
+```
+make lint test
+```
+
+## Contributing
+
+### Guidelines
+
+- **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.

Dockerfile

@@ -1,33 +1,40 @@
 # stage: 1
 FROM node:10 as react-build
 WORKDIR /web
-COPY web/ ./
+COPY /internal/serv/web/ ./
 RUN yarn
 RUN yarn build
 
+
+
 # stage: 2
-FROM golang:1.13beta1-alpine as go-build
+FROM golang:1.14-alpine as go-build
 RUN apk update && \
+    apk add --no-cache make && \
     apk add --no-cache git && \
+    apk add --no-cache jq && \
     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
+
+ARG SOPS_VERSION=3.5.0
+ADD https://github.com/mozilla/sops/releases/download/v${SOPS_VERSION}/sops-v${SOPS_VERSION}.linux /usr/local/bin/sops
+RUN chmod 755 /usr/local/bin/sops
 
 WORKDIR /app
 COPY . /app
 
-RUN mkdir -p /app/web/build
-COPY --from=react-build /web/build/ ./web/build/
+RUN mkdir -p /app/internal/serv/web/build
+COPY --from=react-build /web/build/ ./internal/serv/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
 
+
+
 # stage: 3
 FROM alpine:latest
 WORKDIR /
@@ -38,10 +45,15 @@ RUN mkdir -p /config
 COPY --from=go-build /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
 COPY --from=go-build /app/config/* /config/
 COPY --from=go-build /app/super-graph .
+COPY --from=go-build /app/internal/scripts/start.sh .
+COPY --from=go-build /usr/local/bin/sops .
 
 RUN chmod +x /super-graph
+RUN chmod +x /start.sh
+
 USER nobody
 
-EXPOSE 8080
+ENV GO_ENV production
 
-CMD ./super-graph serv
+ENTRYPOINT ["./start.sh"]
+CMD ["./super-graph", "serv"]

LICENSE

@@ -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

Makefile

@@ -0,0 +1,108 @@
+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/internal/serv.version
+gitBranch      = github.com/dosco/super-graph/internal/serv.gitBranch
+lastCommitSHA  = github.com/dosco/super-graph/internal/serv.lastCommitSHA
+lastCommitTime = github.com/dosco/super-graph/internal/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)/rice
+GOLANGCILINT := $(BIN_DIR)/golangci-lint
+GITCHGLOG := $(BIN_DIR)/git-chglog
+WEB_BUILD_DIR := ./internal/serv/web/build/manifest.json
+
+$(GORICE):
+	@GO111MODULE=off go get -u github.com/GeertJohan/go.rice/rice
+
+$(WEB_BUILD_DIR):
+	@echo "First install Yarn and create a build of the web UI then re-run make install"
+	@echo "Run this command: yarn --cwd internal/serv/web/ build"
+	@exit 1
+
+$(GITCHGLOG):
+	@GO111MODULE=off go get -u github.com/git-chglog/git-chglog/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: $(GOLANGCILINT)
+	@golangci-lint run ./... --skip-dirs-use-default
+
+BINARY := super-graph
+LDFLAGS := -s -w
+PLATFORMS := windows linux darwin
+os = $(word 1, $@)
+
+$(PLATFORMS): lint test 
+	@mkdir -p release
+	@GOOS=$(os) GOARCH=amd64 go build $(BUILD_FLAGS) -o release/$(BINARY)-$(BUILD_VERSION)-$(os)-amd64 main.go
+
+release: windows linux darwin
+
+all: lint test $(BINARY)
+
+build: $(BINARY)
+
+gen: $(GORICE) $(WEB_BUILD_DIR)
+	@go generate ./...
+
+$(BINARY): clean
+	@go build $(BUILD_FLAGS) -o $(BINARY) main.go 
+
+clean:
+	@rm -f $(BINARY)
+
+run: clean
+	@go run $(BUILD_FLAGS) main.go $(ARGS)
+
+install: clean build
+	@echo "Commit Hash: `git rev-parse HEAD`"
+	@echo "Old Hash: `shasum $(GOPATH)/bin/$(BINARY) 2>/dev/null | cut -c -32`"
+	@mv $(BINARY) $(GOPATH)/bin/$(BINARY)
+	@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

NOTICE

@@ -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.

README.md

@@ -1,17 +1,71 @@
-<a href="https://supergraph.dev"><img src="https://supergraph.dev/hologram.svg" width="100" height="100" align="right" /></a>
+<img src="docs/guide/.vuepress/public/super-graph.png" width="250" />
 
-# Super Graph - Instant GraphQL APIs for your apps. 
+### Build web products faster. Secure high performance GraphQL
 
-## Build web products faster. No code needed. GraphQL auto. transformed into efficient database queries.
-
-![MIT license](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)
+[![GoDoc](https://img.shields.io/badge/godoc-reference-5272B4.svg)](https://pkg.go.dev/github.com/dosco/super-graph/core?tab=doc)
+![Apache 2.0](https://img.shields.io/github/license/dosco/super-graph.svg?style=flat-square)
+![Docker build](https://img.shields.io/docker/cloud/build/dosco/super-graph.svg?style=flat-square)
+![Cloud native](https://img.shields.io/badge/cloud--native-enabled-blue.svg?style=flat-squareg)
 [![Discord Chat](https://img.shields.io/discord/628796009539043348.svg)](https://discord.gg/6pSWCTZ)  
 
-![GraphQL](docs/.vuepress/public/graphql.png?raw=true "")
+## What's Super Graph?
 
-## The story of Super Graph?
+Designed to 100x your developer productivity. Super Graph will instantly and without you writing code provide you a high performance GraphQL API for Postgres DB. GraphQL queries are compiled into a single fast SQL query. Super Graph is a GO library and a service, use it in your own code or run it as a seperate service.
+
+## Using it as a service
+
+```console
+get get https://github.com/dosco/super-graph 
+super-graph new <app_name>
+```
+
+## Using it in your own code
+
+```golang
+package main
+
+import (
+  "database/sql"
+  "fmt"
+  "time"
+  "github.com/dosco/super-graph/core"
+  _ "github.com/jackc/pgx/v4/stdlib"
+)
+
+func main() {
+  db, err := sql.Open("pgx", "postgres://postgrs:@localhost:5432/example_db")
+  if err != nil {
+    log.Fatalf(err)
+  }
+
+  conf, err := core.ReadInConfig("./config/dev.yml")
+  if err != nil {
+    log.Fatalf(err)
+  }
+
+  sg, err = core.NewSuperGraph(conf, db)
+  if err != nil {
+    log.Fatalf(err)
+  }
+
+  query := `
+    query {
+      posts {
+      id
+      title
+    }
+  }`
+
+  res, err := sg.GraphQL(context.Background(), query, nil)
+  if err != nil {
+    log.Fatalf(err)
+  }
+
+  fmt.Println(string(res.Data))
+}
+```
+
+## About 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,21 +79,23 @@ 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
-- Automatically learns database schemas and relationships
+- Complex nested queries and mutations
+- Auto learns database tables and relationships
+- Role and Attribute based access control
+- Opaque cursor based efficient pagination
 - Full text search and aggregations
-- Rails authentication supported (Redis, Memcache, Cookie)
 - JWT tokens supported (Auth0, etc)
-- Join database with remote REST APIs
-- Highly optimized and fast Postgres SQL queries
-- GraphQL queries and mutations
+- Join database queries with remote REST APIs
+- Also works with existing Ruby-On-Rails apps
+- Rails authentication supported (Redis, Memcache, Cookie)
 - A simple config file
 - High performance GO codebase
 - Tiny docker image and low memory requirements
 - Fuzz tested for security
 - Database migrations tool
 - Database seeding tool
+- Works with Postgres and YugabyteDB
+
 
 ## Documentation
 
@@ -56,7 +112,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
 

config/allow.list

@@ -73,43 +73,6 @@ mutation {
   }
 }
 
-variables {
-	"data": [
-		{
-			"name": "Gumbo1",
-			"created_at": "now",
-			"updated_at": "now"
-		},
-		{
-			"name": "Gumbo2",
-			"created_at": "now",
-			"updated_at": "now"
-		}
-	]
-}
-
-query {
-  products {
-    id
-    name
-  }
-}
-
-variables {
-	"data": [
-		{
-			"name": "Gumbo1",
-			"created_at": "now",
-			"updated_at": "now"
-		},
-		{
-			"name": "Gumbo2",
-			"created_at": "now",
-			"updated_at": "now"
-		}
-	]
-}
-
 query {
   products {
     id
@@ -133,21 +96,6 @@ mutation {
   }
 }
 
-variables {
-	"data": [
-		{
-			"name": "Gumbo1",
-			"created_at": "now",
-			"updated_at": "now"
-		},
-		{
-			"name": "Gumbo2",
-			"created_at": "now",
-			"updated_at": "now"
-		}
-	]
-}
-
 query {
   products {
     id
@@ -174,39 +122,6 @@ mutation {
   }
 }
 
-variables {
-	"data": [
-		{
-			"name": "Gumbo1",
-			"created_at": "now",
-			"updated_at": "now"
-		},
-		{
-			"name": "Gumbo2",
-			"created_at": "now",
-			"updated_at": "now"
-		}
-	]
-}
-
-query {
-  products {
-    id
-    name
-    users {
-      email
-    }
-  }
-}
-
-query {
-  me {
-    id
-    email
-    full_name
-  }
-}
-
 variables {
 	"update": {
 		"name": "Helloo",
@@ -223,70 +138,6 @@ mutation {
   }
 }
 
-variables {
-	"data": [
-		{
-			"name": "Gumbo1",
-			"created_at": "now",
-			"updated_at": "now"
-		},
-		{
-			"name": "Gumbo2",
-			"created_at": "now",
-			"updated_at": "now"
-		}
-	]
-}
-
-query {
-  product {
-    id
-    name
-  }
-}
-
-variables {
-	"data": [
-		{
-			"name": "Gumbo1",
-			"created_at": "now",
-			"updated_at": "now"
-		},
-		{
-			"name": "Gumbo2",
-			"created_at": "now",
-			"updated_at": "now"
-		}
-	]
-}
-
-query {
-  products {
-    id
-    name
-    description
-    users {
-      email
-    }
-  }
-}
-
-query {
-  users {
-    id
-    email
-    picture: avatar
-    password
-    full_name
-    products(limit: 2, where: {price: {gt: 10}}) {
-      id
-      name
-      description
-      price
-    }
-  }
-}
-
 variables {
 	"data": {
 		"name": "WOOO",
@@ -301,4 +152,604 @@ mutation {
   }
 }
 
+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
+  }
+}
+
+query {
+  user {
+    id
+    full_name
+  }
+}
+
+variables {
+	"data": {
+		"email": "goo1@rug.com",
+		"full_name": "The Dude",
+		"created_at": "now",
+		"updated_at": "now",
+		"product": {
+			"name": "Apple",
+			"price": 1.25,
+			"created_at": "now",
+			"updated_at": "now"
+		}
+	}
+}
+
+mutation {
+  user(insert: $data) {
+    id
+    full_name
+    email
+    product {
+      id
+      name
+      price
+    }
+  }
+}
+
+variables {
+	"data": {
+		"email": "goo12@rug.com",
+		"full_name": "The Dude",
+		"created_at": "now",
+		"updated_at": "now",
+		"product": [
+			{
+				"name": "Banana 1",
+				"price": 1.1,
+				"created_at": "now",
+				"updated_at": "now"
+			},
+			{
+				"name": "Banana 2",
+				"price": 2.2,
+				"created_at": "now",
+				"updated_at": "now"
+			}
+		]
+	}
+}
+
+mutation {
+  user(insert: $data) {
+    id
+    full_name
+    email
+    products {
+      id
+      name
+      price
+    }
+  }
+}
+
+variables {
+	"data": {
+		"name": "Banana 3",
+		"price": 1.1,
+		"created_at": "now",
+		"updated_at": "now",
+		"user": {
+			"email": "a2@a.com",
+			"full_name": "The Dude",
+			"created_at": "now",
+			"updated_at": "now"
+		}
+	}
+}
+
+mutation {
+  products(insert: $data) {
+    id
+    name
+    price
+    user {
+      id
+      full_name
+      email
+    }
+  }
+}
+
+variables {
+	"update": {
+		"name": "my_name",
+		"description": "my_desc"
+	}
+}
+
+mutation {
+  product(id: 15, update: $update, where: {id: {eq: 1}}) {
+    id
+    name
+  }
+}
+
+variables {
+	"update": {
+		"name": "my_name",
+		"description": "my_desc"
+	}
+}
+
+mutation {
+  product(update: $update, where: {id: {eq: 1}}) {
+    id
+    name
+  }
+}
+
+variables {
+	"update": {
+		"name": "my_name 2",
+		"description": "my_desc 2"
+	}
+}
+
+mutation {
+  product(update: $update, where: {id: {eq: 1}}) {
+    id
+    name
+    description
+  }
+}
+
+variables {
+	"data": {
+		"sale_type": "tuutuu",
+		"quantity": 5,
+		"due_date": "now",
+		"customer": {
+			"email": "thedude1@rug.com",
+			"full_name": "The Dude"
+		},
+		"product": {
+			"name": "Apple",
+			"price": 1.25
+		}
+	}
+}
+
+mutation {
+  purchase(update: $data, id: 5) {
+    sale_type
+    quantity
+    due_date
+    customer {
+      id
+      full_name
+      email
+    }
+    product {
+      id
+      name
+      price
+    }
+  }
+}
+
+variables {
+	"data": {
+		"email": "thedude@rug.com",
+		"full_name": "The Dude",
+		"created_at": "now",
+		"updated_at": "now",
+		"product": {
+			"where": {
+				"id": 2
+			},
+			"name": "Apple",
+			"price": 1.25,
+			"created_at": "now",
+			"updated_at": "now"
+		}
+	}
+}
+
+mutation {
+  user(update: $data, where: {id: {eq: 8}}) {
+    id
+    full_name
+    email
+    product {
+      id
+      name
+      price
+    }
+  }
+}
+
+variables {
+	"data": {
+		"email": "thedude@rug.com",
+		"full_name": "The Dude",
+		"created_at": "now",
+		"updated_at": "now",
+		"product": {
+			"where": {
+				"id": 2
+			},
+			"name": "Apple",
+			"price": 1.25,
+			"created_at": "now",
+			"updated_at": "now"
+		}
+	}
+}
+
+query {
+  user(where: {id: {eq: 8}}) {
+    id
+    product {
+      id
+      name
+      price
+    }
+  }
+}
+
+variables {
+	"data": {
+		"name": "Apple",
+		"price": 1.25,
+		"created_at": "now",
+		"updated_at": "now",
+		"user": {
+			"email": "thedude@rug.com"
+		}
+	}
+}
+
+query {
+  user {
+    email
+  }
+}
+
+variables {
+	"data": {
+		"name": "Apple",
+		"price": 1.25,
+		"created_at": "now",
+		"updated_at": "now",
+		"user": {
+			"email": "booboo@demo.com"
+		}
+	}
+}
+
+mutation {
+  product(update: $data, id: 6) {
+    id
+    name
+    user {
+      id
+      full_name
+      email
+    }
+  }
+}
+
+variables {
+	"data": {
+		"name": "Apple",
+		"price": 1.25,
+		"created_at": "now",
+		"updated_at": "now",
+		"user": {
+			"email": "booboo@demo.com"
+		}
+	}
+}
+
+query {
+  product(id: 6) {
+    id
+    name
+    user {
+      id
+      full_name
+      email
+    }
+  }
+}
+
+variables {
+	"data": {
+		"email": "thedude123@rug.com",
+		"full_name": "The Dude",
+		"created_at": "now",
+		"updated_at": "now",
+		"product": {
+			"connect": {
+				"id": 7
+			},
+			"disconnect": {
+				"id": 8
+			}
+		}
+	}
+}
+
+mutation {
+  user(update: $data, id: 6) {
+    id
+    full_name
+    email
+    product {
+      id
+      name
+      price
+    }
+  }
+}
+
+variables {
+	"data": {
+		"name": "Apple",
+		"price": 1.25,
+		"created_at": "now",
+		"updated_at": "now",
+		"user": {
+			"connect": {
+				"id": 5,
+				"email": "test@test.com"
+			}
+		}
+	}
+}
+
+mutation {
+  product(update: $data, id: 9) {
+    id
+    name
+    user {
+      id
+      full_name
+      email
+    }
+  }
+}
+
+variables {
+	"data": {
+		"email": "thed44ude@rug.com",
+		"full_name": "The Dude",
+		"created_at": "now",
+		"updated_at": "now",
+		"product": {
+			"connect": {
+				"id": 5
+			}
+		}
+	}
+}
+
+mutation {
+  user(insert: $data) {
+    id
+    full_name
+    email
+    product {
+      id
+      name
+      price
+    }
+  }
+}
+
+variables {
+	"data": {
+		"name": "Apple",
+		"price": 1.25,
+		"created_at": "now",
+		"updated_at": "now",
+		"user": {
+			"connect": {
+				"id": 5
+			}
+		}
+	}
+}
+
+mutation {
+  product(insert: $data) {
+    id
+    name
+    user {
+      id
+      full_name
+      email
+    }
+  }
+}
+
+variables {
+	"data": [
+		{
+			"name": "Apple",
+			"price": 1.25,
+			"created_at": "now",
+			"updated_at": "now",
+			"user": {
+				"connect": {
+					"id": 6
+				}
+			}
+		},
+		{
+			"name": "Coconut",
+			"price": 2.25,
+			"created_at": "now",
+			"updated_at": "now",
+			"user": {
+				"connect": {
+					"id": 3
+				}
+			}
+		}
+	]
+}
+
+mutation {
+  products(insert: $data) {
+    id
+    name
+    user {
+      id
+      full_name
+      email
+    }
+  }
+}
+
+variables {
+	"data": [
+		{
+			"name": "Apple",
+			"price": 1.25,
+			"created_at": "now",
+			"updated_at": "now"
+		},
+		{
+			"name": "Coconut",
+			"price": 2.25,
+			"created_at": "now",
+			"updated_at": "now"
+		}
+	]
+}
+
+mutation {
+  products(insert: $data) {
+    id
+    name
+    user {
+      id
+      full_name
+      email
+    }
+  }
+}
+
+variables {
+	"data": {
+		"name": "Apple",
+		"price": 1.25,
+		"user": {
+			"connect": {
+				"id": 5,
+				"email": "test@test.com"
+			}
+		}
+	}
+}
+
+mutation {
+  product(update: $data, id: 9) {
+    id
+    name
+    user {
+      id
+      full_name
+      email
+    }
+  }
+}
+
+variables {
+	"data": {
+		"name": "Apple",
+		"price": 1.25,
+		"user": {
+			"connect": {
+				"id": 5
+			}
+		}
+	}
+}
+
+mutation {
+  product(update: $data, id: 9) {
+    id
+    name
+    user {
+      id
+      full_name
+      email
+    }
+  }
+}
+
+variables {
+	"data": {
+		"name": "Apple",
+		"price": 1.25,
+		"user": {
+			"disconnect": {
+				"id": 5
+			}
+		}
+	}
+}
+
+mutation {
+  product(update: $data, id: 9) {
+    id
+    name
+    user_id
+  }
+}
+
+
+variables {
+	"data": {
+		"name": "Apple",
+		"price": 1.25,
+		"user": {
+			"disconnect": {
+				"id": 5
+			}
+		}
+	}
+}
+
+mutation {
+  product(update: $data, id: 2) {
+    id
+    name
+    user_id
+  }
+}
+
 

config/dev.yml

@@ -2,9 +2,12 @@ app_name: "Super Graph Development"
 host_port: 0.0.0.0:8080
 web_ui: true
 
-# debug, info, warn, error, fatal, panic
+# debug, error, warn, info, none
 log_level: "debug"
 
+# enable or disable http compression (uses gzip)
+http_compress: true
+
 # When production mode is 'true' only queries 
 # from the allow list are permitted.
 # When it's 'false' all queries are saved to the
@@ -27,7 +30,20 @@ reload_on_config_change: true
 # seed_file: seed.js
 
 # Path pointing to where the migrations can be found
-migrations_path: ./config/migrations
+migrations_path: ./migrations
+
+# Secret key for general encryption operations like 
+# encrypting the cursor data
+secret_key: supercalifajalistics
+
+# CORS: A list of origins a cross-domain request can be executed from. 
+# If the special * value is present in the list, all origins will be allowed. 
+# An origin may contain a wildcard (*) to replace 0 or more 
+# characters (i.e.: http://*.domain.com).
+cors_allowed_origins: ["*"]
+
+# Debug Cross Origin Resource Sharing requests
+cors_debug: true
 
 # Postgres related environment Variables
 # SG_DATABASE_HOST
@@ -86,7 +102,7 @@ database:
   port: 5432
   dbname: app_development
   user: postgres
-  password: ''
+  password: postgres
 
   #schema: "public"
   #pool_size: 10
@@ -97,22 +113,21 @@ database:
   # Enable this if you need the user id in triggers, etc
   set_user_id: false
 
-  # Define additional variables here to be used with filters
-  variables:
-    admin_account_id: "5"
+  # database ping timeout is used for db health checking
+  ping_timeout: 1m
 
-  # Define defaults to for the field key and values below
-  defaults:
-    # filters: ["{ user_id: { eq: $user_id } }"]
+# Define additional variables here to be used with filters
+variables:
+  admin_account_id: "5"
 
-    # Field and table names that you wish to block
-    blocklist:
-      - ar_internal_metadata
-      - schema_migrations
-      - secret
-      - password
-      - encrypted
-      - token
+# Field and table names that you wish to block
+blocklist:
+  - ar_internal_metadata
+  - schema_migrations
+  - secret
+  - password
+  - encrypted
+  - token
 
 tables:
   - name: customers
@@ -135,15 +150,23 @@ tables:
     name: me
     table: users
 
+  - name: deals
+    table: products
+
+  - name: users
+    columns:
+      - name: email
+        related_to: products.name
+
+
 roles_query: "SELECT * FROM users WHERE id = $user_id"
 
 roles:
   - name: anon
     tables:
       - name: products
-        limit: 10
-
         query:
+          limit: 10
           columns: ["id", "name", "description" ]
           aggregation: false
 
@@ -156,6 +179,16 @@ roles:
         delete:
           block: false
 
+      - name: deals
+        query:
+          limit: 3
+          aggregation: false
+
+      - name: purchases
+        query:
+          limit: 3
+          aggregation: false
+
   - name: user
     tables:
       - name: users
@@ -166,12 +199,10 @@ roles:
         query:
           limit: 50
           filters: ["{ user_id: { eq: $user_id } }"]
-          columns: ["id", "name", "description" ]
           disable_functions: false
 
         insert:
           filters: ["{ user_id: { eq: $user_id } }"]
-          columns: ["id", "name", "description" ]
           presets:
             - user_id: "$user_id"
             - created_at: "now"

config/prod.yml

@@ -6,9 +6,12 @@ app_name: "Super Graph Production"
 host_port: 0.0.0.0:8080
 web_ui: false
 
-# debug, info, warn, error, fatal, panic, disable
+# debug, error, warn, info, none
 log_level: "info"
 
+# enable or disable http compression (uses gzip)
+http_compress: true
+
 # When production mode is 'true' only queries 
 # from the allow list are permitted.
 # When it's 'false' all queries are saved to the
@@ -27,7 +30,11 @@ enable_tracing: true
 # seed_file: seed.js
 
 # Path pointing to where the migrations can be found
-# migrations_path: migrations
+# migrations_path: ./migrations
+
+# Secret key for general encryption operations like 
+# encrypting the cursor data
+# secret_key: supercalifajalistics
 
 # Postgres related environment Variables
 # SG_DATABASE_HOST
@@ -47,11 +54,14 @@ database:
   port: 5432
   dbname: app_production
   user: postgres
-  password: ''
+  password: postgres
   #pool_size: 10
   #max_retries: 0
   #log_level: "debug" 
 
   # Set session variable "user.id" to the user id
   # Enable this if you need the user id in triggers, etc
-  set_user_id: false
+  set_user_id: false
+
+  # database ping timeout is used for db health checking
+  ping_timeout: 5m

config/seed.js

@@ -11,7 +11,7 @@ for (i = 0; i < user_count; i++) {
   var pwd = fake.password()
   var data = {
     full_name: fake.name(),
-    avatar: fake.image_url(),
+    avatar: fake.avatar_url(200),
     phone: fake.phone(),
     email: fake.email(),
     password: pwd,

core/api.go

@@ -0,0 +1,180 @@
+// Package core provides the primary API to include and use Super Graph with your own code.
+// For detailed documentation visit https://supergraph.dev
+//
+// Example usage:
+/*
+	package main
+
+	import (
+		"database/sql"
+		"fmt"
+		"time"
+		"github.com/dosco/super-graph/core"
+		_ "github.com/jackc/pgx/v4/stdlib"
+	)
+
+	func main() {
+		db, err := sql.Open("pgx", "postgres://postgrs:@localhost:5432/example_db")
+		if err != nil {
+			log.Fatalf(err)
+		}
+
+		conf, err := core.ReadInConfig("./config/dev.yml")
+		if err != nil {
+			log.Fatalf(err)
+		}
+
+		sg, err = core.NewSuperGraph(conf, db)
+		if err != nil {
+			log.Fatalf(err)
+		}
+
+		query := `
+			query {
+				posts {
+				id
+				title
+			}
+		}`
+
+		res, err := sg.GraphQL(context.Background(), query, nil)
+		if err != nil {
+			log.Fatalf(err)
+		}
+
+		fmt.Println(string(res.Data))
+	}
+*/
+package core
+
+import (
+	"context"
+	"crypto/sha256"
+	"database/sql"
+	"encoding/json"
+	_log "log"
+	"os"
+
+	"github.com/dosco/super-graph/core/internal/allow"
+	"github.com/dosco/super-graph/core/internal/crypto"
+	"github.com/dosco/super-graph/core/internal/psql"
+	"github.com/dosco/super-graph/core/internal/qcode"
+)
+
+type contextkey int
+
+// Constants to set values on the context passed to the NewSuperGraph function
+const (
+	// Name of the authentication provider. Eg. google, github, etc
+	UserIDProviderKey contextkey = iota
+
+	// User ID value for authenticated users
+	UserIDKey
+
+	// User role if pre-defined
+	UserRoleKey
+)
+
+// SuperGraph struct is an instance of the Super Graph engine it holds all the required information like
+// datase schemas, relationships, etc that the GraphQL to SQL compiler would need to do it's job.
+type SuperGraph struct {
+	conf        *Config
+	db          *sql.DB
+	log         *_log.Logger
+	schema      *psql.DBSchema
+	allowList   *allow.List
+	encKey      [32]byte
+	prepared    map[string]*preparedItem
+	roles       map[string]*Role
+	getRole     *sql.Stmt
+	rmap        map[uint64]*resolvFn
+	abacEnabled bool
+	anonExists  bool
+	qc          *qcode.Compiler
+	pc          *psql.Compiler
+}
+
+// NewSuperGraph creates the SuperGraph struct, this involves querying the database to learn its
+// schemas and relationships
+func NewSuperGraph(conf *Config, db *sql.DB) (*SuperGraph, error) {
+	sg := &SuperGraph{
+		conf: conf,
+		db:   db,
+		log:  _log.New(os.Stdout, "", 0),
+	}
+
+	if err := sg.initConfig(); err != nil {
+		return nil, err
+	}
+
+	if err := sg.initCompilers(); err != nil {
+		return nil, err
+	}
+
+	if err := sg.initAllowList(); err != nil {
+		return nil, err
+	}
+
+	if err := sg.initPrepared(); err != nil {
+		return nil, err
+	}
+
+	if err := sg.initResolvers(); err != nil {
+		return nil, err
+	}
+
+	if len(conf.SecretKey) != 0 {
+		sk := sha256.Sum256([]byte(conf.SecretKey))
+		conf.SecretKey = ""
+		sg.encKey = sk
+	} else {
+		sg.encKey = crypto.NewEncryptionKey()
+	}
+
+	return sg, nil
+}
+
+// Result struct contains the output of the GraphQL function this includes resulting json from the
+// database query and any error information
+type Result struct {
+	op   qcode.QType
+	name string
+	sql  string
+	role string
+
+	Error      string          `json:"message,omitempty"`
+	Data       json.RawMessage `json:"data,omitempty"`
+	Extensions *extensions     `json:"extensions,omitempty"`
+}
+
+// GraphQL function is called on the SuperGraph struct to convert the provided GraphQL query into an
+// SQL query and execute it on the database. In production mode prepared statements are directly used
+// and no query compiling takes places.
+//
+// In developer mode all names queries are saved into a file `allow.list` and in production mode only
+// queries from this file can be run.
+func (sg *SuperGraph) GraphQL(c context.Context, query string, vars json.RawMessage) (*Result, error) {
+	ct := scontext{Context: c, sg: sg, query: query, vars: vars}
+
+	if len(vars) <= 2 {
+		ct.vars = nil
+	}
+
+	if keyExists(c, UserIDKey) {
+		ct.role = "user"
+	} else {
+		ct.role = "anon"
+	}
+
+	ct.res.op = qcode.GetQType(query)
+	ct.res.name = allow.QueryName(query)
+
+	data, err := ct.execQuery()
+	if err != nil {
+		return &ct.res, err
+	}
+
+	ct.res.Data = json.RawMessage(data)
+
+	return &ct.res, nil
+}

core/args.go

@@ -0,0 +1,165 @@
+package core
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+
+	"github.com/dosco/super-graph/jsn"
+)
+
+func (c *scontext) argMap() func(w io.Writer, tag string) (int, error) {
+	return func(w io.Writer, tag string) (int, error) {
+		switch tag {
+		case "user_id_provider":
+			if v := c.Value(UserIDProviderKey); v != nil {
+				return io.WriteString(w, v.(string))
+			}
+			return 0, argErr("user_id_provider")
+
+		case "user_id":
+			if v := c.Value(UserIDKey); v != nil {
+				return io.WriteString(w, v.(string))
+			}
+			return 0, argErr("user_id")
+
+		case "user_role":
+			if v := c.Value(UserRoleKey); v != nil {
+				return io.WriteString(w, v.(string))
+			}
+			return 0, argErr("user_role")
+		}
+
+		fields := jsn.Get(c.vars, [][]byte{[]byte(tag)})
+
+		if len(fields) == 0 {
+			return 0, argErr(tag)
+
+		}
+		v := fields[0].Value
+
+		// Open and close quotes
+		if len(v) >= 2 && v[0] == '"' && v[len(v)-1] == '"' {
+			fields[0].Value = v[1 : len(v)-1]
+		}
+
+		if tag == "cursor" {
+			if bytes.EqualFold(v, []byte("null")) {
+				return io.WriteString(w, ``)
+			}
+			v1, err := c.sg.decrypt(string(fields[0].Value))
+			if err != nil {
+				return 0, err
+			}
+
+			return w.Write(v1)
+		}
+
+		return w.Write(escQuote(fields[0].Value))
+	}
+}
+
+func (c *scontext) argList(args [][]byte) ([]interface{}, error) {
+	vars := make([]interface{}, len(args))
+
+	var fields map[string]json.RawMessage
+	var err error
+
+	if len(c.vars) != 0 {
+		fields, _, err = jsn.Tree(c.vars)
+
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	for i := range args {
+		av := args[i]
+		switch {
+		case bytes.Equal(av, []byte("user_id")):
+			if v := c.Value(UserIDKey); v != nil {
+				vars[i] = v.(string)
+			} else {
+				return nil, argErr("user_id")
+			}
+
+		case bytes.Equal(av, []byte("user_id_provider")):
+			if v := c.Value(UserIDProviderKey); v != nil {
+				vars[i] = v.(string)
+			} else {
+				return nil, argErr("user_id_provider")
+			}
+
+		case bytes.Equal(av, []byte("user_role")):
+			if v := c.Value(UserRoleKey); v != nil {
+				vars[i] = v.(string)
+			} else {
+				return nil, argErr("user_role")
+			}
+
+		case bytes.Equal(av, []byte("cursor")):
+			if v, ok := fields["cursor"]; ok && v[0] == '"' {
+				v1, err := c.sg.decrypt(string(v[1 : len(v)-1]))
+				if err != nil {
+					return nil, err
+				}
+				vars[i] = v1
+			} else {
+				return nil, argErr("cursor")
+			}
+
+		default:
+			if v, ok := fields[string(av)]; ok {
+				switch v[0] {
+				case '[', '{':
+					vars[i] = escQuote(v)
+				default:
+					var val interface{}
+					if err := json.Unmarshal(v, &val); err != nil {
+						return nil, err
+					}
+
+					vars[i] = val
+				}
+
+			} else {
+				return nil, argErr(string(av))
+			}
+		}
+	}
+
+	return vars, nil
+}
+
+func escQuote(b []byte) []byte {
+	f := false
+	for i := range b {
+		if b[i] == '\'' {
+			f = true
+			break
+		}
+	}
+	if !f {
+		return b
+	}
+
+	buf := &bytes.Buffer{}
+	s := 0
+	for i := range b {
+		if b[i] == '\'' {
+			buf.Write(b[s:i])
+			buf.WriteString(`''`)
+			s = i + 1
+		}
+	}
+	l := len(b)
+	if s < (l - 1) {
+		buf.Write(b[s:l])
+	}
+	return buf.Bytes()
+}
+
+func argErr(name string) error {
+	return fmt.Errorf("query requires variable '%s' to be set", name)
+}

core/build.go

@@ -0,0 +1,182 @@
+package core
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/dosco/super-graph/core/internal/psql"
+	"github.com/dosco/super-graph/core/internal/qcode"
+)
+
+type stmt struct {
+	role    *Role
+	qc      *qcode.QCode
+	skipped uint32
+	sql     string
+}
+
+func (sg *SuperGraph) buildStmt(qt qcode.QType, query, vars []byte, role string) ([]stmt, error) {
+	switch qt {
+	case qcode.QTMutation:
+		return sg.buildRoleStmt(query, vars, role)
+
+	case qcode.QTQuery:
+		if role == "anon" {
+			return sg.buildRoleStmt(query, vars, "anon")
+		}
+
+		if sg.abacEnabled {
+			return sg.buildMultiStmt(query, vars)
+		}
+
+		return sg.buildRoleStmt(query, vars, "user")
+
+	default:
+		return nil, fmt.Errorf("unknown query type '%d'", qt)
+	}
+}
+
+func (sg *SuperGraph) buildRoleStmt(query, vars []byte, role string) ([]stmt, error) {
+	ro, ok := sg.roles[role]
+	if !ok {
+		return nil, fmt.Errorf(`roles '%s' not defined in c.sg.config`, role)
+	}
+
+	var vm map[string]json.RawMessage
+	var err error
+
+	if len(vars) != 0 {
+		if err := json.Unmarshal(vars, &vm); err != nil {
+			return nil, err
+		}
+	}
+
+	qc, err := sg.qc.Compile(query, ro.Name)
+	if err != nil {
+		return nil, err
+	}
+
+	stmts := []stmt{stmt{role: ro, qc: qc}}
+	w := &bytes.Buffer{}
+
+	skipped, err := sg.pc.Compile(qc, w, psql.Variables(vm))
+	if err != nil {
+		return nil, err
+	}
+
+	stmts[0].skipped = skipped
+	stmts[0].sql = w.String()
+
+	return stmts, nil
+}
+
+func (sg *SuperGraph) buildMultiStmt(query, vars []byte) ([]stmt, error) {
+	var vm map[string]json.RawMessage
+	var err error
+
+	if len(vars) != 0 {
+		if err := json.Unmarshal(vars, &vm); err != nil {
+			return nil, err
+		}
+	}
+
+	if len(sg.conf.RolesQuery) == 0 {
+		return nil, errors.New("roles_query not defined")
+	}
+
+	stmts := make([]stmt, 0, len(sg.conf.Roles))
+	w := &bytes.Buffer{}
+
+	for i := 0; i < len(sg.conf.Roles); i++ {
+		role := &sg.conf.Roles[i]
+
+		// skip anon as it's not included in the combined multi-statement
+		if role.Name == "anon" {
+			continue
+		}
+
+		qc, err := sg.qc.Compile(query, role.Name)
+		if err != nil {
+			return nil, err
+		}
+
+		stmts = append(stmts, stmt{role: role, qc: qc})
+
+		skipped, err := sg.pc.Compile(qc, w, psql.Variables(vm))
+		if err != nil {
+			return nil, err
+		}
+
+		s := &stmts[len(stmts)-1]
+		s.skipped = skipped
+		s.sql = w.String()
+		w.Reset()
+	}
+
+	sql, err := sg.renderUserQuery(stmts)
+	if err != nil {
+		return nil, err
+	}
+
+	stmts[0].sql = sql
+	return stmts, nil
+}
+
+//nolint: errcheck
+func (sg *SuperGraph) renderUserQuery(stmts []stmt) (string, error) {
+	w := &bytes.Buffer{}
+
+	io.WriteString(w, `SELECT "_sg_auth_info"."role", (CASE "_sg_auth_info"."role" `)
+
+	for _, s := range stmts {
+		if len(s.role.Match) == 0 &&
+			s.role.Name != "user" && s.role.Name != "anon" {
+			continue
+		}
+		io.WriteString(w, `WHEN '`)
+		io.WriteString(w, s.role.Name)
+		io.WriteString(w, `' THEN (`)
+		io.WriteString(w, s.sql)
+		io.WriteString(w, `) `)
+	}
+
+	io.WriteString(w, `END) FROM (SELECT (CASE WHEN EXISTS (`)
+	io.WriteString(w, sg.conf.RolesQuery)
+	io.WriteString(w, `) THEN `)
+
+	io.WriteString(w, `(SELECT (CASE`)
+	for _, s := range stmts {
+		if len(s.role.Match) == 0 {
+			continue
+		}
+		io.WriteString(w, ` WHEN `)
+		io.WriteString(w, s.role.Match)
+		io.WriteString(w, ` THEN '`)
+		io.WriteString(w, s.role.Name)
+		io.WriteString(w, `'`)
+	}
+
+	io.WriteString(w, ` ELSE 'user' END) FROM (`)
+	io.WriteString(w, sg.conf.RolesQuery)
+	io.WriteString(w, `) AS "_sg_auth_roles_query" LIMIT 1) `)
+	io.WriteString(w, `ELSE 'anon' END) FROM (VALUES (1)) AS "_sg_auth_filler") AS "_sg_auth_info"(role) LIMIT 1; `)
+
+	return w.String(), nil
+}
+
+func (sg *SuperGraph) hasTablesWithConfig(qc *qcode.QCode, role *Role) bool {
+	for _, id := range qc.Roots {
+		t, err := sg.schema.GetTable(qc.Selects[id].Name)
+		if err != nil {
+			return false
+		}
+
+		if r := role.GetTable(t.Name); r == nil {
+			return false
+		}
+	}
+	return true
+}

core/config.go

@@ -0,0 +1,163 @@
+package core
+
+import (
+	"fmt"
+	"path"
+	"strings"
+
+	"github.com/spf13/viper"
+)
+
+// Core struct contains core specific config value
+type Config struct {
+	SecretKey     string            `mapstructure:"secret_key"`
+	UseAllowList  bool              `mapstructure:"use_allow_list"`
+	AllowListFile string            `mapstructure:"allow_list_file"`
+	SetUserID     bool              `mapstructure:"set_user_id"`
+	Vars          map[string]string `mapstructure:"variables"`
+	Blocklist     []string
+	Tables        []Table
+	RolesQuery    string `mapstructure:"roles_query"`
+	Roles         []Role
+	Inflections   map[string]string
+}
+
+// Table struct defines a database table
+type Table struct {
+	Name      string
+	Table     string
+	Blocklist []string
+	Remotes   []Remote
+	Columns   []Column
+}
+
+// Column struct defines a database column
+type Column struct {
+	Name       string
+	Type       string
+	ForeignKey string `mapstructure:"related_to"`
+}
+
+// Remote struct defines a remote API endpoint
+type Remote struct {
+	Name        string
+	ID          string
+	Path        string
+	URL         string
+	Debug       bool
+	PassHeaders []string `mapstructure:"pass_headers"`
+	SetHeaders  []struct {
+		Name  string
+		Value string
+	} `mapstructure:"set_headers"`
+}
+
+// Role struct contains role specific access control values for for all database tables
+type Role struct {
+	Name   string
+	Match  string
+	Tables []RoleTable
+	tm     map[string]*RoleTable
+}
+
+// RoleTable struct contains role specific access control values for a database table
+type RoleTable struct {
+	Name string
+
+	Query  Query
+	Insert Insert
+	Update Update
+	Delete Delete
+}
+
+// Query struct contains access control values for query operations
+type Query struct {
+	Limit            int
+	Filters          []string
+	Columns          []string
+	DisableFunctions bool `mapstructure:"disable_functions"`
+	Block            bool
+}
+
+// Insert struct contains access control values for insert operations
+type Insert struct {
+	Filters []string
+	Columns []string
+	Presets map[string]string
+	Block   bool
+}
+
+// Insert struct contains access control values for update operations
+type Update struct {
+	Filters []string
+	Columns []string
+	Presets map[string]string
+	Block   bool
+}
+
+// Delete struct contains access control values for delete operations
+type Delete struct {
+	Filters []string
+	Columns []string
+	Block   bool
+}
+
+// ReadInConfig function reads in the config file for the environment specified in the GO_ENV
+// environment variable. This is the best way to create a new Super Graph config.
+func ReadInConfig(configFile string) (*Config, error) {
+	cpath := path.Dir(configFile)
+	cfile := path.Base(configFile)
+	vi := newViper(cpath, cfile)
+
+	if err := vi.ReadInConfig(); err != nil {
+		return nil, err
+	}
+
+	inherits := vi.GetString("inherits")
+
+	if len(inherits) != 0 {
+		vi = newViper(cpath, inherits)
+
+		if err := vi.ReadInConfig(); err != nil {
+			return nil, err
+		}
+
+		if vi.IsSet("inherits") {
+			return nil, fmt.Errorf("inherited config (%s) cannot itself inherit (%s)",
+				inherits,
+				vi.GetString("inherits"))
+		}
+
+		vi.SetConfigName(cfile)
+
+		if err := vi.MergeInConfig(); err != nil {
+			return nil, err
+		}
+	}
+
+	c := &Config{}
+
+	if err := vi.Unmarshal(&c); err != nil {
+		return nil, fmt.Errorf("failed to decode config, %v", err)
+	}
+
+	if len(c.AllowListFile) == 0 {
+		c.AllowListFile = path.Join(cpath, "allow.list")
+	}
+
+	return c, nil
+}
+
+func newViper(configPath, configFile string) *viper.Viper {
+	vi := viper.New()
+
+	vi.SetEnvPrefix("SG")
+	vi.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
+	vi.AutomaticEnv()
+
+	vi.SetConfigName(configFile)
+	vi.AddConfigPath(configPath)
+	vi.AddConfigPath("./config")
+
+	return vi
+}

core/consts.go

@@ -0,0 +1,19 @@
+package core
+
+import (
+	"context"
+	"errors"
+)
+
+const (
+	openVar  = "{{"
+	closeVar = "}}"
+)
+
+var (
+	errNotFound = errors.New("not found in prepared statements")
+)
+
+func keyExists(ct context.Context, key contextkey) bool {
+	return ct.Value(key) != nil
+}

core/core.go

@@ -0,0 +1,395 @@
+package core
+
+import (
+	"bytes"
+	"context"
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/dosco/super-graph/core/internal/psql"
+	"github.com/dosco/super-graph/core/internal/qcode"
+
+	"github.com/valyala/fasttemplate"
+)
+
+type extensions struct {
+	Tracing *trace `json:"tracing,omitempty"`
+}
+
+type trace struct {
+	Version   int           `json:"version"`
+	StartTime time.Time     `json:"startTime"`
+	EndTime   time.Time     `json:"endTime"`
+	Duration  time.Duration `json:"duration"`
+	Execution execution     `json:"execution"`
+}
+
+type execution struct {
+	Resolvers []resolver `json:"resolvers"`
+}
+
+type resolver struct {
+	Path        []string      `json:"path"`
+	ParentType  string        `json:"parentType"`
+	FieldName   string        `json:"fieldName"`
+	ReturnType  string        `json:"returnType"`
+	StartOffset int           `json:"startOffset"`
+	Duration    time.Duration `json:"duration"`
+}
+
+type scontext struct {
+	context.Context
+
+	sg    *SuperGraph
+	query string
+	vars  json.RawMessage
+	role  string
+	res   Result
+}
+
+func (sg *SuperGraph) initCompilers() error {
+	di, err := psql.GetDBInfo(sg.db)
+	if err != nil {
+		return err
+	}
+
+	if err = addTables(sg.conf, di); err != nil {
+		return err
+	}
+
+	if err = addForeignKeys(sg.conf, di); err != nil {
+		return err
+	}
+
+	sg.schema, err = psql.NewDBSchema(di, getDBTableAliases(sg.conf))
+	if err != nil {
+		return err
+	}
+
+	sg.qc, err = qcode.NewCompiler(qcode.Config{
+		Blocklist: sg.conf.Blocklist,
+	})
+	if err != nil {
+		return err
+	}
+
+	if err := addRoles(sg.conf, sg.qc); err != nil {
+		return err
+	}
+
+	sg.pc = psql.NewCompiler(psql.Config{
+		Schema: sg.schema,
+		Vars:   sg.conf.Vars,
+	})
+
+	return nil
+}
+
+func (c *scontext) execQuery() ([]byte, error) {
+	var data []byte
+	var st *stmt
+	var err error
+
+	if c.sg.conf.UseAllowList {
+		data, st, err = c.resolvePreparedSQL()
+		if err != nil {
+			return nil, err
+		}
+
+	} else {
+		data, st, err = c.resolveSQL()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if len(data) == 0 || st.skipped == 0 {
+		return data, nil
+	}
+
+	// return c.sg.execRemoteJoin(st, data, c.req.hdr)
+	return c.sg.execRemoteJoin(st, data, nil)
+}
+
+func (c *scontext) resolvePreparedSQL() ([]byte, *stmt, error) {
+	var tx *sql.Tx
+	var err error
+
+	mutation := (c.res.op == qcode.QTMutation)
+	useRoleQuery := c.sg.abacEnabled && mutation
+	useTx := useRoleQuery || c.sg.conf.SetUserID
+
+	if useTx {
+		if tx, err = c.sg.db.BeginTx(c, nil); err != nil {
+			return nil, nil, err
+		}
+		defer tx.Rollback() //nolint: errcheck
+	}
+
+	if c.sg.conf.SetUserID {
+		if err := setLocalUserID(c, tx); err != nil {
+			return nil, nil, err
+		}
+	}
+
+	var role string
+
+	if useRoleQuery {
+		if role, err = c.executeRoleQuery(tx); err != nil {
+			return nil, nil, err
+		}
+
+	} else if v := c.Value(UserRoleKey); v != nil {
+		role = v.(string)
+
+	} else {
+		role = c.role
+
+	}
+
+	c.res.role = role
+
+	ps, ok := c.sg.prepared[stmtHash(c.res.name, role)]
+	if !ok {
+		return nil, nil, errNotFound
+	}
+	c.res.sql = ps.st.sql
+
+	var root []byte
+	var row *sql.Row
+
+	varsList, err := c.argList(ps.args)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if useTx {
+		row = tx.Stmt(ps.sd).QueryRow(varsList...)
+	} else {
+		row = ps.sd.QueryRow(varsList...)
+	}
+
+	if ps.roleArg {
+		err = row.Scan(&role, &root)
+	} else {
+		err = row.Scan(&root)
+	}
+
+	if err != nil {
+		return nil, nil, err
+	}
+
+	c.role = role
+
+	if useTx {
+		if err := tx.Commit(); err != nil {
+			return nil, nil, err
+		}
+	}
+
+	if root, err = c.sg.encryptCursor(ps.st.qc, root); err != nil {
+		return nil, nil, err
+	}
+
+	return root, &ps.st, nil
+}
+
+func (c *scontext) resolveSQL() ([]byte, *stmt, error) {
+	var tx *sql.Tx
+	var err error
+
+	mutation := (c.res.op == qcode.QTMutation)
+	useRoleQuery := c.sg.abacEnabled && mutation
+	useTx := useRoleQuery || c.sg.conf.SetUserID
+
+	if useTx {
+		if tx, err = c.sg.db.BeginTx(c, nil); err != nil {
+			return nil, nil, err
+		}
+		defer tx.Rollback() //nolint: errcheck
+	}
+
+	if c.sg.conf.SetUserID {
+		if err := setLocalUserID(c, tx); err != nil {
+			return nil, nil, err
+		}
+	}
+
+	if useRoleQuery {
+		if c.role, err = c.executeRoleQuery(tx); err != nil {
+			return nil, nil, err
+		}
+
+	} else if v := c.Value(UserRoleKey); v != nil {
+		c.role = v.(string)
+	}
+
+	stmts, err := c.sg.buildStmt(c.res.op, []byte(c.query), c.vars, c.role)
+	if err != nil {
+		return nil, nil, err
+	}
+	st := &stmts[0]
+
+	t := fasttemplate.New(st.sql, openVar, closeVar)
+	buf := &bytes.Buffer{}
+
+	_, err = t.ExecuteFunc(buf, c.argMap())
+	if err != nil {
+		return nil, nil, err
+	}
+	finalSQL := buf.String()
+
+	// var stime time.Time
+
+	// if c.sg.conf.EnableTracing {
+	// 	stime = time.Now()
+	// }
+
+	var root []byte
+	var role string
+	var row *sql.Row
+
+	// defaultRole := c.role
+
+	if useTx {
+		row = tx.QueryRow(finalSQL)
+	} else {
+		row = c.sg.db.QueryRow(finalSQL)
+	}
+
+	if len(stmts) > 1 {
+		err = row.Scan(&role, &root)
+	} else {
+		err = row.Scan(&root)
+	}
+
+	c.res.sql = finalSQL
+
+	if len(role) == 0 {
+		c.res.role = c.role
+	} else {
+		c.res.role = role
+	}
+
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if useTx {
+		if err := tx.Commit(); err != nil {
+			return nil, nil, err
+		}
+	}
+
+	if root, err = c.sg.encryptCursor(st.qc, root); err != nil {
+		return nil, nil, err
+	}
+
+	if c.sg.allowList.IsPersist() {
+		if err := c.sg.allowList.Set(c.vars, c.query, ""); err != nil {
+			return nil, nil, err
+		}
+	}
+
+	if len(stmts) > 1 {
+		if st = findStmt(role, stmts); st == nil {
+			return nil, nil, fmt.Errorf("invalid role '%s' returned", role)
+		}
+	}
+
+	// if c.sg.conf.EnableTracing {
+	// 	for _, id := range st.qc.Roots {
+	// 		c.addTrace(st.qc.Selects, id, stime)
+	// 	}
+	// }
+
+	return root, st, nil
+}
+
+func (c *scontext) executeRoleQuery(tx *sql.Tx) (string, error) {
+	userID := c.Value(UserIDKey)
+
+	if userID == nil {
+		return "anon", nil
+	}
+
+	var role string
+	row := c.sg.getRole.QueryRow(userID, c.role)
+
+	if err := row.Scan(&role); err != nil {
+		return "", err
+	}
+
+	return role, nil
+}
+
+func (r *Result) Operation() string {
+	return r.op.String()
+}
+
+func (r *Result) QueryName() string {
+	return r.name
+}
+
+func (r *Result) Role() string {
+	return r.role
+}
+
+func (r *Result) SQL() string {
+	return r.sql
+}
+
+// func (c *scontext) addTrace(sel []qcode.Select, id int32, st time.Time) {
+// 	et := time.Now()
+// 	du := et.Sub(st)
+
+// 	if c.res.Extensions == nil {
+// 		c.res.Extensions = &extensions{&trace{
+// 			Version:   1,
+// 			StartTime: st,
+// 			Execution: execution{},
+// 		}}
+// 	}
+
+// 	c.res.Extensions.Tracing.EndTime = et
+// 	c.res.Extensions.Tracing.Duration = du
+
+// 	n := 1
+// 	for i := id; i != -1; i = sel[i].ParentID {
+// 		n++
+// 	}
+// 	path := make([]string, n)
+
+// 	n--
+// 	for i := id; ; i = sel[i].ParentID {
+// 		path[n] = sel[i].Name
+// 		if sel[i].ParentID == -1 {
+// 			break
+// 		}
+// 		n--
+// 	}
+
+// 	tr := resolver{
+// 		Path:        path,
+// 		ParentType:  "Query",
+// 		FieldName:   sel[id].Name,
+// 		ReturnType:  "object",
+// 		StartOffset: 1,
+// 		Duration:    du,
+// 	}
+
+// 	c.res.Extensions.Tracing.Execution.Resolvers =
+// 		append(c.res.Extensions.Tracing.Execution.Resolvers, tr)
+// }
+
+func findStmt(role string, stmts []stmt) *stmt {
+	for i := range stmts {
+		if stmts[i].role.Name != role {
+			continue
+		}
+		return &stmts[i]
+	}
+	return nil
+}

core/core_test.go

@@ -1,4 +1,4 @@
-package serv
+package core
 
 /*
 

core/cursor.go

@@ -0,0 +1,72 @@
+package core
+
+import (
+	"bytes"
+	"encoding/base64"
+
+	"github.com/dosco/super-graph/core/internal/crypto"
+	"github.com/dosco/super-graph/core/internal/qcode"
+	"github.com/dosco/super-graph/jsn"
+)
+
+func (sg *SuperGraph) encryptCursor(qc *qcode.QCode, data []byte) ([]byte, error) {
+	var keys [][]byte
+
+	for _, s := range qc.Selects {
+		if s.Paging.Type != qcode.PtOffset {
+			var buf bytes.Buffer
+
+			buf.WriteString(s.FieldName)
+			buf.WriteString("_cursor")
+			keys = append(keys, buf.Bytes())
+		}
+	}
+
+	if len(keys) == 0 {
+		return data, nil
+	}
+
+	from := jsn.Get(data, keys)
+	to := make([]jsn.Field, len(from))
+
+	for i, f := range from {
+		to[i].Key = f.Key
+
+		if f.Value[0] != '"' || f.Value[len(f.Value)-1] != '"' {
+			continue
+		}
+
+		var buf bytes.Buffer
+
+		if len(f.Value) > 2 {
+			v, err := crypto.Encrypt(f.Value[1:len(f.Value)-1], &sg.encKey)
+			if err != nil {
+				return nil, err
+			}
+
+			buf.WriteByte('"')
+			buf.WriteString(base64.StdEncoding.EncodeToString(v))
+			buf.WriteByte('"')
+		} else {
+			buf.WriteString(`null`)
+		}
+
+		to[i].Value = buf.Bytes()
+	}
+
+	var buf bytes.Buffer
+
+	if err := jsn.Replace(&buf, data, from, to); err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+func (sg *SuperGraph) decrypt(data string) ([]byte, error) {
+	v, err := base64.StdEncoding.DecodeString(data)
+	if err != nil {
+		return nil, err
+	}
+	return crypto.Decrypt(v, &sg.encKey)
+}

core/db.go

@@ -0,0 +1,15 @@
+package core
+
+import (
+	"context"
+	"database/sql"
+)
+
+func setLocalUserID(c context.Context, tx *sql.Tx) error {
+	var err error
+	if v := c.Value(UserIDKey); v != nil {
+		_, err = tx.Exec(`SET LOCAL "user.id" = ?`, v)
+	}
+
+	return err
+}

core/init.go

@@ -0,0 +1,285 @@
+package core
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+	"unicode"
+
+	"github.com/dosco/super-graph/core/internal/psql"
+	"github.com/dosco/super-graph/core/internal/qcode"
+	"github.com/gobuffalo/flect"
+)
+
+func (sg *SuperGraph) initConfig() error {
+	c := sg.conf
+
+	for k, v := range c.Inflections {
+		flect.AddPlural(k, v)
+	}
+
+	// Variables: Validate and sanitize
+	for k, v := range c.Vars {
+		c.Vars[k] = sanitizeVars(v)
+	}
+
+	// Tables: Validate and sanitize
+	tm := make(map[string]struct{})
+
+	for i := 0; i < len(c.Tables); i++ {
+		t := &c.Tables[i]
+		t.Name = flect.Pluralize(strings.ToLower(t.Name))
+
+		if _, ok := tm[t.Name]; ok {
+			sg.conf.Tables = append(c.Tables[:i], c.Tables[i+1:]...)
+			sg.log.Printf("WRN duplicate table found: %s", t.Name)
+		}
+		tm[t.Name] = struct{}{}
+
+		t.Table = flect.Pluralize(strings.ToLower(t.Table))
+	}
+
+	sg.roles = make(map[string]*Role)
+
+	for i := 0; i < len(c.Roles); i++ {
+		role := &c.Roles[i]
+		role.Name = sanitize(role.Name)
+
+		if _, ok := sg.roles[role.Name]; ok {
+			c.Roles = append(c.Roles[:i], c.Roles[i+1:]...)
+			sg.log.Printf("WRN duplicate role found: %s", role.Name)
+		}
+
+		role.Match = sanitize(role.Match)
+		role.tm = make(map[string]*RoleTable)
+
+		for n, table := range role.Tables {
+			role.tm[table.Name] = &role.Tables[n]
+		}
+
+		sg.roles[role.Name] = role
+	}
+
+	// If user role not defined then create it
+	if _, ok := sg.roles["user"]; !ok {
+		ur := Role{
+			Name: "user",
+			tm:   make(map[string]*RoleTable),
+		}
+		c.Roles = append(c.Roles, ur)
+		sg.roles["user"] = &ur
+	}
+
+	// Roles: validate and sanitize
+	c.RolesQuery = sanitizeVars(c.RolesQuery)
+
+	if len(c.RolesQuery) == 0 {
+		sg.log.Printf("WRN roles_query not defined: attribute based access control disabled")
+	}
+
+	_, userExists := sg.roles["user"]
+	_, sg.anonExists = sg.roles["anon"]
+
+	sg.abacEnabled = userExists && len(c.RolesQuery) != 0
+
+	return nil
+}
+
+func getDBTableAliases(c *Config) map[string][]string {
+	m := make(map[string][]string, len(c.Tables))
+
+	for i := range c.Tables {
+		t := c.Tables[i]
+
+		if len(t.Table) == 0 || len(t.Columns) != 0 {
+			continue
+		}
+
+		m[t.Table] = append(m[t.Table], t.Name)
+	}
+	return m
+}
+
+func addTables(c *Config, di *psql.DBInfo) error {
+	for _, t := range c.Tables {
+		if len(t.Table) == 0 || len(t.Columns) == 0 {
+			continue
+		}
+		if err := addTable(di, t.Columns, t); err != nil {
+			return err
+		}
+
+	}
+	return nil
+}
+
+func addTable(di *psql.DBInfo, cols []Column, t Table) error {
+	bc, ok := di.GetColumn(t.Table, t.Name)
+	if !ok {
+		return fmt.Errorf(
+			"Column '%s' not found on table '%s'",
+			t.Name, t.Table)
+	}
+
+	if bc.Type != "json" && bc.Type != "jsonb" {
+		return fmt.Errorf(
+			"Column '%s' in table '%s' is of type '%s'. Only JSON or JSONB is valid",
+			t.Name, t.Table, bc.Type)
+	}
+
+	table := psql.DBTable{
+		Name: t.Name,
+		Key:  strings.ToLower(t.Name),
+		Type: bc.Type,
+	}
+
+	columns := make([]psql.DBColumn, 0, len(cols))
+
+	for i := range cols {
+		c := cols[i]
+		columns = append(columns, psql.DBColumn{
+			Name: c.Name,
+			Key:  strings.ToLower(c.Name),
+			Type: c.Type,
+		})
+	}
+
+	di.AddTable(table, columns)
+	bc.FKeyTable = t.Name
+
+	return nil
+}
+
+func addForeignKeys(c *Config, di *psql.DBInfo) error {
+	for _, t := range c.Tables {
+		for _, c := range t.Columns {
+			if len(c.ForeignKey) == 0 {
+				continue
+			}
+			if err := addForeignKey(di, c, t); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func addForeignKey(di *psql.DBInfo, c Column, t Table) error {
+	c1, ok := di.GetColumn(t.Name, c.Name)
+	if !ok {
+		return fmt.Errorf(
+			"Invalid table '%s' or column '%s' in Config",
+			t.Name, c.Name)
+	}
+
+	v := strings.SplitN(c.ForeignKey, ".", 2)
+	if len(v) != 2 {
+		return fmt.Errorf(
+			"Invalid foreign_key in Config for table '%s' and column '%s",
+			t.Name, c.Name)
+	}
+
+	fkt, fkc := v[0], v[1]
+	c2, ok := di.GetColumn(fkt, fkc)
+	if !ok {
+		return fmt.Errorf(
+			"Invalid foreign_key in Config for table '%s' and column '%s",
+			t.Name, c.Name)
+	}
+
+	c1.FKeyTable = fkt
+	c1.FKeyColID = []int16{c2.ID}
+
+	return nil
+}
+
+func addRoles(c *Config, qc *qcode.Compiler) error {
+	for _, r := range c.Roles {
+		for _, t := range r.Tables {
+			if err := addRole(qc, r, t); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func addRole(qc *qcode.Compiler, r Role, t RoleTable) error {
+	blockFilter := []string{"false"}
+
+	query := qcode.QueryConfig{
+		Limit:            t.Query.Limit,
+		Filters:          t.Query.Filters,
+		Columns:          t.Query.Columns,
+		DisableFunctions: t.Query.DisableFunctions,
+	}
+
+	if t.Query.Block {
+		query.Filters = blockFilter
+	}
+
+	insert := qcode.InsertConfig{
+		Filters: t.Insert.Filters,
+		Columns: t.Insert.Columns,
+		Presets: t.Insert.Presets,
+	}
+
+	if t.Insert.Block {
+		insert.Filters = blockFilter
+	}
+
+	update := qcode.UpdateConfig{
+		Filters: t.Update.Filters,
+		Columns: t.Update.Columns,
+		Presets: t.Update.Presets,
+	}
+
+	if t.Update.Block {
+		update.Filters = blockFilter
+	}
+
+	delete := qcode.DeleteConfig{
+		Filters: t.Delete.Filters,
+		Columns: t.Delete.Columns,
+	}
+
+	if t.Delete.Block {
+		delete.Filters = blockFilter
+	}
+
+	return qc.AddRole(r.Name, t.Name, qcode.TRConfig{
+		Query:  query,
+		Insert: insert,
+		Update: update,
+		Delete: delete,
+	})
+}
+
+func (r *Role) GetTable(name string) *RoleTable {
+	return r.tm[name]
+}
+
+func sanitize(value string) string {
+	return strings.ToLower(strings.TrimSpace(value))
+}
+
+var (
+	varRe1 = regexp.MustCompile(`(?mi)\$([a-zA-Z0-9_.]+)`)
+	varRe2 = regexp.MustCompile(`\{\{([a-zA-Z0-9_.]+)\}\}`)
+)
+
+func sanitizeVars(s string) string {
+	s0 := varRe1.ReplaceAllString(s, `{{$1}}`)
+
+	s1 := strings.Map(func(r rune) rune {
+		if unicode.IsSpace(r) {
+			return ' '
+		}
+		return r
+	}, s0)
+
+	return varRe2.ReplaceAllStringFunc(s1, func(m string) string {
+		return strings.ToLower(m)
+	})
+}

core/internal/allow/allow.go

@@ -0,0 +1,360 @@
+package allow
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"sort"
+	"strings"
+)
+
+const (
+	AL_QUERY int = iota + 1
+	AL_VARS
+)
+
+type Item struct {
+	Name    string
+	key     string
+	Query   string
+	Vars    json.RawMessage
+	Comment string
+}
+
+type List struct {
+	filepath string
+	saveChan chan Item
+}
+
+type Config struct {
+	CreateIfNotExists bool
+	Persist           bool
+}
+
+func New(filename string, conf Config) (*List, error) {
+	al := List{}
+
+	if len(filename) != 0 {
+		fp := filename
+
+		if _, err := os.Stat(fp); err == nil {
+			al.filepath = fp
+		} else if !os.IsNotExist(err) {
+			return nil, err
+		}
+	}
+
+	if len(al.filepath) == 0 {
+		fp := "./allow.list"
+
+		if _, err := os.Stat(fp); err == nil {
+			al.filepath = fp
+		} else if !os.IsNotExist(err) {
+			return nil, err
+		}
+	}
+
+	if len(al.filepath) == 0 {
+		fp := "./config/allow.list"
+
+		if _, err := os.Stat(fp); err == nil {
+			al.filepath = fp
+		} else if !os.IsNotExist(err) {
+			return nil, err
+		}
+	}
+
+	if len(al.filepath) == 0 {
+		if !conf.CreateIfNotExists {
+			return nil, errors.New("allow.list not found")
+		}
+
+		if len(filename) == 0 {
+			al.filepath = "./config/allow.list"
+		} else {
+			al.filepath = filename
+		}
+	}
+
+	var err error
+
+	if conf.Persist {
+		al.saveChan = make(chan Item)
+
+		go func() {
+			for v := range al.saveChan {
+				if err = al.save(v); err != nil {
+					break
+				}
+			}
+		}()
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &al, nil
+}
+
+func (al *List) IsPersist() bool {
+	return al.saveChan != nil
+}
+
+func (al *List) Set(vars []byte, query, comment string) error {
+	if al.saveChan == nil {
+		return errors.New("allow.list is read-only")
+	}
+
+	if len(query) == 0 {
+		return errors.New("empty query")
+	}
+
+	var q string
+
+	for i := 0; i < len(query); i++ {
+		c := query[i]
+		if c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' {
+			q = query
+			break
+
+		} else if c == '{' {
+			q = "query " + query
+			break
+		}
+	}
+
+	al.saveChan <- Item{
+		Comment: comment,
+		Query:   q,
+		Vars:    vars,
+	}
+
+	return nil
+}
+
+func (al *List) Load() ([]Item, error) {
+	var list []Item
+
+	b, err := ioutil.ReadFile(al.filepath)
+	if err != nil {
+		return list, err
+	}
+
+	if len(b) == 0 {
+		return list, nil
+	}
+
+	var comment bytes.Buffer
+	var varBytes []byte
+
+	itemMap := make(map[string]struct{})
+
+	s, e, c := 0, 0, 0
+	ty := 0
+
+	for {
+		fq := false
+
+		if c == 0 && b[e] == '#' {
+			s = e
+			for e < len(b) && b[e] != '\n' {
+				e++
+			}
+			if (e - s) > 2 {
+				comment.Write(b[(s + 1):(e + 1)])
+			}
+		}
+
+		if e >= len(b) {
+			break
+		}
+
+		if matchPrefix(b, e, "query") || matchPrefix(b, e, "mutation") {
+			if c == 0 {
+				s = e
+			}
+			ty = AL_QUERY
+		} else if matchPrefix(b, e, "variables") {
+			if c == 0 {
+				s = e + len("variables") + 1
+			}
+			ty = AL_VARS
+		} else if b[e] == '{' {
+			c++
+
+		} else if b[e] == '}' {
+			c--
+
+			if c == 0 {
+				if ty == AL_QUERY {
+					fq = true
+				} else if ty == AL_VARS {
+					varBytes = b[s:(e + 1)]
+				}
+				ty = 0
+			}
+		}
+
+		if fq {
+			query := string(b[s:(e + 1)])
+			name := QueryName(query)
+			key := strings.ToLower(name)
+
+			if _, ok := itemMap[key]; !ok {
+				v := Item{
+					Name:    name,
+					key:     key,
+					Query:   query,
+					Vars:    varBytes,
+					Comment: comment.String(),
+				}
+				list = append(list, v)
+				comment.Reset()
+			}
+
+			varBytes = nil
+
+		}
+
+		e++
+		if e >= len(b) {
+			break
+		}
+	}
+
+	return list, nil
+}
+
+func (al *List) save(item Item) error {
+	item.Name = QueryName(item.Query)
+	item.key = strings.ToLower(item.Name)
+
+	if len(item.Name) == 0 {
+		return nil
+	}
+
+	list, err := al.Load()
+	if err != nil {
+		return err
+	}
+
+	index := -1
+
+	for i, v := range list {
+		if strings.EqualFold(v.Name, item.Name) {
+			index = i
+			break
+		}
+	}
+
+	if index != -1 {
+		if len(list[index].Comment) != 0 {
+			item.Comment = list[index].Comment
+		}
+		list[index] = item
+	} else {
+		list = append(list, item)
+	}
+
+	f, err := os.Create(al.filepath)
+	if err != nil {
+		return err
+	}
+
+	defer f.Close()
+
+	sort.Slice(list, func(i, j int) bool {
+		return strings.Compare(list[i].key, list[j].key) == -1
+	})
+
+	for _, v := range list {
+		cmtLines := strings.Split(v.Comment, "\n")
+
+		i := 0
+		for _, c := range cmtLines {
+			if c = strings.TrimSpace(c); len(c) == 0 {
+				continue
+			}
+
+			_, err := f.WriteString(fmt.Sprintf("# %s\n", c))
+			if err != nil {
+				return err
+			}
+			i++
+		}
+
+		if i != 0 {
+			if _, err := f.WriteString("\n"); err != nil {
+				return err
+			}
+		} else {
+			if _, err := f.WriteString(fmt.Sprintf("# Query named %s\n\n", v.Name)); err != nil {
+				return err
+			}
+		}
+
+		if len(v.Vars) != 0 && !bytes.Equal(v.Vars, []byte("{}")) {
+			vj, err := json.MarshalIndent(v.Vars, "", "  ")
+			if err != nil {
+				return fmt.Errorf("failed to marshal vars: %v", err)
+			}
+
+			_, err = f.WriteString(fmt.Sprintf("variables %s\n\n", vj))
+			if err != nil {
+				return err
+			}
+		}
+
+		if v.Query[0] == '{' {
+			_, err = f.WriteString(fmt.Sprintf("query %s\n\n", v.Query))
+		} else {
+			_, err = f.WriteString(fmt.Sprintf("%s\n\n", v.Query))
+		}
+
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func matchPrefix(b []byte, i int, s string) bool {
+	if (len(b) - i) < len(s) {
+		return false
+	}
+	for n := 0; n < len(s); n++ {
+		if b[(i+n)] != s[n] {
+			return false
+		}
+	}
+	return true
+}
+
+func QueryName(b string) string {
+	state, s := 0, 0
+
+	for i := 0; i < len(b); i++ {
+		switch {
+		case state == 2 && !isValidNameChar(b[i]):
+			return b[s:i]
+		case state == 1 && b[i] == '{':
+			return ""
+		case state == 1 && isValidNameChar(b[i]):
+			s = i
+			state = 2
+		case i != 0 && b[i] == ' ' && (b[i-1] == 'n' || b[i-1] == 'y'):
+			state = 1
+		}
+	}
+
+	return ""
+}
+
+func isValidNameChar(c byte) bool {
+	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_'
+}

core/internal/allow/allow_test.go

@@ -0,0 +1,84 @@
+package allow
+
+import (
+	"testing"
+)
+
+func TestGQLName1(t *testing.T) {
+	var q = `
+	query {
+		products(
+			distinct: [price]
+			where: { id: { and: { greater_or_equals: 20, lt: 28 } } }
+		) { id name } }`
+
+	name := QueryName(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 := QueryName(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 := QueryName(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 := QueryName(q)
+
+	if name != "no_worries" {
+		t.Fatal("Name should be 'no_worries', not ", name)
+	}
+}
+
+func TestGQLName5(t *testing.T) {
+	var q = `
+	    {
+		users {
+			id
+		}
+	}`
+
+	name := QueryName(q)
+
+	if len(name) != 0 {
+		t.Fatal("Name should be empty, not ", name)
+	}
+}

core/internal/allow/fuzz_test.go

@@ -0,0 +1,15 @@
+package allow
+
+import "testing"
+
+func TestFuzzCrashers(t *testing.T) {
+	var crashers = []string{
+		"query",
+		"q",
+		"que",
+	}
+
+	for _, f := range crashers {
+		_ = QueryName(f)
+	}
+}

core/internal/crypto/encrypt.go

@@ -0,0 +1,80 @@
+// cryptopasta - basic cryptography examples
+//
+// Written in 2015 by George Tankersley <george.tankersley@gmail.com>
+//
+// To the extent possible under law, the author(s) have dedicated all copyright
+// and related and neighboring rights to this software to the public domain
+// worldwide. This software is distributed without any warranty.
+//
+// You should have received a copy of the CC0 Public Domain Dedication along
+// with this software. If not, see // <http://creativecommons.org/publicdomain/zero/1.0/>.
+
+// Provides symmetric authenticated encryption using 256-bit AES-GCM with a random nonce.
+package crypto
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+	"errors"
+	"io"
+)
+
+// NewEncryptionKey generates a random 256-bit key for Encrypt() and
+// Decrypt(). It panics if the source of randomness fails.
+func NewEncryptionKey() [32]byte {
+	key := [32]byte{}
+	_, err := io.ReadFull(rand.Reader, key[:])
+	if err != nil {
+		panic(err)
+	}
+	return key
+}
+
+// Encrypt encrypts data using 256-bit AES-GCM.  This both hides the content of
+// the data and provides a check that it hasn't been altered. Output takes the
+// form nonce|ciphertext|tag where '|' indicates concatenation.
+func Encrypt(plaintext []byte, key *[32]byte) (ciphertext []byte, err error) {
+	block, err := aes.NewCipher(key[:])
+	if err != nil {
+		return nil, err
+	}
+
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return nil, err
+	}
+
+	nonce := make([]byte, gcm.NonceSize())
+	_, err = io.ReadFull(rand.Reader, nonce)
+	if err != nil {
+		return nil, err
+	}
+
+	return gcm.Seal(nonce, nonce, plaintext, nil), nil
+}
+
+// Decrypt decrypts data using 256-bit AES-GCM.  This both hides the content of
+// the data and provides a check that it hasn't been altered. Expects input
+// form nonce|ciphertext|tag where '|' indicates concatenation.
+func Decrypt(ciphertext []byte, key *[32]byte) (plaintext []byte, err error) {
+	block, err := aes.NewCipher(key[:])
+	if err != nil {
+		return nil, err
+	}
+
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(ciphertext) < gcm.NonceSize() {
+		return nil, errors.New("malformed ciphertext")
+	}
+
+	return gcm.Open(nil,
+		ciphertext[:gcm.NonceSize()],
+		ciphertext[gcm.NonceSize():],
+		nil,
+	)
+}

core/internal/integration_tests/cockroachdb/cockroachdb_test.go

@@ -0,0 +1,84 @@
+package cockraochdb_test
+
+import (
+	"database/sql"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"regexp"
+	"sync/atomic"
+	"testing"
+
+	integration_tests "github.com/dosco/super-graph/core/internal/integration_tests"
+	_ "github.com/jackc/pgx/v4/stdlib"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCockroachDB(t *testing.T) {
+
+	dir, err := ioutil.TempDir("", "temp-cockraochdb-")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	cmd := exec.Command("cockroach", "start", "--insecure", "--listen-addr", ":0", "--http-addr", ":0", "--store=path="+dir)
+	finder := &urlFinder{
+		c: make(chan bool),
+	}
+	cmd.Stdout = finder
+	cmd.Stderr = ioutil.Discard
+
+	err = cmd.Start()
+	if err != nil {
+		t.Skip("is CockroachDB installed?: " + err.Error())
+	}
+	fmt.Println("started temporary cockroach db")
+
+	stopped := int32(0)
+	stopDatabase := func() {
+		fmt.Println("stopping temporary cockroach db")
+		if atomic.CompareAndSwapInt32(&stopped, 0, 1) {
+			cmd.Process.Kill()
+			cmd.Process.Wait()
+			os.RemoveAll(dir)
+		}
+	}
+	defer stopDatabase()
+
+	// Wait till we figure out the URL we should connect to...
+	<-finder.c
+	db, err := sql.Open("pgx", finder.URL)
+	if err != nil {
+		stopDatabase()
+		require.NoError(t, err)
+	}
+	integration_tests.SetupSchema(t, db)
+
+	integration_tests.TestSuperGraph(t, db, func(t *testing.T) {
+		if t.Name() == "TestCockroachDB/nested_insert" {
+			t.Skip("nested inserts currently not working yet on cockroach db")
+		}
+	})
+}
+
+type urlFinder struct {
+	c    chan bool
+	done bool
+	URL  string
+}
+
+func (finder *urlFinder) Write(p []byte) (n int, err error) {
+	s := string(p)
+	urlRegex := regexp.MustCompile(`\nsql:\s+(postgresql:[^\s]+)\n`)
+	if !finder.done {
+		submatch := urlRegex.FindAllStringSubmatch(s, -1)
+		if submatch != nil {
+			finder.URL = submatch[0][1]
+			finder.done = true
+			close(finder.c)
+		}
+	}
+	return len(p), nil
+}

core/internal/integration_tests/integration_tests.go

@@ -0,0 +1,143 @@
+package integration_tests
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"testing"
+
+	"github.com/dosco/super-graph/core"
+	"github.com/stretchr/testify/require"
+)
+
+func SetupSchema(t *testing.T, db *sql.DB) {
+
+	_, err := db.Exec(`
+CREATE TABLE users (
+  id 		 integer PRIMARY KEY,
+  full_name  text
+)`)
+	require.NoError(t, err)
+
+	_, err = db.Exec(`CREATE TABLE product (
+  id            integer PRIMARY KEY,
+  name          text,
+  weight        float
+)`)
+	require.NoError(t, err)
+
+	_, err = db.Exec(`CREATE TABLE line_item (
+  id            integer PRIMARY KEY,
+  product       integer REFERENCES product(id),
+  quantity      integer,
+  price      	float
+)`)
+	require.NoError(t, err)
+}
+
+func DropSchema(t *testing.T, db *sql.DB) {
+
+	_, err := db.Exec(`DROP TABLE IF EXISTS line_item`)
+	require.NoError(t, err)
+
+	_, err = db.Exec(`DROP TABLE IF EXISTS product`)
+	require.NoError(t, err)
+
+	_, err = db.Exec(`DROP TABLE IF EXISTS users`)
+	require.NoError(t, err)
+}
+
+func TestSuperGraph(t *testing.T, db *sql.DB, before func(t *testing.T)) {
+	config := core.Config{}
+	config.UseAllowList = false
+	config.AllowListFile = "./allow.list"
+	config.RolesQuery = `SELECT * FROM users WHERE id = $user_id`
+
+	config.Roles = []core.Role{
+		core.Role{
+			Name: "anon",
+			Tables: []core.RoleTable{
+				core.RoleTable{Name: "users", Query: core.Query{Limit: 100}},
+				core.RoleTable{Name: "product", Query: core.Query{Limit: 100}},
+				core.RoleTable{Name: "line_item", Query: core.Query{Limit: 100}},
+			},
+		},
+	}
+
+	sg, err := core.NewSuperGraph(&config, db)
+	require.NoError(t, err)
+	ctx := context.Background()
+
+	t.Run("seed fixtures", func(t *testing.T) {
+		before(t)
+		res, err := sg.GraphQL(ctx,
+			`mutation { products (insert: $products) { id } }`,
+			json.RawMessage(`{"products":[
+{"id":1, "name":"Charmin Ultra Soft", "weight": 0.5},
+{"id":2, "name":"Hand Sanitizer", "weight": 0.2},
+{"id":3, "name":"Case of Corona", "weight": 1.2}
+]}`))
+		require.NoError(t, err, res.SQL())
+		require.Equal(t, `{"products": [{"id": 1}, {"id": 2}, {"id": 3}]}`, string(res.Data))
+
+		res, err = sg.GraphQL(ctx,
+			`mutation { line_items (insert: $line_items) { id } }`,
+			json.RawMessage(`{"line_items":[
+{"id":5001, "product":1, "price":6.95, "quantity":10},
+{"id":5002, "product":2, "price":10.99, "quantity":2}
+]}`))
+		require.NoError(t, err, res.SQL())
+		require.Equal(t, `{"line_items": [{"id": 5001}, {"id": 5002}]}`, string(res.Data))
+	})
+
+	t.Run("get line items", func(t *testing.T) {
+		before(t)
+		res, err := sg.GraphQL(ctx,
+			`query { line_items { id, price, quantity } }`,
+			json.RawMessage(`{}`))
+		require.NoError(t, err, res.SQL())
+		require.Equal(t, `{"line_items": [{"id": 5001, "price": 6.95, "quantity": 10}, {"id": 5002, "price": 10.99, "quantity": 2}]}`, string(res.Data))
+	})
+
+	t.Run("update line item", func(t *testing.T) {
+		before(t)
+		res, err := sg.GraphQL(ctx,
+			`mutation { line_item(update:$update, id:$id) { id } }`,
+			json.RawMessage(`{"id":5001, "update":{"quantity":20}}`))
+		require.NoError(t, err, res.SQL())
+		require.Equal(t, `{"line_item": {"id": 5001}}`, string(res.Data))
+
+		res, err = sg.GraphQL(ctx,
+			`query { line_item(id:$id) { id, price, quantity } }`,
+			json.RawMessage(`{"id":5001}`))
+		require.NoError(t, err, res.SQL())
+		require.Equal(t, `{"line_item": {"id": 5001, "price": 6.95, "quantity": 20}}`, string(res.Data))
+	})
+
+	t.Run("delete line item", func(t *testing.T) {
+		before(t)
+		res, err := sg.GraphQL(ctx,
+			`mutation { line_item(delete:true, id:$id) { id } }`,
+			json.RawMessage(`{"id":5002}`))
+		require.NoError(t, err, res.SQL())
+		require.Equal(t, `{"line_item": {"id": 5002}}`, string(res.Data))
+
+		res, err = sg.GraphQL(ctx,
+			`query { line_items { id, price, quantity } }`,
+			json.RawMessage(`{}`))
+		require.NoError(t, err, res.SQL())
+		require.Equal(t, `{"line_items": [{"id": 5001, "price": 6.95, "quantity": 20}]}`, string(res.Data))
+	})
+
+	t.Run("nested insert", func(t *testing.T) {
+		before(t)
+		res, err := sg.GraphQL(ctx,
+			`mutation { line_items (insert: $line_item) { id, product { name } } }`,
+			json.RawMessage(`{"line_item":
+{"id":5003, "product": { "connect": { "id": 1} }, "price":10.95, "quantity":15}
+}`))
+		require.NoError(t, err, res.SQL())
+		require.Equal(t, `{"line_items": [{"id": 5003, "product": {"name": "Charmin Ultra Soft"}}]}`, string(res.Data))
+	})
+
+}

core/internal/integration_tests/postgresql/postgresql_test.go

@@ -0,0 +1,27 @@
+package cockraochdb_test
+
+import (
+	"database/sql"
+	"os"
+	"testing"
+
+	integration_tests "github.com/dosco/super-graph/core/internal/integration_tests"
+	_ "github.com/jackc/pgx/v4/stdlib"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCockroachDB(t *testing.T) {
+
+	url, found := os.LookupEnv("SG_POSTGRESQL_TEST_URL")
+	if !found {
+		t.Skip("set the SG_POSTGRESQL_TEST_URL env variable if you want to run integration tests against a PostgreSQL database")
+	}
+
+	db, err := sql.Open("pgx", url)
+	require.NoError(t, err)
+
+	integration_tests.DropSchema(t, db)
+	integration_tests.SetupSchema(t, db)
+	integration_tests.TestSuperGraph(t, db, func(t *testing.T) {
+	})
+}

core/internal/psql/columns.go

@@ -0,0 +1,216 @@
+//nolint:errcheck
+package psql
+
+import (
+	"errors"
+	"io"
+	"strings"
+
+	"github.com/dosco/super-graph/core/internal/qcode"
+)
+
+func (c *compilerContext) renderBaseColumns(
+	sel *qcode.Select,
+	ti *DBTableInfo,
+	childCols []*qcode.Column,
+	skipped uint32) ([]int, bool, error) {
+
+	var realColsRendered []int
+
+	colcount := (len(sel.Cols) + len(sel.OrderBy) + 1)
+	colmap := make(map[string]struct{}, colcount)
+
+	isSearch := sel.Args["search"] != nil
+	isCursorPaged := sel.Paging.Type != qcode.PtOffset
+	isAgg := false
+
+	i := 0
+	for n, col := range sel.Cols {
+		cn := col.Name
+		colmap[cn] = struct{}{}
+
+		_, isRealCol := ti.ColMap[cn]
+
+		if isRealCol {
+			c.renderComma(i)
+			realColsRendered = append(realColsRendered, n)
+			colWithTable(c.w, ti.Name, cn)
+
+		} else {
+			switch {
+			case isSearch && cn == "search_rank":
+				if err := c.renderColumnSearchRank(sel, ti, col, i); err != nil {
+					return nil, false, err
+				}
+
+			case isSearch && strings.HasPrefix(cn, "search_headline_"):
+				if err := c.renderColumnSearchHeadline(sel, ti, col, i); err != nil {
+					return nil, false, err
+				}
+
+			case cn == "__typename":
+				if err := c.renderColumnTypename(sel, ti, col, i); err != nil {
+					return nil, false, err
+				}
+
+			case strings.HasSuffix(cn, "_cursor"):
+				continue
+
+			default:
+				if err := c.renderColumnFunction(sel, ti, col, i); err != nil {
+					return nil, false, err
+				}
+
+				isAgg = true
+			}
+		}
+		i++
+
+	}
+
+	if isCursorPaged {
+		if _, ok := colmap[ti.PrimaryCol.Key]; !ok {
+			colmap[ti.PrimaryCol.Key] = struct{}{}
+			c.renderComma(i)
+			colWithTable(c.w, ti.Name, ti.PrimaryCol.Name)
+		}
+		i++
+	}
+
+	for _, ob := range sel.OrderBy {
+		if _, ok := colmap[ob.Col]; ok {
+			continue
+		}
+		colmap[ob.Col] = struct{}{}
+		c.renderComma(i)
+		colWithTable(c.w, ti.Name, ob.Col)
+		i++
+	}
+
+	for _, col := range childCols {
+		if _, ok := colmap[col.Name]; ok {
+			continue
+		}
+		c.renderComma(i)
+		colWithTable(c.w, col.Table, col.Name)
+		i++
+	}
+
+	return realColsRendered, isAgg, nil
+}
+
+func (c *compilerContext) renderColumnSearchRank(sel *qcode.Select, ti *DBTableInfo, col qcode.Column, columnsRendered int) error {
+	if isColumnBlocked(sel, col.Name) {
+		return nil
+	}
+
+	if ti.TSVCol == nil {
+		return errors.New("no ts_vector column found")
+	}
+	cn := ti.TSVCol.Name
+	arg := sel.Args["search"]
+
+	c.renderComma(columnsRendered)
+	//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)
+	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, `}}'))`)
+	alias(c.w, col.Name)
+
+	return nil
+}
+
+func (c *compilerContext) renderColumnSearchHeadline(sel *qcode.Select, ti *DBTableInfo, col qcode.Column, columnsRendered int) error {
+	cn := col.Name[16:]
+
+	if isColumnBlocked(sel, cn) {
+		return nil
+	}
+	arg := sel.Args["search"]
+
+	c.renderComma(columnsRendered)
+	//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, cn)
+	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, `}}'))`)
+	alias(c.w, col.Name)
+
+	return nil
+}
+
+func (c *compilerContext) renderColumnTypename(sel *qcode.Select, ti *DBTableInfo, col qcode.Column, columnsRendered int) error {
+	if isColumnBlocked(sel, col.Name) {
+		return nil
+	}
+
+	c.renderComma(columnsRendered)
+	io.WriteString(c.w, `(`)
+	squoted(c.w, ti.Name)
+	io.WriteString(c.w, ` :: text)`)
+	alias(c.w, col.Name)
+
+	return nil
+}
+
+func (c *compilerContext) renderColumnFunction(sel *qcode.Select, ti *DBTableInfo, col qcode.Column, columnsRendered int) error {
+	pl := funcPrefixLen(col.Name)
+	// if pl == 0 {
+	// 	//fmt.Fprintf(w, `'%s not defined' AS %s`, cn, col.Name)
+	// 	io.WriteString(c.w, `'`)
+	// 	io.WriteString(c.w, col.Name)
+	// 	io.WriteString(c.w, ` not defined'`)
+	// 	alias(c.w, col.Name)
+	// }
+
+	if pl == 0 || !sel.Functions {
+		return nil
+	}
+
+	cn := col.Name[pl:]
+
+	if isColumnBlocked(sel, cn) {
+		return nil
+	}
+
+	fn := col.Name[:pl-1]
+
+	c.renderComma(columnsRendered)
+
+	//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, cn)
+	io.WriteString(c.w, `)`)
+	alias(c.w, col.Name)
+
+	return nil
+}
+
+func (c *compilerContext) renderComma(columnsRendered int) {
+	if columnsRendered != 0 {
+		io.WriteString(c.w, `, `)
+	}
+}
+
+func isColumnBlocked(sel *qcode.Select, name string) bool {
+	if len(sel.Allowed) != 0 {
+		if _, ok := sel.Allowed[name]; !ok {
+			return true
+		}
+	}
+	return false
+}

core/internal/psql/fuzz.go

@@ -0,0 +1,54 @@
+// +build gofuzz
+
+package psql
+
+import (
+	"encoding/json"
+	"github.com/dosco/super-graph/core/internal/qcode"
+)
+
+var (
+	qcompileTest, _ = qcode.NewCompiler(qcode.Config{})
+
+	schema = getTestSchema()
+
+	vars = NewVariables(map[string]string{
+		"admin_account_id": "5",
+	})
+
+	pcompileTest = NewCompiler(Config{
+		Schema: schema,
+		Vars:   vars,
+	})
+)
+
+// FuzzerEntrypoint for Fuzzbuzz
+func Fuzz(data []byte) int {
+	gql := `mutation {
+		product(insert: $data) {
+			id
+			name
+			user {
+				id
+				full_name
+				email
+			}
+		}
+	}`
+
+	qc, err := qcompileTest.Compile([]byte(gql), "user")
+	if err != nil {
+		panic("qcompile can't fail")
+	}
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(data),
+	}
+
+	_, _, err = pcompileTest.CompileEx(qc, vars)
+	if err != nil {
+		return 0
+	}
+
+	return 1
+}

core/internal/psql/insert.go

@@ -0,0 +1,187 @@
+//nolint:errcheck
+package psql
+
+import (
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/dosco/super-graph/core/internal/qcode"
+	"github.com/dosco/super-graph/core/internal/util"
+)
+
+func (c *compilerContext) renderInsert(qc *qcode.QCode, w io.Writer,
+	vars Variables, ti *DBTableInfo) (uint32, error) {
+
+	insert, ok := vars[qc.ActionVar]
+	if !ok {
+		return 0, fmt.Errorf("variable '%s' not defined", qc.ActionVar)
+	}
+	if len(insert) == 0 {
+		return 0, fmt.Errorf("variable '%s' is empty", qc.ActionVar)
+	}
+
+	io.WriteString(c.w, `WITH "_sg_input" AS (SELECT `)
+	if insert[0] == '[' {
+		io.WriteString(c.w, `json_array_elements(`)
+	}
+	io.WriteString(c.w, `'{{`)
+	io.WriteString(c.w, qc.ActionVar)
+	io.WriteString(c.w, `}}' :: json`)
+	if insert[0] == '[' {
+		io.WriteString(c.w, `)`)
+	}
+	io.WriteString(c.w, ` AS j)`)
+
+	st := util.NewStack()
+	st.Push(kvitem{_type: itemInsert, key: ti.Name, val: insert, ti: ti})
+
+	for {
+		if st.Len() == 0 {
+			break
+		}
+		if insert[0] == '[' && st.Len() > 1 {
+			return 0, errors.New("Nested bulk insert not supported")
+		}
+		intf := st.Pop()
+
+		switch item := intf.(type) {
+		case kvitem:
+			if err := c.handleKVItem(st, item); err != nil {
+				return 0, err
+			}
+
+		case renitem:
+			var err error
+
+			// if w := qc.Selects[0].Where; w != nil && w.Op == qcode.OpFalse {
+			// 	io.WriteString(c.w, ` WHERE false`)
+			// }
+
+			switch item._type {
+			case itemInsert:
+				err = c.renderInsertStmt(qc, w, item)
+			case itemConnect:
+				err = c.renderConnectStmt(qc, w, item)
+			case itemUnion:
+				err = c.renderUnionStmt(w, item)
+			}
+
+			if err != nil {
+				return 0, err
+			}
+		}
+	}
+	io.WriteString(c.w, ` `)
+
+	return 0, nil
+}
+
+func (c *compilerContext) renderInsertStmt(qc *qcode.QCode, w io.Writer, item renitem) error {
+
+	ti := item.ti
+	jt := item.data
+	sk := nestedInsertRelColumnsMap(item.kvitem)
+
+	io.WriteString(c.w, `, `)
+	renderCteName(w, item.kvitem)
+	io.WriteString(w, ` AS (`)
+
+	io.WriteString(w, `INSERT INTO `)
+	quoted(w, ti.Name)
+	io.WriteString(w, ` (`)
+	renderInsertUpdateColumns(w, qc, jt, ti, sk, false)
+	renderNestedInsertRelColumns(w, item.kvitem, false)
+	io.WriteString(w, `)`)
+
+	io.WriteString(w, ` SELECT `)
+	renderInsertUpdateColumns(w, qc, jt, ti, sk, true)
+	renderNestedInsertRelColumns(w, item.kvitem, true)
+
+	io.WriteString(w, ` FROM "_sg_input" i`)
+	renderNestedInsertRelTables(w, item.kvitem)
+	io.WriteString(w, ` RETURNING *)`)
+	return nil
+}
+
+func nestedInsertRelColumnsMap(item kvitem) map[string]struct{} {
+	sk := make(map[string]struct{}, len(item.items))
+
+	if len(item.items) == 0 {
+		if item.relPC != nil && item.relPC.Type == RelOneToMany {
+			sk[item.relPC.Right.Col] = struct{}{}
+		}
+	} else {
+		for _, v := range item.items {
+			if v.relCP.Type == RelOneToMany {
+				sk[v.relCP.Right.Col] = struct{}{}
+			}
+		}
+	}
+
+	return sk
+}
+
+func renderNestedInsertRelColumns(w io.Writer, item kvitem, values bool) error {
+	if len(item.items) == 0 {
+		if item.relPC != nil && item.relPC.Type == RelOneToMany {
+			if values {
+				colWithTable(w, item.relPC.Left.Table, item.relPC.Left.Col)
+			} else {
+				quoted(w, item.relPC.Right.Col)
+			}
+		}
+	} else {
+		// Render child foreign key columns if child-to-parent
+		// relationship is one-to-many
+		i := 0
+		for _, v := range item.items {
+			if v.relCP.Type == RelOneToMany {
+				if i != 0 {
+					io.WriteString(w, `, `)
+				}
+				if values {
+					if v._ctype > 0 {
+						io.WriteString(w, `"_x_`)
+						io.WriteString(w, v.relCP.Left.Table)
+						io.WriteString(w, `".`)
+						quoted(w, v.relCP.Left.Col)
+					} else {
+						colWithTable(w, v.relCP.Left.Table, v.relCP.Left.Col)
+					}
+				} else {
+					quoted(w, v.relCP.Right.Col)
+				}
+				i++
+			}
+		}
+	}
+
+	return nil
+}
+
+func renderNestedInsertRelTables(w io.Writer, item kvitem) error {
+	if len(item.items) == 0 {
+		if item.relPC != nil && item.relPC.Type == RelOneToMany {
+			io.WriteString(w, `, `)
+			quoted(w, item.relPC.Left.Table)
+		}
+	} else {
+		// Render tables needed to set values if child-to-parent
+		// relationship is one-to-many
+		for _, v := range item.items {
+			if v.relCP.Type == RelOneToMany {
+				io.WriteString(w, `, `)
+				if v._ctype > 0 {
+					io.WriteString(w, `"_x_`)
+					io.WriteString(w, v.relCP.Left.Table)
+					io.WriteString(w, `"`)
+				} else {
+					quoted(w, v.relCP.Left.Table)
+				}
+			}
+		}
+	}
+
+	return nil
+}

core/internal/psql/insert_test.go

@@ -0,0 +1,271 @@
+package psql
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func simpleInsert(t *testing.T) {
+	gql := `mutation {
+		user(insert: $data) {
+			id
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{"email": "reannagreenholt@orn.com", "full_name": "Flo Barton"}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "user")
+}
+
+func singleInsert(t *testing.T) {
+	gql := `mutation {
+		product(id: $id, insert: $insert) {
+			id
+			name
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"insert": json.RawMessage(` { "name": "my_name", "price": 6.95, "description": "my_desc", "user_id": 5 }`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "anon")
+}
+
+func bulkInsert(t *testing.T) {
+	gql := `mutation {
+		product(name: "test", id: $id, insert: $insert) {
+			id
+			name
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"insert": json.RawMessage(` [{ "name": "my_name", "description": "my_desc"  }]`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "anon")
+}
+
+func simpleInsertWithPresets(t *testing.T) {
+	gql := `mutation {
+		product(insert: $data) {
+			id
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{"name": "Tomato", "price": 5.76}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "user")
+}
+
+func nestedInsertManyToMany(t *testing.T) {
+	gql := `mutation {
+		purchase(insert: $data) {
+			sale_type
+			quantity
+			due_date
+			customer {
+				id
+				full_name
+				email
+			}
+			product {
+				id
+				name
+				price
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(` {
+			"sale_type": "bought",
+			"quantity": 5,
+			"due_date": "now",
+			"customer": {
+				"email": "thedude@rug.com",
+				"full_name": "The Dude"
+			},
+			"product": {
+				"name": "Apple",
+				"price": 1.25
+			}
+		}
+	`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func nestedInsertOneToMany(t *testing.T) {
+	gql := `mutation {
+		user(insert: $data) {
+			id
+			full_name
+			email
+			product {
+				id
+				name
+				price
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{
+			"email": "thedude@rug.com",
+			"full_name": "The Dude",
+			"created_at": "now",
+			"updated_at": "now",
+			"product": {
+				"name": "Apple",
+				"price": 1.25,
+				"created_at": "now",
+				"updated_at": "now"
+			}
+		}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func nestedInsertOneToOne(t *testing.T) {
+	gql := `mutation {
+		product(insert: $data) {
+			id
+			name
+			user {
+				id
+				full_name
+				email
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{
+			"name": "Apple",
+			"price": 1.25,
+			"created_at": "now",
+			"updated_at": "now",
+			"user": {
+				"hey": {
+					"now": "what's the matter"
+				},
+				"email": "thedude@rug.com",
+				"full_name": "The Dude",
+				"created_at": "now",
+				"updated_at": "now"
+			}
+		}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func nestedInsertOneToManyWithConnect(t *testing.T) {
+	gql := `mutation {
+		user(insert: $data) {
+			id
+			full_name
+			email
+			product {
+				id
+				name
+				price
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{
+			"email": "thedude@rug.com",
+			"full_name": "The Dude",
+			"created_at": "now",
+			"updated_at": "now",
+			"product": {
+				"connect": { "id": 5 }
+			}
+		}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func nestedInsertOneToOneWithConnect(t *testing.T) {
+	gql := `mutation {
+		product(insert: $data) {
+			id
+			name
+			tags {
+				id
+				name
+			}
+			user {
+				id
+				full_name
+				email
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{
+			"name": "Apple",
+			"price": 1.25,
+			"created_at": "now",
+			"updated_at": "now",
+			"user": {
+				"connect": { "id": 5 }
+			}
+		}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func nestedInsertOneToOneWithConnectArray(t *testing.T) {
+	gql := `mutation {
+		product(insert: $data) {
+			id
+			name
+			user {
+				id
+				full_name
+				email
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{
+			"name": "Apple",
+			"price": 1.25,
+			"created_at": "now",
+			"updated_at": "now",
+			"user": {
+				"connect": { "id": [1,2] }
+			}
+		}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func TestCompileInsert(t *testing.T) {
+	t.Run("simpleInsert", simpleInsert)
+	t.Run("singleInsert", singleInsert)
+	t.Run("bulkInsert", bulkInsert)
+	t.Run("simpleInsertWithPresets", simpleInsertWithPresets)
+	t.Run("nestedInsertManyToMany", nestedInsertManyToMany)
+	t.Run("nestedInsertOneToMany", nestedInsertOneToMany)
+	t.Run("nestedInsertOneToOne", nestedInsertOneToOne)
+	t.Run("nestedInsertOneToManyWithConnect", nestedInsertOneToManyWithConnect)
+	t.Run("nestedInsertOneToOneWithConnect", nestedInsertOneToOneWithConnect)
+	t.Run("nestedInsertOneToOneWithConnectArray", nestedInsertOneToOneWithConnectArray)
+}

core/internal/psql/mutate.go

@@ -0,0 +1,699 @@
+//nolint:errcheck
+package psql
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/dosco/super-graph/core/internal/qcode"
+	"github.com/dosco/super-graph/core/internal/util"
+	"github.com/dosco/super-graph/jsn"
+)
+
+type itemType int
+
+const (
+	itemInsert itemType = iota + 1
+	itemUpdate
+	itemConnect
+	itemDisconnect
+	itemUnion
+)
+
+var insertTypes = map[string]itemType{
+	"connect": itemConnect,
+}
+
+var updateTypes = map[string]itemType{
+	"connect":    itemConnect,
+	"disconnect": itemDisconnect,
+}
+
+var noLimit = qcode.Paging{NoLimit: true}
+
+func (co *Compiler) compileMutation(qc *qcode.QCode, w io.Writer, vars Variables) (uint32, error) {
+	if len(qc.Selects) == 0 {
+		return 0, errors.New("empty query")
+	}
+
+	c := &compilerContext{w, qc.Selects, co}
+	root := &qc.Selects[0]
+
+	ti, err := c.schema.GetTable(root.Name)
+	if err != nil {
+		return 0, err
+	}
+
+	switch qc.Type {
+	case qcode.QTInsert:
+		if _, err := c.renderInsert(qc, w, vars, ti); err != nil {
+			return 0, err
+		}
+
+	case qcode.QTUpdate:
+		if _, err := c.renderUpdate(qc, w, vars, ti); err != nil {
+			return 0, err
+		}
+
+	case qcode.QTUpsert:
+		if _, err := c.renderUpsert(qc, w, vars, ti); err != nil {
+			return 0, err
+		}
+
+	case qcode.QTDelete:
+		if _, err := c.renderDelete(qc, w, vars, ti); err != nil {
+			return 0, err
+		}
+
+	default:
+		return 0, errors.New("valid mutations are 'insert', 'update', 'upsert' and 'delete'")
+	}
+
+	root.Paging = noLimit
+	root.DistinctOn = root.DistinctOn[:]
+	root.OrderBy = root.OrderBy[:]
+	root.Where = nil
+	root.Args = nil
+
+	return c.compileQuery(qc, w, vars)
+}
+
+type kvitem struct {
+	id     int32
+	_type  itemType
+	_ctype int
+	key    string
+	path   []string
+	val    json.RawMessage
+	data   map[string]json.RawMessage
+	array  bool
+	ti     *DBTableInfo
+	relCP  *DBRel
+	relPC  *DBRel
+	items  []kvitem
+}
+
+type renitem struct {
+	kvitem
+	array bool
+	data  map[string]json.RawMessage
+}
+
+// TODO: Handle cases where a column name matches the child table name
+// the child path needs to be exluded in the json sent to insert or update
+
+func (c *compilerContext) handleKVItem(st *util.Stack, item kvitem) error {
+	var data map[string]json.RawMessage
+	var array bool
+	var err error
+
+	if item.data == nil {
+		data, array, err = jsn.Tree(item.val)
+		if err != nil {
+			return err
+		}
+	} else {
+		data, array = item.data, item.array
+	}
+
+	var unionize bool
+	id := item.id + 1
+
+	item.items = make([]kvitem, 0, len(data))
+
+	for k, v := range data {
+		if v[0] != '{' && v[0] != '[' {
+			continue
+		}
+
+		// Get child-to-parent relationship
+		relCP, err := c.schema.GetRel(k, item.key)
+		if err != nil {
+			var ty itemType
+			var ok bool
+
+			switch item._type {
+			case itemInsert:
+				ty, ok = insertTypes[k]
+			case itemUpdate:
+				ty, ok = updateTypes[k]
+			}
+
+			if ok {
+				unionize = true
+				item1 := item
+				item1._type = ty
+				item1.id = id
+				item1.val = v
+
+				item.items = append(item.items, item1)
+				id++
+			}
+
+			// Get parent-to-child relationship
+		} else if relPC, err := c.schema.GetRel(item.key, k); err == nil {
+			ti, err := c.schema.GetTable(k)
+			if err != nil {
+				return err
+			}
+
+			item1 := kvitem{
+				id:    id,
+				_type: item._type,
+				key:   k,
+				val:   v,
+				path:  append(item.path, k),
+				ti:    ti,
+				relCP: relCP,
+				relPC: relPC,
+			}
+
+			if v[0] == '{' {
+				item1.data, item1.array, err = jsn.Tree(v)
+				if err != nil {
+					return err
+				}
+				if v1, ok := item1.data["connect"]; ok && (v1[0] == '{' || v1[0] == '[') {
+					item1._ctype |= (1 << itemConnect)
+				}
+				if v1, ok := item1.data["disconnect"]; ok && (v1[0] == '{' || v1[0] == '[') {
+					item1._ctype |= (1 << itemDisconnect)
+				}
+			}
+
+			item.items = append(item.items, item1)
+			id++
+		}
+	}
+
+	if unionize {
+		item._type = itemUnion
+	}
+
+	// For inserts order the children according to
+	// the creation order required by the parent-to-child
+	// relationships. For example users need to be created
+	// before the products they own.
+
+	// For updates the order defined in the query must be
+	// the order used.
+	switch item._type {
+	case itemInsert:
+		for _, v := range item.items {
+			if v.relPC.Type == RelOneToMany {
+				st.Push(v)
+			}
+		}
+		st.Push(renitem{kvitem: item, array: array, data: data})
+		for _, v := range item.items {
+			if v.relPC.Type == RelOneToOne {
+				st.Push(v)
+			}
+		}
+
+	case itemUpdate:
+		for _, v := range item.items {
+			if !(v._ctype > 0 && v.relPC.Type == RelOneToOne) {
+				st.Push(v)
+			}
+		}
+		st.Push(renitem{kvitem: item, array: array, data: data})
+		for _, v := range item.items {
+			if v._ctype > 0 && v.relPC.Type == RelOneToOne {
+				st.Push(v)
+			}
+		}
+
+	case itemUnion:
+		st.Push(renitem{kvitem: item, array: array, data: data})
+		for _, v := range item.items {
+			st.Push(v)
+		}
+
+	default:
+		for _, v := range item.items {
+			st.Push(v)
+		}
+		st.Push(renitem{kvitem: item, array: array, data: data})
+	}
+
+	return nil
+}
+
+func (c *compilerContext) renderUnionStmt(w io.Writer, item renitem) error {
+	var connect, disconnect bool
+
+	// Render only for parent-to-child relationship of one-to-many
+	if item.relPC.Type != RelOneToMany {
+		return nil
+	}
+
+	for _, v := range item.items {
+		if v._type == itemConnect {
+			connect = true
+		} else if v._type == itemDisconnect {
+			disconnect = true
+		}
+		if connect && disconnect {
+			break
+		}
+	}
+
+	if connect {
+		io.WriteString(w, `, `)
+		if connect && disconnect {
+			renderCteNameWithSuffix(w, item.kvitem, "c")
+		} else {
+			quoted(w, item.ti.Name)
+		}
+		io.WriteString(w, ` AS ( UPDATE `)
+		quoted(w, item.ti.Name)
+		io.WriteString(w, ` SET `)
+		quoted(w, item.relPC.Right.Col)
+		io.WriteString(w, ` = `)
+
+		// When setting the id of the connected table in a one-to-many setting
+		// we always overwrite the value including for array columns
+		colWithTable(w, item.relPC.Left.Table, item.relPC.Left.Col)
+
+		io.WriteString(w, ` FROM `)
+		quoted(w, item.relPC.Left.Table)
+		io.WriteString(w, ` WHERE`)
+
+		i := 0
+		for _, v := range item.items {
+			if v._type == itemConnect {
+				if i != 0 {
+					io.WriteString(w, ` OR (`)
+				} else {
+					io.WriteString(w, ` (`)
+				}
+				if err := renderWhereFromJSON(w, v, "connect", v.val); err != nil {
+					return err
+				}
+				io.WriteString(w, `)`)
+				i++
+			}
+		}
+		io.WriteString(w, ` RETURNING `)
+		quoted(w, item.ti.Name)
+		io.WriteString(w, `.*)`)
+	}
+
+	if disconnect {
+		io.WriteString(w, `, `)
+		if connect && disconnect {
+			renderCteNameWithSuffix(w, item.kvitem, "d")
+		} else {
+			quoted(w, item.ti.Name)
+		}
+		io.WriteString(w, ` AS ( UPDATE `)
+		quoted(w, item.ti.Name)
+		io.WriteString(w, ` SET `)
+		quoted(w, item.relPC.Right.Col)
+		io.WriteString(w, ` = `)
+
+		if item.relPC.Right.Array {
+			io.WriteString(w, ` array_remove(`)
+			quoted(w, item.relPC.Right.Col)
+			io.WriteString(w, `, `)
+			colWithTable(w, item.relPC.Left.Table, item.relPC.Left.Col)
+			io.WriteString(w, `)`)
+
+		} else {
+			io.WriteString(w, ` NULL`)
+		}
+
+		io.WriteString(w, ` FROM `)
+		quoted(w, item.relPC.Left.Table)
+		io.WriteString(w, ` WHERE`)
+
+		i := 0
+		for _, v := range item.items {
+			if v._type == itemDisconnect {
+				if i != 0 {
+					io.WriteString(w, ` OR (`)
+				} else {
+					io.WriteString(w, ` (`)
+				}
+				if err := renderWhereFromJSON(w, v, "disconnect", v.val); err != nil {
+					return err
+				}
+				io.WriteString(w, `)`)
+				i++
+			}
+		}
+		io.WriteString(w, ` RETURNING `)
+		quoted(w, item.ti.Name)
+		io.WriteString(w, `.*)`)
+	}
+
+	if connect && disconnect {
+		io.WriteString(w, `, `)
+		quoted(w, item.ti.Name)
+		io.WriteString(w, ` AS (`)
+		io.WriteString(w, `SELECT * FROM `)
+		renderCteNameWithSuffix(w, item.kvitem, "c")
+		io.WriteString(w, ` UNION ALL `)
+		io.WriteString(w, `SELECT * FROM `)
+		renderCteNameWithSuffix(w, item.kvitem, "d")
+		io.WriteString(w, `)`)
+	}
+
+	return nil
+}
+
+func renderInsertUpdateColumns(w io.Writer,
+	qc *qcode.QCode,
+	jt map[string]json.RawMessage,
+	ti *DBTableInfo,
+	skipcols map[string]struct{},
+	values bool) (uint32, error) {
+
+	root := &qc.Selects[0]
+	renderedCol := false
+
+	n := 0
+	for _, cn := range ti.Columns {
+		if _, ok := skipcols[cn.Name]; ok {
+			continue
+		}
+		if _, ok := jt[cn.Key]; !ok {
+			continue
+		}
+		if _, ok := root.PresetMap[cn.Key]; ok {
+			continue
+		}
+		if len(root.Allowed) != 0 {
+			if _, ok := root.Allowed[cn.Key]; !ok {
+				continue
+			}
+		}
+		if n != 0 {
+			io.WriteString(w, `, `)
+		}
+
+		if values {
+			io.WriteString(w, `CAST( i.j ->>`)
+			io.WriteString(w, `'`)
+			io.WriteString(w, cn.Name)
+			io.WriteString(w, `' AS `)
+			io.WriteString(w, cn.Type)
+			io.WriteString(w, `)`)
+		} else {
+			quoted(w, cn.Name)
+		}
+
+		if !renderedCol {
+			renderedCol = true
+		}
+		n++
+	}
+
+	for i := range root.PresetList {
+		cn := root.PresetList[i]
+		col, ok := ti.ColMap[cn]
+		if !ok {
+			continue
+		}
+		if _, ok := skipcols[col.Name]; ok {
+			continue
+		}
+		if i != 0 || n != 0 {
+			io.WriteString(w, `, `)
+		}
+
+		if values {
+			io.WriteString(w, `'`)
+			io.WriteString(w, root.PresetMap[cn])
+			io.WriteString(w, `' :: `)
+			io.WriteString(w, col.Type)
+		} else {
+			quoted(w, cn)
+		}
+
+		if !renderedCol {
+			renderedCol = true
+		}
+	}
+
+	if len(skipcols) != 0 && renderedCol {
+		io.WriteString(w, `, `)
+	}
+	return 0, nil
+}
+
+func (c *compilerContext) renderUpsert(qc *qcode.QCode, w io.Writer,
+	vars Variables, ti *DBTableInfo) (uint32, error) {
+	root := &qc.Selects[0]
+
+	upsert, ok := vars[qc.ActionVar]
+	if !ok {
+		return 0, fmt.Errorf("variable '%s' not defined", qc.ActionVar)
+	}
+	if len(upsert) == 0 {
+		return 0, fmt.Errorf("variable '%s' is empty", qc.ActionVar)
+	}
+
+	if ti.PrimaryCol == nil {
+		return 0, fmt.Errorf("no primary key column found")
+	}
+
+	jt, _, err := jsn.Tree(upsert)
+	if err != nil {
+		return 0, err
+	}
+
+	if _, err := c.renderInsert(qc, w, vars, ti); err != nil {
+		return 0, err
+	}
+
+	io.WriteString(c.w, ` ON CONFLICT (`)
+	i := 0
+
+	for _, cn := range ti.Columns {
+		if _, ok := jt[cn.Key]; !ok {
+			continue
+		}
+
+		if col, ok := ti.ColMap[cn.Key]; !ok || !(col.UniqueKey || col.PrimaryKey) {
+			continue
+		}
+
+		if i != 0 {
+			io.WriteString(c.w, `, `)
+		}
+		io.WriteString(c.w, cn.Name)
+		i++
+	}
+	if i == 0 {
+		io.WriteString(c.w, ti.PrimaryCol.Name)
+	}
+	io.WriteString(c.w, `)`)
+
+	if root.Where != nil {
+		io.WriteString(c.w, ` WHERE `)
+
+		if err := c.renderWhere(root, ti); err != nil {
+			return 0, err
+		}
+	}
+
+	io.WriteString(c.w, ` DO UPDATE SET `)
+
+	i = 0
+	for _, cn := range ti.Columns {
+		if _, ok := jt[cn.Key]; !ok {
+			continue
+		}
+		if i != 0 {
+			io.WriteString(c.w, `, `)
+		}
+		io.WriteString(c.w, cn.Name)
+		io.WriteString(c.w, ` = EXCLUDED.`)
+		io.WriteString(c.w, cn.Name)
+		i++
+	}
+
+	io.WriteString(c.w, ` RETURNING *) `)
+
+	return 0, nil
+}
+
+func (c *compilerContext) renderConnectStmt(qc *qcode.QCode, w io.Writer,
+	item renitem) error {
+
+	rel := item.relPC
+
+	// Render only for parent-to-child relationship of one-to-one
+	// For this to work the child needs to found first so it's primary key
+	// can be set in the related column on the parent object.
+	// Eg. Create product and connect a user to it.
+	if rel.Type != RelOneToOne {
+		return nil
+	}
+
+	io.WriteString(w, `, "_x_`)
+	io.WriteString(c.w, item.ti.Name)
+	io.WriteString(c.w, `" AS (SELECT `)
+
+	if rel.Left.Array {
+		io.WriteString(w, `array_agg(DISTINCT `)
+		quoted(w, rel.Right.Col)
+		io.WriteString(w, `) AS `)
+		quoted(w, rel.Right.Col)
+
+	} else {
+		quoted(w, rel.Right.Col)
+
+	}
+
+	io.WriteString(c.w, ` FROM "_sg_input" i,`)
+	quoted(c.w, item.ti.Name)
+
+	io.WriteString(c.w, ` WHERE `)
+	if err := renderWhereFromJSON(c.w, item.kvitem, "connect", item.kvitem.val); err != nil {
+		return err
+	}
+	io.WriteString(c.w, ` LIMIT 1)`)
+
+	return nil
+}
+
+func (c *compilerContext) renderDisconnectStmt(qc *qcode.QCode, w io.Writer,
+	item renitem) error {
+
+	rel := item.relPC
+
+	// Render only for parent-to-child relationship of one-to-one
+	// For this to work the child needs to found first so it's
+	// null value can beset in the related column on the parent object.
+	// Eg. Update product and diconnect the user from it.
+	if rel.Type != RelOneToOne {
+		return nil
+	}
+	io.WriteString(w, `, "_x_`)
+	io.WriteString(c.w, item.ti.Name)
+	io.WriteString(c.w, `" AS (`)
+
+	if rel.Right.Array {
+		io.WriteString(c.w, `SELECT `)
+		quoted(w, rel.Right.Col)
+		io.WriteString(c.w, ` FROM "_sg_input" i,`)
+		quoted(c.w, item.ti.Name)
+		io.WriteString(c.w, ` WHERE `)
+		if err := renderWhereFromJSON(c.w, item.kvitem, "connect", item.kvitem.val); err != nil {
+			return err
+		}
+		io.WriteString(c.w, ` LIMIT 1))`)
+
+	} else {
+		io.WriteString(c.w, `SELECT * FROM (VALUES(NULL::`)
+		io.WriteString(w, rel.Right.col.Type)
+		io.WriteString(c.w, `)) AS LOOKUP(`)
+		quoted(w, rel.Right.Col)
+		io.WriteString(c.w, `))`)
+	}
+
+	return nil
+}
+
+func renderWhereFromJSON(w io.Writer, item kvitem, key string, val []byte) error {
+	var kv map[string]json.RawMessage
+	ti := item.ti
+
+	if err := json.Unmarshal(val, &kv); err != nil {
+		return err
+	}
+	i := 0
+	for k, v := range kv {
+		col, ok := ti.ColMap[k]
+		if !ok {
+			continue
+		}
+		if i != 0 {
+			io.WriteString(w, ` AND `)
+		}
+
+		if v[0] == '[' {
+			colWithTable(w, ti.Name, k)
+
+			if col.Array {
+				io.WriteString(w, ` && `)
+			} else {
+				io.WriteString(w, ` = `)
+			}
+
+			io.WriteString(w, `ANY((select a::`)
+			io.WriteString(w, col.Type)
+
+			io.WriteString(w, ` AS list from json_array_elements_text(`)
+			renderPathJSON(w, item, key, k)
+			io.WriteString(w, `::json) AS a))`)
+
+		} else if col.Array {
+			io.WriteString(w, `(`)
+			renderPathJSON(w, item, key, k)
+			io.WriteString(w, `)::`)
+			io.WriteString(w, col.Type)
+
+			io.WriteString(w, ` = ANY(`)
+			colWithTable(w, ti.Name, k)
+			io.WriteString(w, `)`)
+
+		} else {
+			colWithTable(w, ti.Name, k)
+
+			io.WriteString(w, `= (`)
+			renderPathJSON(w, item, key, k)
+			io.WriteString(w, `)::`)
+			io.WriteString(w, col.Type)
+		}
+
+		i++
+	}
+	return nil
+}
+
+func renderPathJSON(w io.Writer, item kvitem, key1, key2 string) {
+	io.WriteString(w, `(i.j->`)
+	joinPath(w, item.path)
+	io.WriteString(w, `->'`)
+	io.WriteString(w, key1)
+	io.WriteString(w, `'->>'`)
+	io.WriteString(w, key2)
+	io.WriteString(w, `')`)
+}
+
+func renderCteName(w io.Writer, item kvitem) error {
+	io.WriteString(w, `"`)
+	io.WriteString(w, item.ti.Name)
+	if item._type == itemConnect || item._type == itemDisconnect {
+		io.WriteString(w, `_`)
+		int2string(w, item.id)
+	}
+	io.WriteString(w, `"`)
+	return nil
+}
+
+func renderCteNameWithSuffix(w io.Writer, item kvitem, suffix string) error {
+	io.WriteString(w, `"`)
+	io.WriteString(w, item.ti.Name)
+	io.WriteString(w, `_`)
+	io.WriteString(w, suffix)
+	io.WriteString(w, `"`)
+	return nil
+}
+
+func joinPath(w io.Writer, path []string) {
+	for i := range path {
+		if i != 0 {
+			io.WriteString(w, `->`)
+		}
+		io.WriteString(w, `'`)
+		io.WriteString(w, path[i])
+		io.WriteString(w, `'`)
+	}
+}

core/internal/psql/mutate_test.go

@@ -0,0 +1,123 @@
+package psql
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func singleUpsert(t *testing.T) {
+	gql := `mutation {
+		product(upsert: $upsert) {
+			id
+			name
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"upsert": json.RawMessage(` { "name": "my_name", "description": "my_desc"  }`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "user")
+}
+
+func singleUpsertWhere(t *testing.T) {
+	gql := `mutation {
+		product(upsert: $upsert, where: { price : { gt: 3 } }) {
+			id
+			name
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"upsert": json.RawMessage(` { "name": "my_name",  "description": "my_desc"  }`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "user")
+}
+
+func bulkUpsert(t *testing.T) {
+	gql := `mutation {
+		product(upsert: $upsert) {
+			id
+			name
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"upsert": json.RawMessage(` [{ "name": "my_name",  "description": "my_desc"  }]`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "user")
+}
+
+func delete(t *testing.T) {
+	gql := `mutation {
+		product(delete: true, where: { id: { eq: 1 } }) {
+			id
+			name
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"update": json.RawMessage(` { "name": "my_name", "description": "my_desc"  }`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "user")
+}
+
+// func blockedInsert(t *testing.T) {
+// 	gql := `mutation {
+// 		user(insert: $data) {
+// 			id
+// 		}
+// 	}`
+
+// 	sql := `WITH "users" AS (WITH "input" AS (SELECT '{{data}}' :: json AS j) INSERT INTO "users" ("full_name", "email") SELECT "full_name", "email" FROM input i, json_populate_record(NULL::users, i.j) t WHERE false RETURNING *) SELECT json_object_agg('user', json_0) FROM (SELECT row_to_json((SELECT "json_row_0" FROM (SELECT "users_0"."id" AS "id") AS "json_row_0")) AS "json_0" FROM (SELECT "users"."id" FROM "users" LIMIT ('1') :: integer) AS "users_0" LIMIT ('1') :: integer) AS "sel_0"`
+
+// 	vars := map[string]json.RawMessage{
+// 		"data": json.RawMessage(`{"email": "reannagreenholt@orn.com", "full_name": "Flo Barton"}`),
+// 	}
+
+// 	resSQL, err := compileGQLToPSQL(gql, vars, "bad_dude")
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+// 	fmt.Println(string(resSQL))
+
+// 	if string(resSQL) != sql {
+// 		t.Fatal(errNotExpected)
+// 	}
+// }
+
+// func blockedUpdate(t *testing.T) {
+// 	gql := `mutation {
+// 		user(where: { id: { lt: 5 } }, update: $data) {
+// 			id
+// 			email
+// 		}
+// 	}`
+
+// 	sql := `WITH "users" AS (WITH "input" AS (SELECT '{{data}}' :: json AS j) UPDATE "users" SET ("full_name", "email") = (SELECT "full_name", "email" FROM input i, json_populate_record(NULL::users, i.j) t) WHERE false RETURNING *) SELECT json_object_agg('user', json_0) FROM (SELECT row_to_json((SELECT "json_row_0" FROM (SELECT "users_0"."id" AS "id", "users_0"."email" AS "email") AS "json_row_0")) AS "json_0" FROM (SELECT "users"."id", "users"."email" FROM "users" LIMIT ('1') :: integer) AS "users_0" LIMIT ('1') :: integer) AS "sel_0"`
+
+// 	vars := map[string]json.RawMessage{
+// 		"data": json.RawMessage(`{"email": "reannagreenholt@orn.com", "full_name": "Flo Barton"}`),
+// 	}
+
+// 	resSQL, err := compileGQLToPSQL(gql, vars, "bad_dude")
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	if string(resSQL) != sql {
+// 		t.Fatal(errNotExpected)
+// 	}
+// }
+
+func TestCompileMutate(t *testing.T) {
+	t.Run("singleUpsert", singleUpsert)
+	t.Run("singleUpsertWhere", singleUpsertWhere)
+	t.Run("bulkUpsert", bulkUpsert)
+	t.Run("delete", delete)
+	// t.Run("blockedInsert", blockedInsert)
+	// t.Run("blockedUpdate", blockedUpdate)
+}

core/internal/psql/psql_test.go

@@ -0,0 +1,237 @@
+package psql
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/dosco/super-graph/core/internal/qcode"
+)
+
+const (
+	errNotExpected = "Generated SQL did not match what was expected"
+	headerMarker   = "=== RUN"
+	commentMarker  = "---"
+)
+
+var (
+	qcompile *qcode.Compiler
+	pcompile *Compiler
+	expected map[string][]string
+)
+
+func TestMain(m *testing.M) {
+	var err error
+
+	qcompile, err = qcode.NewCompiler(qcode.Config{
+		Blocklist: []string{
+			"secret",
+			"password",
+			"token",
+		},
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = qcompile.AddRole("user", "product", qcode.TRConfig{
+		Query: qcode.QueryConfig{
+			Columns: []string{"id", "name", "price", "users", "customers"},
+			Filters: []string{
+				"{ price: { gt: 0 } }",
+				"{ price: { lt: 8 } }",
+			},
+		},
+		Insert: qcode.InsertConfig{
+			Presets: map[string]string{
+				"user_id":    "$user_id",
+				"created_at": "now",
+				"updated_at": "now",
+			},
+		},
+		Update: qcode.UpdateConfig{
+			Filters: []string{"{ user_id: { eq: $user_id } }"},
+			Presets: map[string]string{"updated_at": "now"},
+		},
+		Delete: qcode.DeleteConfig{
+			Filters: []string{
+				"{ price: { gt: 0 } }",
+				"{ price: { lt: 8 } }",
+			},
+		},
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = qcompile.AddRole("anon", "product", qcode.TRConfig{
+		Query: qcode.QueryConfig{
+			Columns: []string{"id", "name"},
+		},
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = qcompile.AddRole("anon1", "product", qcode.TRConfig{
+		Query: qcode.QueryConfig{
+			Columns:          []string{"id", "name", "price"},
+			DisableFunctions: true,
+		},
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = qcompile.AddRole("user", "users", qcode.TRConfig{
+		Query: qcode.QueryConfig{
+			Columns: []string{"id", "full_name", "avatar", "email", "products"},
+		},
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = qcompile.AddRole("bad_dude", "users", qcode.TRConfig{
+		Query: qcode.QueryConfig{
+			Filters:          []string{"false"},
+			DisableFunctions: true,
+		},
+		Insert: qcode.InsertConfig{
+			Filters: []string{"false"},
+		},
+		Update: qcode.UpdateConfig{
+			Filters: []string{"false"},
+		},
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = qcompile.AddRole("user", "mes", qcode.TRConfig{
+		Query: qcode.QueryConfig{
+			Columns: []string{"id", "full_name", "avatar"},
+			Filters: []string{
+				"{ id: { eq: $user_id } }",
+			},
+		},
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = qcompile.AddRole("user", "customers", qcode.TRConfig{
+		Query: qcode.QueryConfig{
+			Columns: []string{"id", "email", "full_name", "products"},
+		},
+	})
+
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	schema := getTestSchema()
+
+	vars := NewVariables(map[string]string{
+		"admin_account_id": "5",
+	})
+
+	pcompile = NewCompiler(Config{
+		Schema: schema,
+		Vars:   vars,
+	})
+
+	expected = make(map[string][]string)
+
+	b, err := ioutil.ReadFile("tests.sql")
+	if err != nil {
+		log.Fatal(err)
+	}
+	text := string(b)
+	lines := strings.Split(text, "\n")
+
+	var h string
+
+	for _, v := range lines {
+		switch {
+		case strings.HasPrefix(v, headerMarker):
+			h = strings.TrimSpace(v[len(headerMarker):])
+
+		case strings.HasPrefix(v, commentMarker):
+			break
+
+		default:
+			v := strings.TrimSpace(v)
+			if len(v) != 0 {
+				expected[h] = append(expected[h], v)
+			}
+		}
+	}
+	os.Exit(m.Run())
+}
+
+func compileGQLToPSQL(t *testing.T, gql string, vars Variables, role string) {
+	generateTestFile := false
+
+	if generateTestFile {
+		var sqlStmts []string
+
+		for i := 0; i < 100; i++ {
+			qc, err := qcompile.Compile([]byte(gql), role)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			_, sqlB, err := pcompile.CompileEx(qc, vars)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			sql := string(sqlB)
+
+			match := false
+			for _, s := range sqlStmts {
+				if sql == s {
+					match = true
+					break
+				}
+			}
+
+			if !match {
+				s := string(sql)
+				sqlStmts = append(sqlStmts, s)
+				fmt.Println(s)
+			}
+		}
+
+		return
+	}
+
+	for i := 0; i < 200; i++ {
+		qc, err := qcompile.Compile([]byte(gql), role)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		_, sqlStmt, err := pcompile.CompileEx(qc, vars)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		failed := true
+
+		for _, sql := range expected[t.Name()] {
+			if string(sqlStmt) == sql {
+				failed = false
+			}
+		}
+
+		if failed {
+			fmt.Println(string(sqlStmt))
+			t.Fatal(errNotExpected)
+		}
+	}
+}

core/internal/psql/query.go

@@ -0,0 +1,1297 @@
+//nolint:errcheck
+package psql
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/dosco/super-graph/core/internal/qcode"
+	"github.com/dosco/super-graph/core/internal/util"
+)
+
+const (
+	closeBlock = 500
+)
+
+var (
+	ErrAllTablesSkipped = errors.New("all tables skipped. cannot render query")
+)
+
+type Variables map[string]json.RawMessage
+
+type Config struct {
+	Schema *DBSchema
+	Vars   map[string]string
+}
+
+type Compiler struct {
+	schema *DBSchema
+	vars   map[string]string
+}
+
+func NewCompiler(conf Config) *Compiler {
+	return &Compiler{
+		schema: conf.Schema,
+		vars:   conf.Vars,
+	}
+}
+
+func (c *Compiler) AddRelationship(child, parent string, rel *DBRel) error {
+	return c.schema.SetRel(child, parent, rel)
+}
+
+func (c *Compiler) IDColumn(table string) (*DBColumn, error) {
+	ti, err := c.schema.GetTable(table)
+	if err != nil {
+		return nil, err
+	}
+
+	if ti.PrimaryCol == nil {
+		return nil, fmt.Errorf("no primary key column found")
+	}
+
+	return ti.PrimaryCol, nil
+}
+
+type compilerContext struct {
+	w io.Writer
+	s []qcode.Select
+	*Compiler
+}
+
+func (co *Compiler) CompileEx(qc *qcode.QCode, vars Variables) (uint32, []byte, error) {
+	w := &bytes.Buffer{}
+	skipped, err := co.Compile(qc, w, vars)
+	return skipped, w.Bytes(), err
+}
+
+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, vars)
+	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)
+}
+
+func (co *Compiler) compileQuery(qc *qcode.QCode, w io.Writer, vars Variables) (uint32, error) {
+	if len(qc.Selects) == 0 {
+		return 0, errors.New("empty query")
+	}
+
+	c := &compilerContext{w, qc.Selects, co}
+
+	st := NewIntStack()
+	i := 0
+
+	io.WriteString(c.w, `SELECT jsonb_build_object(`)
+	for _, id := range qc.Roots {
+		root := &qc.Selects[id]
+		if root.SkipRender || len(root.Cols) == 0 {
+			continue
+		}
+
+		st.Push(root.ID + closeBlock)
+		st.Push(root.ID)
+
+		if i != 0 {
+			io.WriteString(c.w, `, `)
+		}
+
+		c.renderRootSelect(root)
+		i++
+	}
+
+	io.WriteString(c.w, `) as "__root" FROM `)
+
+	if i == 0 {
+		return 0, ErrAllTablesSkipped
+	}
+
+	var ignored uint32
+
+	for {
+		if st.Len() == 0 {
+			break
+		}
+
+		id := st.Pop()
+
+		if id < closeBlock {
+			sel := &c.s[id]
+
+			if len(sel.Cols) == 0 {
+				continue
+			}
+
+			ti, err := c.schema.GetTable(sel.Name)
+			if err != nil {
+				return 0, err
+			}
+
+			if sel.ParentID == -1 {
+				io.WriteString(c.w, `(`)
+			} else {
+				c.renderLateralJoin(sel)
+			}
+
+			if !ti.Singular {
+				c.renderPluralSelect(sel, ti)
+			}
+
+			skipped, err := c.renderSelect(sel, ti, vars)
+			if err != nil {
+				return 0, err
+			}
+			ignored |= skipped
+
+			for _, cid := range sel.Children {
+				if hasBit(skipped, uint32(cid)) {
+					continue
+				}
+				child := &c.s[cid]
+				if child.SkipRender {
+					continue
+				}
+
+				st.Push(child.ID + closeBlock)
+				st.Push(child.ID)
+			}
+
+		} else {
+			sel := &c.s[(id - closeBlock)]
+
+			ti, err := c.schema.GetTable(sel.Name)
+			if err != nil {
+				return 0, err
+			}
+
+			io.WriteString(c.w, `)`)
+			aliasWithID(c.w, "__sr", sel.ID)
+
+			io.WriteString(c.w, `)`)
+			aliasWithID(c.w, "__sj", sel.ID)
+
+			if !ti.Singular {
+				io.WriteString(c.w, `)`)
+				aliasWithID(c.w, "__sj", sel.ID)
+			}
+
+			if sel.ParentID == -1 {
+				if st.Len() != 0 {
+					io.WriteString(c.w, `, `)
+				}
+			} else {
+				c.renderLateralJoinClose(sel)
+			}
+
+			if len(sel.Args) != 0 {
+				i := 0
+				for _, v := range sel.Args {
+					qcode.FreeNode(v, 500)
+					i++
+				}
+			}
+		}
+	}
+
+	return ignored, nil
+}
+
+func (c *compilerContext) renderPluralSelect(sel *qcode.Select, ti *DBTableInfo) error {
+	io.WriteString(c.w, `SELECT coalesce(jsonb_agg("__sj_`)
+	int2string(c.w, sel.ID)
+	io.WriteString(c.w, `"."json"), '[]') as "json"`)
+
+	if sel.Paging.Type != qcode.PtOffset {
+		n := 0
+
+		// check if primary key already included in order by
+		// query argument
+		for _, ob := range sel.OrderBy {
+			if ob.Col == ti.PrimaryCol.Key {
+				n = 1
+				break
+			}
+		}
+
+		if n == 1 {
+			n = len(sel.OrderBy)
+		} else {
+			n = len(sel.OrderBy) + 1
+		}
+
+		io.WriteString(c.w, `, CONCAT_WS(','`)
+		for i := 0; i < n; i++ {
+			io.WriteString(c.w, `, max("__cur_`)
+			int2string(c.w, int32(i))
+			io.WriteString(c.w, `")`)
+		}
+		io.WriteString(c.w, `) as "cursor"`)
+	}
+
+	io.WriteString(c.w, ` FROM (`)
+	return nil
+}
+
+func (c *compilerContext) renderRootSelect(sel *qcode.Select) error {
+	io.WriteString(c.w, `'`)
+	io.WriteString(c.w, sel.FieldName)
+	io.WriteString(c.w, `', `)
+
+	io.WriteString(c.w, `"__sj_`)
+	int2string(c.w, sel.ID)
+	io.WriteString(c.w, `"."json"`)
+
+	if sel.Paging.Type != qcode.PtOffset {
+		io.WriteString(c.w, `, '`)
+		io.WriteString(c.w, sel.FieldName)
+		io.WriteString(c.w, `_cursor', `)
+
+		io.WriteString(c.w, `"__sj_`)
+		int2string(c.w, sel.ID)
+		io.WriteString(c.w, `"."cursor"`)
+	}
+
+	return nil
+}
+
+func (c *compilerContext) initSelect(sel *qcode.Select, ti *DBTableInfo, vars Variables) (uint32, []*qcode.Column, error) {
+	var skipped uint32
+
+	cols := make([]*qcode.Column, 0, len(sel.Cols))
+	colmap := make(map[string]struct{}, len(sel.Cols))
+
+	for i := range sel.Cols {
+		colmap[sel.Cols[i].Name] = struct{}{}
+	}
+
+	for i := range sel.OrderBy {
+		colmap[sel.OrderBy[i].Col] = struct{}{}
+	}
+
+	if sel.Paging.Type != qcode.PtOffset {
+		colmap[ti.PrimaryCol.Key] = struct{}{}
+		addPrimaryKey := true
+
+		for _, ob := range sel.OrderBy {
+			if ob.Col == ti.PrimaryCol.Key {
+				addPrimaryKey = false
+				break
+			}
+		}
+
+		if addPrimaryKey {
+			ob := &qcode.OrderBy{Col: ti.PrimaryCol.Name, Order: qcode.OrderAsc}
+
+			if sel.Paging.Type == qcode.PtBackward {
+				ob.Order = qcode.OrderDesc
+			}
+			sel.OrderBy = append(sel.OrderBy, ob)
+		}
+	}
+
+	if sel.Paging.Cursor {
+		c.addSeekPredicate(sel)
+	}
+
+	for _, id := range sel.Children {
+		child := &c.s[id]
+
+		rel, err := c.schema.GetRel(child.Name, ti.Name)
+		if err != nil {
+			return 0, nil, err
+			//skipped |= (1 << uint(id))
+			//continue
+		}
+
+		switch rel.Type {
+		case RelOneToOne, RelOneToMany:
+			if _, ok := colmap[rel.Right.Col]; !ok {
+				cols = append(cols, &qcode.Column{Table: ti.Name, Name: rel.Right.Col, FieldName: rel.Right.Col})
+				colmap[rel.Right.Col] = struct{}{}
+			}
+
+		case RelOneToManyThrough:
+			if _, ok := colmap[rel.Left.Col]; !ok {
+				cols = append(cols, &qcode.Column{Table: ti.Name, Name: rel.Left.Col, FieldName: rel.Left.Col})
+				colmap[rel.Left.Col] = struct{}{}
+			}
+
+		case RelEmbedded:
+			if _, ok := colmap[rel.Left.Col]; !ok {
+				cols = append(cols, &qcode.Column{Table: ti.Name, Name: rel.Left.Col, FieldName: rel.Left.Col})
+				colmap[rel.Left.Col] = struct{}{}
+			}
+
+		case RelRemote:
+			if _, ok := colmap[rel.Left.Col]; !ok {
+				cols = append(cols, &qcode.Column{Table: ti.Name, Name: rel.Left.Col, FieldName: rel.Right.Col})
+				colmap[rel.Left.Col] = struct{}{}
+				skipped |= (1 << uint(id))
+			}
+
+		default:
+			return 0, nil, fmt.Errorf("unknown relationship %s", rel)
+			//skipped |= (1 << uint(id))
+		}
+	}
+
+	return skipped, cols, nil
+}
+
+// This
+// (A, B, C) >= (X, Y, Z)
+//
+// Becomes
+// (A > X)
+//   OR ((A = X) AND (B > Y))
+//   OR ((A = X) AND (B = Y) AND (C > Z))
+//   OR ((A = X) AND (B = Y) AND (C = Z))
+
+func (c *compilerContext) addSeekPredicate(sel *qcode.Select) error {
+	var or, and *qcode.Exp
+
+	obLen := len(sel.OrderBy)
+
+	if obLen > 1 {
+		or = qcode.NewFilter()
+		or.Op = qcode.OpOr
+	}
+
+	for i := 0; i < obLen; i++ {
+		if i > 0 {
+			and = qcode.NewFilter()
+			and.Op = qcode.OpAnd
+		}
+
+		for n, ob := range sel.OrderBy {
+			f := qcode.NewFilter()
+			f.Col = ob.Col
+			f.Type = qcode.ValRef
+			f.Table = "__cur"
+			f.Val = ob.Col
+
+			if obLen == 1 {
+				qcode.AddFilter(sel, f)
+				return nil
+			}
+
+			switch {
+			case i > 0 && n != i:
+				f.Op = qcode.OpEquals
+			case ob.Order == qcode.OrderDesc:
+				f.Op = qcode.OpLesserThan
+			default:
+				f.Op = qcode.OpGreaterThan
+			}
+
+			if and != nil {
+				and.Children = append(and.Children, f)
+			} else {
+				or.Children = append(or.Children, f)
+			}
+
+			if n == i {
+				break
+			}
+		}
+
+		if and != nil {
+			or.Children = append(or.Children, and)
+		}
+	}
+
+	qcode.AddFilter(sel, or)
+	return nil
+}
+
+func (c *compilerContext) renderSelect(sel *qcode.Select, ti *DBTableInfo, vars Variables) (uint32, error) {
+	var rel *DBRel
+	var err error
+
+	if sel.ParentID != -1 {
+		parent := c.s[sel.ParentID]
+
+		rel, err = c.schema.GetRel(ti.Name, parent.Name)
+		if err != nil {
+			return 0, err
+		}
+	}
+
+	skipped, childCols, err := c.initSelect(sel, ti, vars)
+	if err != nil {
+		return 0, err
+	}
+
+	// SELECT
+	// io.WriteString(c.w, `SELECT jsonb_build_object(`)
+	// if err := c.renderColumns(sel, ti, skipped); err != nil {
+	// 	return 0, err
+	// }
+
+	io.WriteString(c.w, `SELECT to_jsonb("__sr_`)
+	int2string(c.w, sel.ID)
+	io.WriteString(c.w, `".*) `)
+
+	if sel.Paging.Type != qcode.PtOffset {
+		for i := range sel.OrderBy {
+			io.WriteString(c.w, `- '__cur_`)
+			int2string(c.w, int32(i))
+			io.WriteString(c.w, `' `)
+		}
+	}
+
+	io.WriteString(c.w, `AS "json"`)
+
+	if sel.Paging.Type != qcode.PtOffset {
+		for i := range sel.OrderBy {
+			io.WriteString(c.w, `, "__cur_`)
+			int2string(c.w, int32(i))
+			io.WriteString(c.w, `"`)
+		}
+	}
+
+	io.WriteString(c.w, `FROM (SELECT `)
+
+	if err := c.renderColumns(sel, ti, skipped); err != nil {
+		return 0, err
+	}
+
+	if sel.Paging.Type != qcode.PtOffset {
+		for i, ob := range sel.OrderBy {
+			io.WriteString(c.w, `, LAST_VALUE(`)
+			colWithTableID(c.w, ti.Name, sel.ID, ob.Col)
+			io.WriteString(c.w, `) OVER() AS "__cur_`)
+			int2string(c.w, int32(i))
+			io.WriteString(c.w, `"`)
+		}
+	}
+
+	io.WriteString(c.w, ` FROM (`)
+
+	// FROM (SELECT .... )
+	err = c.renderBaseSelect(sel, ti, rel, childCols, skipped)
+	if err != nil {
+		return skipped, err
+	}
+
+	//fmt.Fprintf(w, `) AS "%s_%d"`, c.sel.Name, c.sel.ID)
+	io.WriteString(c.w, `)`)
+	aliasWithID(c.w, ti.Name, sel.ID)
+
+	// END-FROM
+
+	return skipped, nil
+}
+
+func (c *compilerContext) renderLateralJoin(sel *qcode.Select) error {
+	io.WriteString(c.w, ` LEFT OUTER JOIN LATERAL (`)
+	return nil
+}
+
+func (c *compilerContext) renderLateralJoinClose(sel *qcode.Select) error {
+	// io.WriteString(c.w, `) `)
+	// aliasWithID(c.w, "__sj", sel.ID)
+	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.Name, parent.ID)
+}
+
+func (c *compilerContext) renderJoinByName(table, parent string, id int32) error {
+	rel, err := c.schema.GetRel(table, parent)
+	if err != nil {
+		return err
+	}
+
+	// This join is only required for one-to-many relations since
+	// these make use of join tables that need to be pulled in.
+	if rel.Type != RelOneToManyThrough {
+		return err
+	}
+
+	pt, err := c.schema.GetTable(parent)
+	if err != nil {
+		return err
+	}
+
+	//fmt.Fprintf(w, ` LEFT OUTER JOIN "%s" ON (("%s"."%s") = ("%s_%d"."%s"))`,
+	//rel.Through, rel.Through, rel.ColT, c.parent.Name, c.parent.ID, rel.Left.Col)
+	io.WriteString(c.w, ` LEFT OUTER JOIN "`)
+	io.WriteString(c.w, rel.Through)
+	io.WriteString(c.w, `" ON ((`)
+	colWithTable(c.w, rel.Through, rel.ColT)
+	io.WriteString(c.w, `) = (`)
+	colWithTableID(c.w, pt.Name, id, rel.Left.Col)
+	io.WriteString(c.w, `))`)
+
+	return nil
+}
+
+func (c *compilerContext) renderColumns(sel *qcode.Select, ti *DBTableInfo, skipped uint32) error {
+	i := 0
+	var cn string
+
+	for _, col := range sel.Cols {
+		if n := funcPrefixLen(col.Name); n != 0 {
+			if !sel.Functions {
+				continue
+			}
+			cn = col.Name[n:]
+		} else {
+			cn = col.Name
+
+			if strings.HasSuffix(cn, "_cursor") {
+				continue
+			}
+		}
+
+		if len(sel.Allowed) != 0 {
+			if _, ok := sel.Allowed[cn]; !ok {
+				continue
+			}
+		}
+
+		if i != 0 {
+			io.WriteString(c.w, ", ")
+		}
+
+		colWithTableID(c.w, ti.Name, sel.ID, col.Name)
+		alias(c.w, col.FieldName)
+
+		i++
+	}
+
+	i += c.renderRemoteRelColumns(sel, ti, i)
+
+	return c.renderJoinColumns(sel, ti, skipped, i)
+}
+
+func (c *compilerContext) renderRemoteRelColumns(sel *qcode.Select, ti *DBTableInfo, colsRendered int) int {
+	i := colsRendered
+
+	for _, id := range sel.Children {
+		child := &c.s[id]
+
+		rel, err := c.schema.GetRel(child.Name, sel.Name)
+		if err != nil || rel.Type != RelRemote {
+			continue
+		}
+		if i != 0 || len(sel.Cols) != 0 {
+			io.WriteString(c.w, ", ")
+		}
+
+		colWithTableID(c.w, ti.Name, sel.ID, rel.Left.Col)
+		alias(c.w, rel.Right.Col)
+		i++
+	}
+
+	return i
+}
+
+func (c *compilerContext) renderJoinColumns(sel *qcode.Select, ti *DBTableInfo, skipped uint32, colsRendered int) error {
+	// columns previously rendered
+	i := colsRendered
+
+	for _, id := range sel.Children {
+		if hasBit(skipped, uint32(id)) {
+			continue
+		}
+		childSel := &c.s[id]
+
+		if i != 0 {
+			io.WriteString(c.w, ", ")
+		}
+
+		if childSel.SkipRender {
+			io.WriteString(c.w, `NULL`)
+			alias(c.w, childSel.FieldName)
+			continue
+		}
+
+		io.WriteString(c.w, `"__sj_`)
+		int2string(c.w, childSel.ID)
+		io.WriteString(c.w, `"."json"`)
+		alias(c.w, childSel.FieldName)
+
+		if childSel.Paging.Type != qcode.PtOffset {
+			io.WriteString(c.w, `, "__sj_`)
+			int2string(c.w, childSel.ID)
+			io.WriteString(c.w, `"."cursor" AS "`)
+			io.WriteString(c.w, childSel.FieldName)
+			io.WriteString(c.w, `_cursor"`)
+		}
+
+		i++
+	}
+
+	return nil
+}
+
+func (c *compilerContext) renderBaseSelect(sel *qcode.Select, ti *DBTableInfo, rel *DBRel,
+	childCols []*qcode.Column, skipped uint32) error {
+	isRoot := (rel == nil)
+	isFil := (sel.Where != nil && sel.Where.Op != qcode.OpNop)
+	hasOrder := len(sel.OrderBy) != 0
+
+	if sel.Paging.Cursor {
+		c.renderCursorCTE(sel)
+	}
+
+	io.WriteString(c.w, `SELECT `)
+
+	if len(sel.DistinctOn) != 0 {
+		c.renderDistinctOn(sel, ti)
+	}
+
+	realColsRendered, isAgg, err := c.renderBaseColumns(sel, ti, childCols, skipped)
+	if err != nil {
+		return err
+	}
+
+	io.WriteString(c.w, ` FROM `)
+
+	c.renderFrom(sel, ti, rel)
+
+	if isRoot && isFil {
+		io.WriteString(c.w, ` WHERE (`)
+		if err := c.renderWhere(sel, ti); err != nil {
+			return err
+		}
+		io.WriteString(c.w, `)`)
+	}
+
+	if !isRoot {
+		if err := c.renderJoin(sel, ti); err != nil {
+			return err
+		}
+
+		io.WriteString(c.w, ` WHERE (`)
+		if err := c.renderRelationship(sel, ti); err != nil {
+			return err
+		}
+		if isFil {
+			io.WriteString(c.w, ` AND `)
+			if err := c.renderWhere(sel, ti); err != nil {
+				return err
+			}
+		}
+		io.WriteString(c.w, `)`)
+	}
+
+	if isAgg && len(realColsRendered) != 0 {
+		io.WriteString(c.w, ` GROUP BY `)
+
+		for i, id := range realColsRendered {
+			c.renderComma(i)
+			//fmt.Fprintf(w, `"%s"."%s"`, c.sel.Name, c.sel.Cols[id].Name)
+			colWithTable(c.w, ti.Name, sel.Cols[id].Name)
+		}
+	}
+
+	if hasOrder {
+		if err := c.renderOrderBy(sel, ti); err != nil {
+			return err
+		}
+	}
+
+	switch {
+	case ti.Singular:
+		io.WriteString(c.w, ` LIMIT ('1') :: integer`)
+
+	case len(sel.Paging.Limit) != 0:
+		//fmt.Fprintf(w, ` LIMIT ('%s') :: integer`, c.sel.Paging.Limit)
+		io.WriteString(c.w, ` LIMIT ('`)
+		io.WriteString(c.w, sel.Paging.Limit)
+		io.WriteString(c.w, `') :: integer`)
+
+	case sel.Paging.NoLimit:
+		break
+
+	default:
+		io.WriteString(c.w, ` LIMIT ('20') :: integer`)
+	}
+
+	if len(sel.Paging.Offset) != 0 {
+		//fmt.Fprintf(w, ` OFFSET ('%s') :: integer`, c.sel.Paging.Offset)
+		io.WriteString(c.w, ` OFFSET ('`)
+		io.WriteString(c.w, sel.Paging.Offset)
+		io.WriteString(c.w, `') :: integer`)
+	}
+
+	return nil
+}
+
+func (c *compilerContext) renderFrom(sel *qcode.Select, ti *DBTableInfo, rel *DBRel) error {
+	if rel != nil && rel.Type == RelEmbedded {
+		// jsonb_to_recordset('[{"a":1,"b":[1,2,3],"c":"bar"}, {"a":2,"b":[1,2,3],"c":"bar"}]') as x(a int, b text, d text);
+
+		io.WriteString(c.w, `"`)
+		io.WriteString(c.w, rel.Left.Table)
+		io.WriteString(c.w, `", `)
+
+		io.WriteString(c.w, ti.Type)
+		io.WriteString(c.w, `_to_recordset(`)
+		colWithTable(c.w, rel.Left.Table, rel.Right.Col)
+		io.WriteString(c.w, `) AS `)
+
+		io.WriteString(c.w, `"`)
+		io.WriteString(c.w, ti.Name)
+		io.WriteString(c.w, `"`)
+
+		io.WriteString(c.w, `(`)
+		for i, col := range ti.Columns {
+			if i != 0 {
+				io.WriteString(c.w, `, `)
+			}
+			io.WriteString(c.w, col.Name)
+			io.WriteString(c.w, ` `)
+			io.WriteString(c.w, col.Type)
+		}
+		io.WriteString(c.w, `)`)
+
+	} else {
+		//fmt.Fprintf(w, ` FROM "%s"`, c.sel.Name)
+		io.WriteString(c.w, `"`)
+		io.WriteString(c.w, ti.Name)
+		io.WriteString(c.w, `"`)
+	}
+
+	if sel.Paging.Cursor {
+		io.WriteString(c.w, `, "__cur"`)
+	}
+
+	return nil
+}
+
+func (c *compilerContext) renderCursorCTE(sel *qcode.Select) error {
+	io.WriteString(c.w, `WITH "__cur" AS (SELECT `)
+	for i, ob := range sel.OrderBy {
+		if i != 0 {
+			io.WriteString(c.w, `, `)
+		}
+		io.WriteString(c.w, `a[`)
+		int2string(c.w, int32(i+1))
+		io.WriteString(c.w, `] as `)
+		quoted(c.w, ob.Col)
+	}
+	io.WriteString(c.w, ` FROM string_to_array('{{cursor}}', ',') as a) `)
+	return nil
+}
+
+func (c *compilerContext) renderRelationship(sel *qcode.Select, ti *DBTableInfo) error {
+	parent := c.s[sel.ParentID]
+
+	pti, err := c.schema.GetTable(parent.Name)
+	if err != nil {
+		return err
+	}
+
+	return c.renderRelationshipByName(ti.Name, pti.Name, parent.ID)
+}
+
+func (c *compilerContext) renderRelationshipByName(table, parent string, id int32) error {
+	rel, err := c.schema.GetRel(table, parent)
+	if err != nil {
+		return err
+	}
+
+	io.WriteString(c.w, `((`)
+
+	switch rel.Type {
+	case RelOneToOne, RelOneToMany:
+
+		//fmt.Fprintf(w, `(("%s"."%s") = ("%s_%d"."%s"))`,
+		//c.sel.Name, rel.Left.Col, c.parent.Name, c.parent.ID, rel.Right.Col)
+
+		switch {
+		case !rel.Left.Array && rel.Right.Array:
+			colWithTable(c.w, table, rel.Left.Col)
+			io.WriteString(c.w, `) = any (`)
+			colWithTableID(c.w, parent, id, rel.Right.Col)
+
+		case rel.Left.Array && !rel.Right.Array:
+			colWithTableID(c.w, parent, id, rel.Right.Col)
+			io.WriteString(c.w, `) = any (`)
+			colWithTable(c.w, table, rel.Left.Col)
+
+		default:
+			colWithTable(c.w, table, rel.Left.Col)
+			io.WriteString(c.w, `) = (`)
+			colWithTableID(c.w, parent, id, rel.Right.Col)
+		}
+
+	case RelOneToManyThrough:
+		// This requires the through table to be joined onto this select
+		//fmt.Fprintf(w, `(("%s"."%s") = ("%s"."%s"))`,
+		//c.sel.Name, rel.Left.Col, rel.Through, rel.Right.Col)
+
+		switch {
+		case !rel.Left.Array && rel.Right.Array:
+			colWithTable(c.w, table, rel.Left.Col)
+			io.WriteString(c.w, `) = any (`)
+			colWithTable(c.w, rel.Through, rel.Right.Col)
+
+		case rel.Left.Array && !rel.Right.Array:
+			colWithTable(c.w, rel.Through, rel.Right.Col)
+			io.WriteString(c.w, `) = any (`)
+			colWithTable(c.w, table, rel.Left.Col)
+
+		default:
+			colWithTable(c.w, table, rel.Left.Col)
+			io.WriteString(c.w, `) = (`)
+			colWithTable(c.w, rel.Through, rel.Right.Col)
+		}
+
+	case RelEmbedded:
+		colWithTable(c.w, rel.Left.Table, rel.Left.Col)
+		io.WriteString(c.w, `) = (`)
+		colWithTableID(c.w, parent, id, rel.Left.Col)
+	}
+
+	io.WriteString(c.w, `))`)
+
+	return nil
+}
+
+func (c *compilerContext) renderWhere(sel *qcode.Select, ti *DBTableInfo) error {
+	if sel.Where != nil {
+		return c.renderExp(sel.Where, ti, false)
+	}
+	return nil
+}
+
+func (c *compilerContext) renderExp(ex *qcode.Exp, ti *DBTableInfo, skipNested bool) error {
+	st := util.NewStack()
+	st.Push(ex)
+
+	for {
+		if st.Len() == 0 {
+			break
+		}
+
+		intf := st.Pop()
+
+		switch val := intf.(type) {
+		case int32:
+			switch val {
+			case '(':
+				io.WriteString(c.w, `(`)
+			case ')':
+				io.WriteString(c.w, `)`)
+			}
+
+		case qcode.ExpOp:
+			switch val {
+			case qcode.OpAnd:
+				io.WriteString(c.w, ` AND `)
+			case qcode.OpOr:
+				io.WriteString(c.w, ` OR `)
+			case qcode.OpNot:
+				io.WriteString(c.w, `NOT `)
+			case qcode.OpFalse:
+				io.WriteString(c.w, `false`)
+			default:
+				return fmt.Errorf("11: unexpected value %v (%t)", intf, intf)
+			}
+
+		case *qcode.Exp:
+			switch val.Op {
+			case qcode.OpFalse:
+				st.Push(val.Op)
+
+			case qcode.OpAnd, qcode.OpOr:
+				st.Push(')')
+				for i := len(val.Children) - 1; i >= 0; i-- {
+					st.Push(val.Children[i])
+					if i > 0 {
+						st.Push(val.Op)
+					}
+				}
+				st.Push('(')
+
+			case qcode.OpNot:
+				//fmt.Printf("1> %s %d %s %s\n", val.Op, len(val.Children), val.Children[0].Op, val.Children[1].Op)
+
+				st.Push(val.Children[0])
+				st.Push(qcode.OpNot)
+
+			default:
+				if !skipNested && len(val.NestedCols) != 0 {
+					io.WriteString(c.w, `EXISTS `)
+
+					if err := c.renderNestedWhere(val, ti); err != nil {
+						return err
+					}
+
+				} else {
+					//fmt.Fprintf(w, `(("%s"."%s") `, c.sel.Name, val.Col)
+					if err := c.renderOp(val, ti); err != nil {
+						return err
+					}
+				}
+			}
+			//qcode.FreeExp(val)
+
+		default:
+			return fmt.Errorf("12: unexpected value %v (%t)", intf, intf)
+		}
+	}
+
+	return nil
+}
+
+func (c *compilerContext) renderNestedWhere(ex *qcode.Exp, ti *DBTableInfo) error {
+	for i := 0; i < len(ex.NestedCols)-1; i++ {
+		cti, err := c.schema.GetTable(ex.NestedCols[i])
+		if err != nil {
+			return err
+		}
+
+		if i != 0 {
+			io.WriteString(c.w, ` AND `)
+		}
+
+		io.WriteString(c.w, `(SELECT 1 FROM `)
+		io.WriteString(c.w, cti.Name)
+
+		if err := c.renderJoinByName(cti.Name, ti.Name, -1); err != nil {
+			return err
+		}
+
+		io.WriteString(c.w, ` WHERE `)
+
+		if err := c.renderRelationshipByName(cti.Name, ti.Name, -1); err != nil {
+			return err
+		}
+
+		io.WriteString(c.w, ` AND (`)
+
+		if err := c.renderExp(ex, cti, true); err != nil {
+			return err
+		}
+
+		io.WriteString(c.w, `)`)
+
+	}
+
+	for i := 0; i < len(ex.NestedCols)-1; i++ {
+		io.WriteString(c.w, `)`)
+	}
+
+	return nil
+}
+
+func (c *compilerContext) renderOp(ex *qcode.Exp, ti *DBTableInfo) error {
+	var col *DBColumn
+	var ok bool
+
+	if ex.Op == qcode.OpNop {
+		return nil
+	}
+
+	if len(ex.Col) != 0 {
+		if col, ok = ti.ColMap[ex.Col]; !ok {
+			return fmt.Errorf("no column '%s' found ", ex.Col)
+		}
+
+		io.WriteString(c.w, `((`)
+		colWithTable(c.w, ti.Name, ex.Col)
+		io.WriteString(c.w, `) `)
+	}
+
+	switch ex.Op {
+	case qcode.OpEquals:
+		io.WriteString(c.w, `=`)
+	case qcode.OpNotEquals:
+		io.WriteString(c.w, `!=`)
+	case qcode.OpNotDistinct:
+		io.WriteString(c.w, `IS NOT DISTINCT FROM`)
+	case qcode.OpDistinct:
+		io.WriteString(c.w, `IS DISTINCT FROM`)
+	case qcode.OpGreaterOrEquals:
+		io.WriteString(c.w, `>=`)
+	case qcode.OpLesserOrEquals:
+		io.WriteString(c.w, `<=`)
+	case qcode.OpGreaterThan:
+		io.WriteString(c.w, `>`)
+	case qcode.OpLesserThan:
+		io.WriteString(c.w, `<`)
+	case qcode.OpIn:
+		io.WriteString(c.w, `IN`)
+	case qcode.OpNotIn:
+		io.WriteString(c.w, `NOT IN`)
+	case qcode.OpLike:
+		io.WriteString(c.w, `LIKE`)
+	case qcode.OpNotLike:
+		io.WriteString(c.w, `NOT LIKE`)
+	case qcode.OpILike:
+		io.WriteString(c.w, `ILIKE`)
+	case qcode.OpNotILike:
+		io.WriteString(c.w, `NOT ILIKE`)
+	case qcode.OpSimilar:
+		io.WriteString(c.w, `SIMILAR TO`)
+	case qcode.OpNotSimilar:
+		io.WriteString(c.w, `NOT SIMILAR TO`)
+	case qcode.OpContains:
+		io.WriteString(c.w, `@>`)
+	case qcode.OpContainedIn:
+		io.WriteString(c.w, `<@`)
+	case qcode.OpHasKey:
+		io.WriteString(c.w, `?`)
+	case qcode.OpHasKeyAny:
+		io.WriteString(c.w, `?|`)
+	case qcode.OpHasKeyAll:
+		io.WriteString(c.w, `?&`)
+	case qcode.OpIsNull:
+		if strings.EqualFold(ex.Val, "true") {
+			io.WriteString(c.w, `IS NULL)`)
+		} else {
+			io.WriteString(c.w, `IS NOT NULL)`)
+		}
+		return nil
+
+	case qcode.OpEqID:
+		if ti.PrimaryCol == nil {
+			return fmt.Errorf("no primary key column defined for %s", ti.Name)
+		}
+		col = ti.PrimaryCol
+		//fmt.Fprintf(w, `(("%s") =`, c.ti.PrimaryCol)
+		io.WriteString(c.w, `((`)
+		colWithTable(c.w, ti.Name, ti.PrimaryCol.Name)
+		//io.WriteString(c.w, ti.PrimaryCol)
+		io.WriteString(c.w, `) =`)
+
+	case qcode.OpTsQuery:
+		if ti.PrimaryCol == nil {
+			return fmt.Errorf("no tsv column defined for %s", ti.Name)
+		}
+		//fmt.Fprintf(w, `(("%s") @@ websearch_to_tsquery('%s'))`, c.ti.TSVCol, val.Val)
+		io.WriteString(c.w, `((`)
+		colWithTable(c.w, ti.Name, ti.TSVCol.Name)
+		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
+
+	default:
+		return fmt.Errorf("[Where] unexpected op code %d", ex.Op)
+	}
+
+	switch {
+	case ex.Type == qcode.ValList:
+		c.renderList(ex)
+	case col == nil:
+		return errors.New("no column found for expression value")
+	default:
+		c.renderVal(ex, c.vars, col)
+	}
+
+	io.WriteString(c.w, `)`)
+	return nil
+}
+
+func (c *compilerContext) renderOrderBy(sel *qcode.Select, ti *DBTableInfo) error {
+	io.WriteString(c.w, ` ORDER BY `)
+	for i := range sel.OrderBy {
+		if i != 0 {
+			io.WriteString(c.w, `, `)
+		}
+		ob := sel.OrderBy[i]
+		colWithTable(c.w, ti.Name, ob.Col)
+
+		switch ob.Order {
+		case qcode.OrderAsc:
+			io.WriteString(c.w, ` ASC`)
+		case qcode.OrderDesc:
+			io.WriteString(c.w, ` DESC`)
+		case qcode.OrderAscNullsFirst:
+			io.WriteString(c.w, ` ASC NULLS FIRST`)
+		case qcode.OrderDescNullsFirst:
+			io.WriteString(c.w, ` DESC NULLLS FIRST`)
+		case qcode.OrderAscNullsLast:
+			io.WriteString(c.w, ` ASC NULLS LAST`)
+		case qcode.OrderDescNullsLast:
+			io.WriteString(c.w, ` DESC NULLS LAST`)
+		default:
+			return fmt.Errorf("13: unexpected value %v", ob.Order)
+		}
+	}
+	return nil
+}
+
+func (c *compilerContext) renderDistinctOn(sel *qcode.Select, ti *DBTableInfo) {
+	io.WriteString(c.w, `DISTINCT ON (`)
+	for i := range sel.DistinctOn {
+		if i != 0 {
+			io.WriteString(c.w, `, `)
+		}
+		colWithTable(c.w, ti.Name, sel.DistinctOn[i])
+	}
+	io.WriteString(c.w, `) `)
+}
+
+func (c *compilerContext) renderList(ex *qcode.Exp) {
+	io.WriteString(c.w, ` (`)
+	for i := range ex.ListVal {
+		if i != 0 {
+			io.WriteString(c.w, `, `)
+		}
+		switch ex.ListType {
+		case qcode.ValBool, qcode.ValInt, qcode.ValFloat:
+			io.WriteString(c.w, ex.ListVal[i])
+		case qcode.ValStr:
+			io.WriteString(c.w, `'`)
+			io.WriteString(c.w, ex.ListVal[i])
+			io.WriteString(c.w, `'`)
+		}
+	}
+	io.WriteString(c.w, `)`)
+}
+
+func (c *compilerContext) renderVal(ex *qcode.Exp, vars map[string]string, col *DBColumn) {
+	io.WriteString(c.w, ` `)
+
+	switch ex.Type {
+	case qcode.ValVar:
+		val, ok := vars[ex.Val]
+		switch {
+		case ok && strings.HasPrefix(val, "sql:"):
+			io.WriteString(c.w, ` (`)
+			io.WriteString(c.w, val[4:])
+			io.WriteString(c.w, `)`)
+		case ok:
+			squoted(c.w, val)
+		default:
+			io.WriteString(c.w, ` '{{`)
+			io.WriteString(c.w, ex.Val)
+			io.WriteString(c.w, `}}'`)
+		}
+
+	case qcode.ValRef:
+		colWithTable(c.w, ex.Table, ex.Col)
+
+	default:
+		squoted(c.w, ex.Val)
+	}
+
+	io.WriteString(c.w, ` :: `)
+	io.WriteString(c.w, col.Type)
+}
+
+func funcPrefixLen(fn string) int {
+	switch {
+	case strings.HasPrefix(fn, "avg_"):
+		return 4
+	case strings.HasPrefix(fn, "count_"):
+		return 6
+	case strings.HasPrefix(fn, "max_"):
+		return 4
+	case strings.HasPrefix(fn, "min_"):
+		return 4
+	case strings.HasPrefix(fn, "sum_"):
+		return 4
+	case strings.HasPrefix(fn, "stddev_"):
+		return 7
+	case strings.HasPrefix(fn, "stddev_pop_"):
+		return 11
+	case strings.HasPrefix(fn, "stddev_samp_"):
+		return 12
+	case strings.HasPrefix(fn, "variance_"):
+		return 9
+	case strings.HasPrefix(fn, "var_pop_"):
+		return 8
+	case strings.HasPrefix(fn, "var_samp_"):
+		return 9
+	}
+	return 0
+}
+
+func hasBit(n uint32, pos uint32) bool {
+	val := n & (1 << pos)
+	return (val > 0)
+}
+
+func alias(w io.Writer, alias string) {
+	io.WriteString(w, ` AS "`)
+	io.WriteString(w, alias)
+	io.WriteString(w, `"`)
+}
+
+func aliasWithID(w io.Writer, alias string, id int32) {
+	io.WriteString(w, ` AS "`)
+	io.WriteString(w, alias)
+	io.WriteString(w, `_`)
+	int2string(w, id)
+	io.WriteString(w, `"`)
+}
+
+func colWithTable(w io.Writer, table, col string) {
+	io.WriteString(w, `"`)
+	io.WriteString(w, table)
+	io.WriteString(w, `"."`)
+	io.WriteString(w, col)
+	io.WriteString(w, `"`)
+}
+
+func colWithTableID(w io.Writer, table string, id int32, col string) {
+	io.WriteString(w, `"`)
+	io.WriteString(w, table)
+	if id >= 0 {
+		io.WriteString(w, `_`)
+		int2string(w, id)
+	}
+	io.WriteString(w, `"."`)
+	io.WriteString(w, col)
+	io.WriteString(w, `"`)
+}
+
+func quoted(w io.Writer, identifier string) {
+	io.WriteString(w, `"`)
+	io.WriteString(w, identifier)
+	io.WriteString(w, `"`)
+}
+
+func squoted(w io.Writer, identifier string) {
+	io.WriteString(w, `'`)
+	io.WriteString(w, identifier)
+	io.WriteString(w, `'`)
+}
+
+const charset = "0123456789"
+
+func int2string(w io.Writer, val int32) {
+	if val < 10 {
+		w.Write([]byte{charset[val]})
+		return
+	}
+
+	temp := int32(0)
+	val2 := val
+	for val2 > 0 {
+		temp *= 10
+		temp += val2 % 10
+		val2 = int32(float64(val2 / 10))
+	}
+
+	val3 := temp
+	for val3 > 0 {
+		d := val3 % 10
+		val3 /= 10
+		w.Write([]byte{charset[d]})
+	}
+}

core/internal/psql/query_test.go

@@ -0,0 +1,459 @@
+package psql
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+)
+
+func withComplexArgs(t *testing.T) {
+	gql := `query {
+		proDUcts(
+			# returns only 30 items
+			limit: 30,
+
+			# starts from item 10, commented out for now
+			# offset: 10,
+
+			# orders the response items by highest price
+			order_by: { price: desc },
+
+			# no duplicate prices returned
+			distinct: [ price ]
+
+			# only items with an id >= 20 and < 28 are returned
+			where: { id: { and: { greater_or_equals: 20, lt: 28 } } }) {
+			id
+			NAME
+			price
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func withWhereAndList(t *testing.T) {
+	gql := `query {
+		products(
+			where: {
+				and: [
+					{ not: { id: { is_null: true } } },
+					{ price: { gt: 10 } },
+				] } ) {
+			id
+			name
+			price
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func withWhereIsNull(t *testing.T) {
+	gql := `query {
+		products(
+			where: {
+				and: {
+					not: { id: { is_null: true } },
+					price: { gt: 10 }
+				}}) {
+			id
+			name
+			price
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func withWhereMultiOr(t *testing.T) {
+	gql := `query {
+		products(
+			where: {
+				or: {
+					not: { id: { is_null: true } },
+					price: { gt: 10 },
+					price: { lt: 20 }
+				} }
+			) {
+			id
+			name
+			price
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func fetchByID(t *testing.T) {
+	gql := `query {
+		product(id: $id) {
+			id
+			name
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func searchQuery(t *testing.T) {
+	gql := `query {
+		products(search: $query) {
+			id
+			name
+			search_rank
+			search_headline_description
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "admin")
+}
+
+func oneToMany(t *testing.T) {
+	gql := `query {
+		users {
+			email
+			products {
+				name
+				price
+			}
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func oneToManyReverse(t *testing.T) {
+	gql := `query {
+		products {
+			name
+			price
+			users {
+				email
+			}
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func oneToManyArray(t *testing.T) {
+	gql := `
+	query {
+		product {
+			name
+			price
+			tags {
+				id
+				name
+			}
+		}
+		tags {
+			name
+			product {
+				name
+			}
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "admin")
+}
+
+func manyToMany(t *testing.T) {
+	gql := `query {
+		products {
+			name
+			customers {
+				email
+				full_name
+			}
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func manyToManyReverse(t *testing.T) {
+	gql := `query {
+		customers {
+			email
+			full_name
+			products {
+				name
+			}
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func aggFunction(t *testing.T) {
+	gql := `query {
+		products {
+			name
+			count_price
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func aggFunctionBlockedByCol(t *testing.T) {
+	gql := `query {
+		products {
+			name
+			count_price
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "anon")
+}
+
+func aggFunctionDisabled(t *testing.T) {
+	gql := `query {
+		products {
+			name
+			count_price
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "anon1")
+}
+
+func aggFunctionWithFilter(t *testing.T) {
+	gql := `query {
+		products(where: { id: { gt: 10 } }) {
+			id
+			max_price
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func syntheticTables(t *testing.T) {
+	gql := `query {
+		me {
+			email
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func queryWithVariables(t *testing.T) {
+	gql := `query {
+		product(id: $PRODUCT_ID, where: { price: { eq: $PRODUCT_PRICE } }) {
+			id
+			name
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func withWhereOnRelations(t *testing.T) {
+	gql := `query {
+		users(where: { 
+				not: { 
+					products: { 
+						price: { gt: 3 }
+					} 
+				} 
+			}) {
+			id
+			email
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func multiRoot(t *testing.T) {
+	gql := `query {
+		product {
+			id
+			name
+			customer {
+				email
+			}
+			customers {
+				email
+			}
+		}
+		user {
+			id
+			email
+		}
+		customer {
+			id
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "user")
+}
+
+func withCursor(t *testing.T) {
+	gql := `query {
+		Products(
+			first: 20
+			after: $cursor
+			order_by: { price: desc }) {
+			Name
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"cursor": json.RawMessage(`"0,1"`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func jsonColumnAsTable(t *testing.T) {
+	gql := `query {
+		products {
+			id
+			name
+			tag_count {
+				count
+				tags {
+					name
+				}
+			}
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "admin")
+}
+
+func nullForAuthRequiredInAnon(t *testing.T) {
+	gql := `query {
+		products {
+			id
+			name
+			user(where: { id: { eq: $user_id } }) {
+				id
+				email
+			}
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "anon")
+}
+
+func blockedQuery(t *testing.T) {
+	gql := `query {
+		user(id: $id, where: { id: { gt: 3 } }) {
+			id
+			full_name
+			email
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "bad_dude")
+}
+
+func blockedFunctions(t *testing.T) {
+	gql := `query {
+		users {
+			count_id
+			email
+		}
+	}`
+
+	compileGQLToPSQL(t, gql, nil, "bad_dude")
+}
+
+func TestCompileQuery(t *testing.T) {
+	t.Run("withComplexArgs", withComplexArgs)
+	t.Run("withWhereAndList", withWhereAndList)
+	t.Run("withWhereIsNull", withWhereIsNull)
+	t.Run("withWhereMultiOr", withWhereMultiOr)
+	t.Run("fetchByID", fetchByID)
+	t.Run("searchQuery", searchQuery)
+	t.Run("oneToMany", oneToMany)
+	t.Run("oneToManyReverse", oneToManyReverse)
+	t.Run("oneToManyArray", oneToManyArray)
+	t.Run("manyToMany", manyToMany)
+	t.Run("manyToManyReverse", manyToManyReverse)
+	t.Run("aggFunction", aggFunction)
+	t.Run("aggFunctionBlockedByCol", aggFunctionBlockedByCol)
+	t.Run("aggFunctionDisabled", aggFunctionDisabled)
+	t.Run("aggFunctionWithFilter", aggFunctionWithFilter)
+	t.Run("syntheticTables", syntheticTables)
+	t.Run("queryWithVariables", queryWithVariables)
+	t.Run("withWhereOnRelations", withWhereOnRelations)
+	t.Run("multiRoot", multiRoot)
+	t.Run("jsonColumnAsTable", jsonColumnAsTable)
+	t.Run("withCursor", withCursor)
+	t.Run("nullForAuthRequiredInAnon", nullForAuthRequiredInAnon)
+	t.Run("blockedQuery", blockedQuery)
+	t.Run("blockedFunctions", blockedFunctions)
+}
+
+var benchGQL = []byte(`query {
+	proDUcts(
+		# returns only 30 items
+		limit: 30,
+
+		# starts from item 10, commented out for now
+		# offset: 10,
+
+		# orders the response items by highest price
+		order_by: { price: desc },
+
+		# only items with an id >= 30 and < 30 are returned
+		where: { id: { and: { greater_or_equals: 20, lt: 28 } } }) {
+		id
+		NAME
+		price
+		user {
+			full_name
+			picture : avatar
+		}
+	}
+}`)
+
+func BenchmarkCompile(b *testing.B) {
+	w := &bytes.Buffer{}
+
+	b.ResetTimer()
+	b.ReportAllocs()
+
+	for n := 0; n < b.N; n++ {
+		w.Reset()
+
+		qc, err := qcompile.Compile(benchGQL, "user")
+		if err != nil {
+			b.Fatal(err)
+		}
+
+		_, err = pcompile.Compile(qc, w, nil)
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkCompileParallel(b *testing.B) {
+	b.ReportAllocs()
+
+	b.RunParallel(func(pb *testing.PB) {
+		w := &bytes.Buffer{}
+
+		for pb.Next() {
+			w.Reset()
+
+			qc, err := qcompile.Compile(benchGQL, "user")
+			if err != nil {
+				b.Fatal(err)
+			}
+
+			_, err = pcompile.Compile(qc, w, nil)
+			if err != nil {
+				b.Fatal(err)
+			}
+		}
+	})
+}

core/internal/psql/schema.go

@@ -0,0 +1,426 @@
+package psql
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/gobuffalo/flect"
+)
+
+type DBSchema struct {
+	ver int
+	t   map[string]*DBTableInfo
+	rm  map[string]map[string]*DBRel
+}
+
+type DBTableInfo struct {
+	Name       string
+	Type       string
+	Singular   bool
+	Columns    []DBColumn
+	PrimaryCol *DBColumn
+	TSVCol     *DBColumn
+	ColMap     map[string]*DBColumn
+	ColIDMap   map[int16]*DBColumn
+}
+
+type RelType int
+
+const (
+	RelOneToOne RelType = iota + 1
+	RelOneToMany
+	RelOneToManyThrough
+	RelEmbedded
+	RelRemote
+)
+
+type DBRel struct {
+	Type    RelType
+	Through string
+	ColT    string
+	Left    struct {
+		col   *DBColumn
+		Table string
+		Col   string
+		Array bool
+	}
+	Right struct {
+		col   *DBColumn
+		Table string
+		Col   string
+		Array bool
+	}
+}
+
+func NewDBSchema(info *DBInfo, aliases map[string][]string) (*DBSchema, error) {
+	schema := &DBSchema{
+		t:  make(map[string]*DBTableInfo),
+		rm: make(map[string]map[string]*DBRel),
+	}
+
+	for i, t := range info.Tables {
+		err := schema.addTable(t, info.Columns[i], aliases)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	for i, t := range info.Tables {
+		err := schema.firstDegreeRels(t, info.Columns[i])
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	for i, t := range info.Tables {
+		err := schema.secondDegreeRels(t, info.Columns[i])
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return schema, nil
+}
+
+func (s *DBSchema) addTable(
+	t DBTable, cols []DBColumn, aliases map[string][]string) error {
+
+	colmap := make(map[string]*DBColumn, len(cols))
+	colidmap := make(map[int16]*DBColumn, len(cols))
+
+	singular := flect.Singularize(t.Key)
+	s.t[singular] = &DBTableInfo{
+		Name:     t.Name,
+		Type:     t.Type,
+		Singular: true,
+		Columns:  cols,
+		ColMap:   colmap,
+		ColIDMap: colidmap,
+	}
+
+	plural := flect.Pluralize(t.Key)
+	s.t[plural] = &DBTableInfo{
+		Name:     t.Name,
+		Type:     t.Type,
+		Singular: false,
+		Columns:  cols,
+		ColMap:   colmap,
+		ColIDMap: colidmap,
+	}
+
+	if al, ok := aliases[t.Key]; ok {
+		for i := range al {
+			k1 := flect.Singularize(al[i])
+			s.t[k1] = s.t[singular]
+
+			k2 := flect.Pluralize(al[i])
+			s.t[k2] = s.t[plural]
+		}
+	}
+
+	for i := range cols {
+		c := &cols[i]
+
+		switch {
+		case c.Type == "tsvector":
+			s.t[singular].TSVCol = c
+			s.t[plural].TSVCol = c
+
+		case c.PrimaryKey:
+			s.t[singular].PrimaryCol = c
+			s.t[plural].PrimaryCol = c
+		}
+
+		colmap[c.Key] = c
+		colidmap[c.ID] = c
+	}
+
+	return nil
+}
+
+func (s *DBSchema) firstDegreeRels(t DBTable, cols []DBColumn) error {
+	ct := t.Key
+	cti, ok := s.t[ct]
+	if !ok {
+		return fmt.Errorf("invalid foreign key table '%s'", ct)
+	}
+
+	for i := range cols {
+		c := cols[i]
+
+		if len(c.FKeyTable) == 0 {
+			continue
+		}
+
+		// Foreign key column name
+		ft := strings.ToLower(c.FKeyTable)
+
+		ti, ok := s.t[ft]
+		if !ok {
+			return fmt.Errorf("invalid foreign key table '%s'", ft)
+		}
+
+		// This is an embedded relationship like when a json/jsonb column
+		// is exposed as a table
+		if c.Name == c.FKeyTable && len(c.FKeyColID) == 0 {
+			rel := &DBRel{Type: RelEmbedded}
+			rel.Left.col = cti.PrimaryCol
+			rel.Left.Table = cti.Name
+			rel.Left.Col = cti.PrimaryCol.Name
+
+			rel.Right.col = &c
+			rel.Right.Table = ti.Name
+			rel.Right.Col = c.Name
+
+			if err := s.SetRel(ft, ct, rel); err != nil {
+				return err
+			}
+			continue
+		}
+
+		if len(c.FKeyColID) == 0 {
+			continue
+		}
+
+		// Foreign key column id
+		fcid := c.FKeyColID[0]
+
+		fc, ok := ti.ColIDMap[fcid]
+		if !ok {
+			return fmt.Errorf("invalid foreign key column id '%d' for table '%s'",
+				fcid, ti.Name)
+		}
+
+		var rel1, rel2 *DBRel
+
+		// One-to-many relation between current table and the
+		// table in the foreign key
+		if fc.UniqueKey {
+			rel1 = &DBRel{Type: RelOneToOne}
+		} else {
+			rel1 = &DBRel{Type: RelOneToMany}
+		}
+
+		rel1.Left.col = &c
+		rel1.Left.Table = t.Name
+		rel1.Left.Col = c.Name
+		rel1.Left.Array = c.Array
+
+		rel1.Right.col = fc
+		rel1.Right.Table = c.FKeyTable
+		rel1.Right.Col = fc.Name
+		rel1.Right.Array = fc.Array
+
+		if err := s.SetRel(ct, ft, rel1); err != nil {
+			return err
+		}
+
+		// One-to-many reverse relation between the foreign key table and the
+		// the current table
+		if c.UniqueKey {
+			rel2 = &DBRel{Type: RelOneToOne}
+		} else {
+			rel2 = &DBRel{Type: RelOneToMany}
+		}
+
+		rel2.Left.col = fc
+		rel2.Left.Table = c.FKeyTable
+		rel2.Left.Col = fc.Name
+		rel2.Left.Array = fc.Array
+
+		rel2.Right.col = &c
+		rel2.Right.Table = t.Name
+		rel2.Right.Col = c.Name
+		rel2.Right.Array = c.Array
+
+		if err := s.SetRel(ft, ct, rel2); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (s *DBSchema) secondDegreeRels(t DBTable, cols []DBColumn) error {
+	jcols := make([]DBColumn, 0, len(cols))
+	ct := t.Key
+	cti, ok := s.t[ct]
+	if !ok {
+		return fmt.Errorf("invalid foreign key table '%s'", ct)
+	}
+
+	for i := range cols {
+		c := cols[i]
+
+		if len(c.FKeyTable) == 0 {
+			continue
+		}
+
+		// Foreign key column name
+		ft := strings.ToLower(c.FKeyTable)
+
+		ti, ok := s.t[ft]
+		if !ok {
+			return fmt.Errorf("invalid foreign key table '%s'", ft)
+		}
+
+		// This is an embedded relationship like when a json/jsonb column
+		// is exposed as a table
+		if c.Name == c.FKeyTable && len(c.FKeyColID) == 0 {
+			continue
+		}
+
+		if len(c.FKeyColID) == 0 {
+			continue
+		}
+
+		// Foreign key column id
+		fcid := c.FKeyColID[0]
+
+		if _, ok := ti.ColIDMap[fcid]; !ok {
+			return fmt.Errorf("invalid foreign key column id '%d' for table '%s'",
+				fcid, ti.Name)
+		}
+
+		jcols = append(jcols, c)
+	}
+
+	// If table contains multiple foreign key columns it's a possible
+	// join table for many-to-many relationships or multiple one-to-many
+	// relations
+
+	// Below one-to-many relations use the current table as the
+	// join table aka through table.
+	if len(jcols) > 1 {
+		for i := range jcols {
+			for n := range jcols {
+				if n == i {
+					continue
+				}
+				err := s.updateSchemaOTMT(cti, jcols[i], jcols[n])
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+func (s *DBSchema) updateSchemaOTMT(
+	ti *DBTableInfo, col1, col2 DBColumn) error {
+
+	t1 := strings.ToLower(col1.FKeyTable)
+	t2 := strings.ToLower(col2.FKeyTable)
+
+	fc1, ok := s.t[t1].ColIDMap[col1.FKeyColID[0]]
+	if !ok {
+		return fmt.Errorf("invalid foreign key column id '%d' for table '%s'",
+			col1.FKeyColID[0], ti.Name)
+	}
+	fc2, ok := s.t[t2].ColIDMap[col2.FKeyColID[0]]
+	if !ok {
+		return fmt.Errorf("invalid foreign key column id '%d' for table '%s'",
+			col2.FKeyColID[0], ti.Name)
+	}
+
+	// One-to-many-through relation between 1nd foreign key table and the
+	// 2nd foreign key table
+	rel1 := &DBRel{Type: RelOneToManyThrough}
+	rel1.Through = ti.Name
+	rel1.ColT = col2.Name
+
+	rel1.Left.col = &col2
+	rel1.Left.Table = col2.FKeyTable
+	rel1.Left.Col = fc2.Name
+
+	rel1.Right.col = &col1
+	rel1.Right.Table = ti.Name
+	rel1.Right.Col = col1.Name
+
+	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{Type: RelOneToManyThrough}
+	rel2.Through = ti.Name
+	rel2.ColT = col1.Name
+
+	rel1.Left.col = fc1
+	rel2.Left.Table = col1.FKeyTable
+	rel2.Left.Col = fc1.Name
+
+	rel1.Right.col = &col2
+	rel2.Right.Table = ti.Name
+	rel2.Right.Col = col2.Name
+
+	if err := s.SetRel(t2, t1, rel2); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *DBSchema) GetTable(table string) (*DBTableInfo, error) {
+	t, ok := s.t[table]
+	if !ok {
+		return nil, fmt.Errorf("unknown table '%s'", table)
+	}
+	return t, nil
+}
+
+func (s *DBSchema) SetRel(child, parent string, rel *DBRel) error {
+	sp := strings.ToLower(flect.Singularize(parent))
+	pp := strings.ToLower(flect.Pluralize(parent))
+
+	sc := strings.ToLower(flect.Singularize(child))
+	pc := strings.ToLower(flect.Pluralize(child))
+
+	if _, ok := s.rm[sc]; !ok {
+		s.rm[sc] = make(map[string]*DBRel)
+	}
+
+	if _, ok := s.rm[pc]; !ok {
+		s.rm[pc] = make(map[string]*DBRel)
+	}
+
+	if _, ok := s.rm[sc][sp]; !ok {
+		s.rm[sc][sp] = rel
+	}
+	if _, ok := s.rm[sc][pp]; !ok {
+		s.rm[sc][pp] = rel
+	}
+	if _, ok := s.rm[pc][sp]; !ok {
+		s.rm[pc][sp] = rel
+	}
+	if _, ok := s.rm[pc][pp]; !ok {
+		s.rm[pc][pp] = rel
+	}
+
+	return nil
+}
+
+func (s *DBSchema) GetRel(child, parent string) (*DBRel, error) {
+	rel, ok := s.rm[child][parent]
+	if !ok {
+		// No relationship found so this time fetch the table info
+		// and try again in case child or parent was an alias
+		ct, err := s.GetTable(child)
+		if err != nil {
+			return nil, err
+		}
+		pt, err := s.GetTable(parent)
+		if err != nil {
+			return nil, err
+		}
+		rel, ok = s.rm[ct.Name][pt.Name]
+		if !ok {
+			return nil, fmt.Errorf("unknown relationship '%s' -> '%s'",
+				child, parent)
+		}
+	}
+	return rel, nil
+}

core/internal/psql/stack_int.go

@@ -0,0 +1,47 @@
+package psql
+
+type IntStack struct {
+	stA [20]int32
+	st  []int32
+	top int
+}
+
+// Create a new IntStack
+func NewIntStack() *IntStack {
+	s := &IntStack{top: -1}
+	s.st = s.stA[:0]
+	return s
+}
+
+// Return the number of items in the IntStack
+func (s *IntStack) Len() int {
+	return (s.top + 1)
+}
+
+// View the top item on the IntStack
+func (s *IntStack) Peek() int32 {
+	if s.top == -1 {
+		return -1
+	}
+	return s.st[s.top]
+}
+
+// Pop the top item of the IntStack and return it
+func (s *IntStack) Pop() int32 {
+	if s.top == -1 {
+		return -1
+	}
+
+	s.top--
+	return s.st[(s.top + 1)]
+}
+
+// Push a value onto the top of the IntStack
+func (s *IntStack) Push(value int32) {
+	s.top++
+	if len(s.st) <= s.top {
+		s.st = append(s.st, value)
+	} else {
+		s.st[s.top] = value
+	}
+}

core/internal/psql/strings.go

@@ -0,0 +1,28 @@
+package psql
+
+import "fmt"
+
+func (rt RelType) String() string {
+	switch rt {
+	case RelOneToOne:
+		return "one to one"
+	case RelOneToMany:
+		return "one to many"
+	case RelOneToManyThrough:
+		return "one to many through"
+	case RelRemote:
+		return "remote"
+	case RelEmbedded:
+		return "embedded"
+	}
+	return ""
+}
+
+func (re *DBRel) String() string {
+	if re.Type == RelOneToManyThrough {
+		return fmt.Sprintf("'%s.%s' --(Through: %s)--> '%s.%s'",
+			re.Left.Table, re.Left.Col, re.Through, re.Right.Table, re.Right.Col)
+	}
+	return fmt.Sprintf("'%s.%s' --(%s)--> '%s.%s'",
+		re.Left.Table, re.Left.Col, re.Type, re.Right.Table, re.Right.Col)
+}

core/internal/psql/tables.go

@@ -0,0 +1,248 @@
+package psql
+
+import (
+	"database/sql"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/jackc/pgtype"
+)
+
+type DBInfo struct {
+	Version int
+	Tables  []DBTable
+	Columns [][]DBColumn
+	colmap  map[string]map[string]*DBColumn
+}
+
+func GetDBInfo(db *sql.DB) (*DBInfo, error) {
+	di := &DBInfo{}
+	var version string
+
+	err := db.QueryRow(`SHOW server_version_num`).Scan(&version)
+	if err != nil {
+		return nil, fmt.Errorf("error fetching version: %w", err)
+	}
+
+	di.Version, err = strconv.Atoi(version)
+	if err != nil {
+		return nil, err
+	}
+
+	di.Tables, err = GetTables(db)
+	if err != nil {
+		return nil, err
+	}
+
+	di.colmap = make(map[string]map[string]*DBColumn, len(di.Tables))
+
+	for i, t := range di.Tables {
+		cols, err := GetColumns(db, "public", t.Name)
+		if err != nil {
+			return nil, err
+		}
+
+		di.Columns = append(di.Columns, cols)
+		di.colmap[t.Key] = make(map[string]*DBColumn, len(cols))
+
+		for n, c := range di.Columns[i] {
+			di.colmap[t.Key][c.Key] = &di.Columns[i][n]
+		}
+	}
+
+	return di, nil
+}
+
+func (di *DBInfo) AddTable(t DBTable, cols []DBColumn) {
+	t.ID = di.Tables[len(di.Tables)-1].ID
+
+	di.Tables = append(di.Tables, t)
+	di.colmap[t.Key] = make(map[string]*DBColumn, len(cols))
+
+	for i := range cols {
+		cols[i].ID = int16(i)
+		c := &cols[i]
+		di.colmap[t.Key][c.Key] = c
+	}
+	di.Columns = append(di.Columns, cols)
+}
+
+func (di *DBInfo) GetColumn(table, column string) (*DBColumn, bool) {
+	v, ok := di.colmap[strings.ToLower(table)][strings.ToLower(column)]
+	return v, ok
+}
+
+type DBTable struct {
+	ID   int
+	Name string
+	Key  string
+	Type string
+}
+
+func GetTables(db *sql.DB) ([]DBTable, error) {
+	sqlStmt := `
+SELECT
+	c.relname as "name",
+	CASE c.relkind WHEN 'r' THEN 'table'
+		WHEN 'v' THEN 'view'
+		WHEN 'm' THEN 'materialized view'
+		WHEN 'f' THEN 'foreign table' 
+	END as "type"
+FROM pg_catalog.pg_class c
+	LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+WHERE c.relkind IN ('r','v','m','f','')
+	AND n.nspname <> ('pg_catalog')
+	AND n.nspname <> ('information_schema')
+	AND n.nspname !~ ('^pg_toast')
+AND pg_catalog.pg_table_is_visible(c.oid);`
+
+	var tables []DBTable
+
+	rows, err := db.Query(sqlStmt)
+	if err != nil {
+		return nil, fmt.Errorf("Error fetching tables: %s", err)
+	}
+	defer rows.Close()
+
+	for i := 0; rows.Next(); i++ {
+		t := DBTable{ID: i}
+		err = rows.Scan(&t.Name, &t.Type)
+		if err != nil {
+			return nil, err
+		}
+		t.Key = strings.ToLower(t.Name)
+		if t.Key != "schema_migrations" && t.Key != "ar_internal_metadata" {
+			tables = append(tables, t)
+		}
+	}
+
+	return tables, nil
+}
+
+type DBColumn struct {
+	ID         int16
+	Name       string
+	Key        string
+	Type       string
+	Array      bool
+	NotNull    bool
+	PrimaryKey bool
+	UniqueKey  bool
+	FKeyTable  string
+	FKeyColID  []int16
+	fKeyColID  pgtype.Int2Array
+}
+
+func GetColumns(db *sql.DB, schema, table string) ([]DBColumn, error) {
+	sqlStmt := `
+SELECT  
+	f.attnum AS id,  
+	f.attname AS name,  
+	f.attnotnull AS notnull,  
+	pg_catalog.format_type(f.atttypid,f.atttypmod) AS type,  
+	CASE
+	 WHEN f.attndims != 0 THEN true
+	 WHEN right(pg_catalog.format_type(f.atttypid,f.atttypmod), 2) = '[]' THEN true
+	 ELSE false
+	END AS array,
+	CASE  
+		WHEN p.contype = ('p'::char) THEN true  
+		ELSE false 
+	END AS primarykey,  
+	CASE  
+		WHEN p.contype = ('u'::char) THEN true  
+		ELSE false
+	END AS uniquekey,
+	CASE
+		WHEN p.contype = ('f'::char) THEN g.relname 
+		ELSE ''::text
+	END AS foreignkey,
+	CASE
+		WHEN p.contype = ('f'::char) THEN p.confkey::int2[]
+		ELSE ARRAY[]::int2[]
+	END AS foreignkey_fieldnum
+FROM pg_attribute f
+	JOIN pg_class c ON c.oid = f.attrelid  
+	LEFT JOIN pg_attrdef d ON d.adrelid = c.oid AND d.adnum = f.attnum  
+	LEFT JOIN pg_namespace n ON n.oid = c.relnamespace  
+	LEFT JOIN pg_constraint p ON p.conrelid = c.oid AND f.attnum = ANY (p.conkey)  
+	LEFT JOIN pg_class AS g ON p.confrelid = g.oid  
+WHERE c.relkind IN ('r', 'v', 'm', 'f')
+	AND n.nspname = $1  -- Replace with Schema name  
+	AND c.relname = $2  -- Replace with table name  
+	AND f.attnum > 0
+	AND f.attisdropped = false
+ORDER BY id;`
+
+	rows, err := db.Query(sqlStmt, schema, table)
+	if err != nil {
+		return nil, fmt.Errorf("error fetching columns: %s", err)
+	}
+	defer rows.Close()
+
+	cmap := make(map[int16]DBColumn)
+
+	for rows.Next() {
+		c := DBColumn{}
+
+		err = rows.Scan(&c.ID, &c.Name, &c.NotNull, &c.Type, &c.Array, &c.PrimaryKey, &c.UniqueKey, &c.FKeyTable, &c.fKeyColID)
+		if err != nil {
+			return nil, err
+		}
+
+		if v, ok := cmap[c.ID]; ok {
+			if c.PrimaryKey {
+				v.PrimaryKey = true
+				v.UniqueKey = true
+			}
+			if c.NotNull {
+				v.NotNull = true
+			}
+			if c.UniqueKey {
+				v.UniqueKey = true
+			}
+			if c.Array {
+				v.Array = true
+			}
+			if len(c.FKeyTable) != 0 {
+				v.FKeyTable = c.FKeyTable
+			}
+			if c.fKeyColID.Elements != nil {
+				v.fKeyColID = c.fKeyColID
+				err := v.fKeyColID.AssignTo(&v.FKeyColID)
+				if err != nil {
+					return nil, err
+				}
+			}
+			cmap[c.ID] = v
+		} else {
+			err := c.fKeyColID.AssignTo(&c.FKeyColID)
+			if err != nil {
+				return nil, err
+			}
+			c.Key = strings.ToLower(c.Name)
+			if c.PrimaryKey {
+				c.UniqueKey = true
+			}
+			cmap[c.ID] = c
+		}
+	}
+
+	cols := make([]DBColumn, 0, len(cmap))
+	for i := range cmap {
+		cols = append(cols, cmap[i])
+	}
+
+	return cols, nil
+}
+
+// func GetValType(type string) qcode.ValType {
+// 	switch {
+// 		case "bigint", "integer", "smallint", "numeric", "bigserial":
+// 			return qcode.ValInt
+// 		case "double precision", "real":
+// 			return qcode.ValFloat
+// 		case ""
+// 	}
+// }

core/internal/psql/test_schema.go

@@ -0,0 +1,109 @@
+package psql
+
+import (
+	"log"
+	"strings"
+)
+
+func getTestSchema() *DBSchema {
+	tables := []DBTable{
+		DBTable{Name: "customers", Type: "table"},
+		DBTable{Name: "users", Type: "table"},
+		DBTable{Name: "products", Type: "table"},
+		DBTable{Name: "purchases", Type: "table"},
+		DBTable{Name: "tags", Type: "table"},
+		DBTable{Name: "tag_count", Type: "json"},
+	}
+
+	columns := [][]DBColumn{
+		[]DBColumn{
+			DBColumn{ID: 1, Name: "id", Type: "bigint", NotNull: true, PrimaryKey: true, UniqueKey: true},
+			DBColumn{ID: 2, Name: "full_name", Type: "character varying", NotNull: true, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 3, Name: "phone", Type: "character varying", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 4, Name: "email", Type: "character varying", NotNull: true, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 5, Name: "encrypted_password", Type: "character varying", NotNull: true, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 6, Name: "reset_password_token", Type: "character varying", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 7, Name: "reset_password_sent_at", Type: "timestamp without time zone", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 8, Name: "remember_created_at", Type: "timestamp without time zone", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 9, Name: "created_at", Type: "timestamp without time zone", NotNull: true, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 10, Name: "updated_at", Type: "timestamp without time zone", NotNull: true, PrimaryKey: false, UniqueKey: false}},
+		[]DBColumn{
+			DBColumn{ID: 1, Name: "id", Type: "bigint", NotNull: true, PrimaryKey: true, UniqueKey: true},
+			DBColumn{ID: 2, Name: "full_name", Type: "character varying", NotNull: true, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 3, Name: "phone", Type: "character varying", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 4, Name: "avatar", Type: "character varying", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 5, Name: "email", Type: "character varying", NotNull: true, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 6, Name: "encrypted_password", Type: "character varying", NotNull: true, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 7, Name: "reset_password_token", Type: "character varying", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 8, Name: "reset_password_sent_at", Type: "timestamp without time zone", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 9, Name: "remember_created_at", Type: "timestamp without time zone", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 10, Name: "created_at", Type: "timestamp without time zone", NotNull: true, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 11, Name: "updated_at", Type: "timestamp without time zone", NotNull: true, PrimaryKey: false, UniqueKey: false}},
+		[]DBColumn{
+			DBColumn{ID: 1, Name: "id", Type: "bigint", NotNull: true, PrimaryKey: true, UniqueKey: true},
+			DBColumn{ID: 2, Name: "name", Type: "character varying", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 3, Name: "description", Type: "text", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 4, Name: "price", Type: "numeric(7,2)", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 5, Name: "user_id", Type: "bigint", NotNull: false, PrimaryKey: false, UniqueKey: false, FKeyTable: "users", FKeyColID: []int16{1}},
+			DBColumn{ID: 6, Name: "created_at", Type: "timestamp without time zone", NotNull: true, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 7, Name: "updated_at", Type: "timestamp without time zone", NotNull: true, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 8, Name: "tsv", Type: "tsvector", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 9, Name: "tags", Type: "text[]", NotNull: false, PrimaryKey: false, UniqueKey: false, FKeyTable: "tags", FKeyColID: []int16{3}, Array: true},
+			DBColumn{ID: 9, Name: "tag_count", Type: "json", NotNull: false, PrimaryKey: false, UniqueKey: false, FKeyTable: "tag_count", FKeyColID: []int16{}}},
+		[]DBColumn{
+			DBColumn{ID: 1, Name: "id", Type: "bigint", NotNull: true, PrimaryKey: true, UniqueKey: true},
+			DBColumn{ID: 2, Name: "customer_id", Type: "bigint", NotNull: false, PrimaryKey: false, UniqueKey: false, FKeyTable: "customers", FKeyColID: []int16{1}},
+			DBColumn{ID: 3, Name: "product_id", Type: "bigint", NotNull: false, PrimaryKey: false, UniqueKey: false, FKeyTable: "products", FKeyColID: []int16{1}},
+			DBColumn{ID: 4, Name: "sale_type", Type: "character varying", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 5, Name: "quantity", Type: "integer", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 6, Name: "due_date", Type: "timestamp without time zone", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 7, Name: "returned", Type: "timestamp without time zone", NotNull: false, PrimaryKey: false, UniqueKey: false}},
+		[]DBColumn{
+			DBColumn{ID: 1, Name: "id", Type: "bigint", NotNull: true, PrimaryKey: true, UniqueKey: true},
+			DBColumn{ID: 2, Name: "name", Type: "text", NotNull: false, PrimaryKey: false, UniqueKey: false},
+			DBColumn{ID: 3, Name: "slug", Type: "text", NotNull: false, PrimaryKey: false, UniqueKey: false}},
+		[]DBColumn{
+			DBColumn{ID: 1, Name: "tag_id", Type: "bigint", NotNull: false, PrimaryKey: false, UniqueKey: false, FKeyTable: "tags", FKeyColID: []int16{1}},
+			DBColumn{ID: 2, Name: "count", Type: "int", NotNull: false, PrimaryKey: false, UniqueKey: false}},
+	}
+
+	for i := range tables {
+		tables[i].Key = strings.ToLower(tables[i].Name)
+		for n := range columns[i] {
+			columns[i][n].Key = strings.ToLower(columns[i][n].Name)
+		}
+	}
+
+	schema := &DBSchema{
+		ver: 110000,
+		t:   make(map[string]*DBTableInfo),
+		rm:  make(map[string]map[string]*DBRel),
+	}
+
+	aliases := map[string][]string{
+		"users": []string{"mes"},
+	}
+
+	for i, t := range tables {
+		err := schema.addTable(t, columns[i], aliases)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	for i, t := range tables {
+		err := schema.firstDegreeRels(t, columns[i])
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	for i, t := range tables {
+		err := schema.secondDegreeRels(t, columns[i])
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	return schema
+}

core/internal/psql/tests.sql

@@ -0,0 +1,288 @@
+?   	github.com/dosco/super-graph	[no test files]
+testing: warning: no tests to run
+PASS
+ok  	github.com/dosco/super-graph/core	0.025s [no tests to run]
+=== RUN   TestGQLName1
+--- PASS: TestGQLName1 (0.00s)
+=== RUN   TestGQLName2
+--- PASS: TestGQLName2 (0.00s)
+=== RUN   TestGQLName3
+--- PASS: TestGQLName3 (0.00s)
+=== RUN   TestGQLName4
+--- PASS: TestGQLName4 (0.00s)
+=== RUN   TestGQLName5
+--- PASS: TestGQLName5 (0.00s)
+=== RUN   TestFuzzCrashers
+--- PASS: TestFuzzCrashers (0.00s)
+PASS
+ok  	github.com/dosco/super-graph/core/internal/allow	0.010s
+?   	github.com/dosco/super-graph/core/internal/crypto	[no test files]
+?   	github.com/dosco/super-graph/core/internal/integration_tests	[no test files]
+=== RUN   TestCockroachDB
+started temporary cockroach db
+=== RUN   TestCockroachDB/seed_fixtures
+=== RUN   TestCockroachDB/get_line_items
+=== RUN   TestCockroachDB/update_line_item
+=== RUN   TestCockroachDB/delete_line_item
+=== RUN   TestCockroachDB/nested_insert
+stopping temporary cockroach db
+--- PASS: TestCockroachDB (0.85s)
+    --- PASS: TestCockroachDB/seed_fixtures (0.01s)
+    --- PASS: TestCockroachDB/get_line_items (0.00s)
+    --- PASS: TestCockroachDB/update_line_item (0.00s)
+    --- PASS: TestCockroachDB/delete_line_item (0.00s)
+    --- SKIP: TestCockroachDB/nested_insert (0.00s)
+        cockroachdb_test.go:61: nested inserts currently not working yet on cockroach db
+PASS
+ok  	github.com/dosco/super-graph/core/internal/integration_tests/cockroachdb	0.872s
+=== RUN   TestCockroachDB
+--- SKIP: TestCockroachDB (0.00s)
+    postgresql_test.go:17: set the SG_POSTGRESQL_TEST_URL env variable if you want to run integration tests against a PostgreSQL database
+PASS
+ok  	github.com/dosco/super-graph/core/internal/integration_tests/postgresql	0.015s
+=== RUN   TestCompileInsert
+=== RUN   TestCompileInsert/simpleInsert
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "users" AS (INSERT INTO "users" ("full_name", "email") SELECT CAST( i.j ->>'full_name' AS character varying), CAST( i.j ->>'email' AS character varying) FROM "_sg_input" i RETURNING *) SELECT jsonb_build_object('user', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "users_0"."id" AS "id" FROM (SELECT "users"."id" FROM "users" LIMIT ('1') :: integer) AS "users_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileInsert/singleInsert
+WITH "_sg_input" AS (SELECT '{{insert}}' :: json AS j), "products" AS (INSERT INTO "products" ("name", "description", "price", "user_id") SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'description' AS text), CAST( i.j ->>'price' AS numeric(7,2)), CAST( i.j ->>'user_id' AS bigint) FROM "_sg_input" i RETURNING *) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name" FROM (SELECT "products"."id", "products"."name" FROM "products" LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileInsert/bulkInsert
+WITH "_sg_input" AS (SELECT '{{insert}}' :: json AS j), "products" AS (INSERT INTO "products" ("name", "description") SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'description' AS text) FROM "_sg_input" i RETURNING *) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name" FROM (SELECT "products"."id", "products"."name" FROM "products" LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileInsert/simpleInsertWithPresets
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "products" AS (INSERT INTO "products" ("name", "price", "created_at", "updated_at", "user_id") SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'price' AS numeric(7,2)), 'now' :: timestamp without time zone, 'now' :: timestamp without time zone, '{{user_id}}' :: bigint FROM "_sg_input" i RETURNING *) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id" FROM (SELECT "products"."id" FROM "products" LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileInsert/nestedInsertManyToMany
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "products" AS (INSERT INTO "products" ("name", "price") SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'price' AS numeric(7,2)) FROM "_sg_input" i RETURNING *), "customers" AS (INSERT INTO "customers" ("full_name", "email") SELECT CAST( i.j ->>'full_name' AS character varying), CAST( i.j ->>'email' AS character varying) FROM "_sg_input" i RETURNING *), "purchases" AS (INSERT INTO "purchases" ("sale_type", "quantity", "due_date", "customer_id", "product_id") SELECT CAST( i.j ->>'sale_type' AS character varying), CAST( i.j ->>'quantity' AS integer), CAST( i.j ->>'due_date' AS timestamp without time zone), "customers"."id", "products"."id" FROM "_sg_input" i, "customers", "products" RETURNING *) SELECT jsonb_build_object('purchase', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "purchases_0"."sale_type" AS "sale_type", "purchases_0"."quantity" AS "quantity", "purchases_0"."due_date" AS "due_date", "__sj_1"."json" AS "product", "__sj_2"."json" AS "customer" FROM (SELECT "purchases"."sale_type", "purchases"."quantity", "purchases"."due_date", "purchases"."product_id", "purchases"."customer_id" FROM "purchases" LIMIT ('1') :: integer) AS "purchases_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_2".*) AS "json"FROM (SELECT "customers_2"."id" AS "id", "customers_2"."full_name" AS "full_name", "customers_2"."email" AS "email" FROM (SELECT "customers"."id", "customers"."full_name", "customers"."email" FROM "customers" WHERE ((("customers"."id") = ("purchases_0"."customer_id"))) LIMIT ('1') :: integer) AS "customers_2") AS "__sr_2") AS "__sj_2" ON ('true') LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "products_1"."id" AS "id", "products_1"."name" AS "name", "products_1"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE ((("products"."id") = ("purchases_0"."product_id"))) LIMIT ('1') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "customers" AS (INSERT INTO "customers" ("full_name", "email") SELECT CAST( i.j ->>'full_name' AS character varying), CAST( i.j ->>'email' AS character varying) FROM "_sg_input" i RETURNING *), "products" AS (INSERT INTO "products" ("name", "price") SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'price' AS numeric(7,2)) FROM "_sg_input" i RETURNING *), "purchases" AS (INSERT INTO "purchases" ("sale_type", "quantity", "due_date", "product_id", "customer_id") SELECT CAST( i.j ->>'sale_type' AS character varying), CAST( i.j ->>'quantity' AS integer), CAST( i.j ->>'due_date' AS timestamp without time zone), "products"."id", "customers"."id" FROM "_sg_input" i, "products", "customers" RETURNING *) SELECT jsonb_build_object('purchase', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "purchases_0"."sale_type" AS "sale_type", "purchases_0"."quantity" AS "quantity", "purchases_0"."due_date" AS "due_date", "__sj_1"."json" AS "product", "__sj_2"."json" AS "customer" FROM (SELECT "purchases"."sale_type", "purchases"."quantity", "purchases"."due_date", "purchases"."product_id", "purchases"."customer_id" FROM "purchases" LIMIT ('1') :: integer) AS "purchases_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_2".*) AS "json"FROM (SELECT "customers_2"."id" AS "id", "customers_2"."full_name" AS "full_name", "customers_2"."email" AS "email" FROM (SELECT "customers"."id", "customers"."full_name", "customers"."email" FROM "customers" WHERE ((("customers"."id") = ("purchases_0"."customer_id"))) LIMIT ('1') :: integer) AS "customers_2") AS "__sr_2") AS "__sj_2" ON ('true') LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "products_1"."id" AS "id", "products_1"."name" AS "name", "products_1"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE ((("products"."id") = ("purchases_0"."product_id"))) LIMIT ('1') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileInsert/nestedInsertOneToMany
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "users" AS (INSERT INTO "users" ("full_name", "email", "created_at", "updated_at") SELECT CAST( i.j ->>'full_name' AS character varying), CAST( i.j ->>'email' AS character varying), CAST( i.j ->>'created_at' AS timestamp without time zone), CAST( i.j ->>'updated_at' AS timestamp without time zone) FROM "_sg_input" i RETURNING *), "products" AS (INSERT INTO "products" ("name", "price", "created_at", "updated_at", "user_id") SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'price' AS numeric(7,2)), CAST( i.j ->>'created_at' AS timestamp without time zone), CAST( i.j ->>'updated_at' AS timestamp without time zone), "users"."id" FROM "_sg_input" i, "users" RETURNING *) SELECT jsonb_build_object('user', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "users_0"."id" AS "id", "users_0"."full_name" AS "full_name", "users_0"."email" AS "email", "__sj_1"."json" AS "product" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" LIMIT ('1') :: integer) AS "users_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "products_1"."id" AS "id", "products_1"."name" AS "name", "products_1"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE ((("products"."user_id") = ("users_0"."id"))) LIMIT ('1') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileInsert/nestedInsertOneToOne
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "users" AS (INSERT INTO "users" ("full_name", "email", "created_at", "updated_at") SELECT CAST( i.j ->>'full_name' AS character varying), CAST( i.j ->>'email' AS character varying), CAST( i.j ->>'created_at' AS timestamp without time zone), CAST( i.j ->>'updated_at' AS timestamp without time zone) FROM "_sg_input" i RETURNING *), "products" AS (INSERT INTO "products" ("name", "price", "created_at", "updated_at", "user_id") SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'price' AS numeric(7,2)), CAST( i.j ->>'created_at' AS timestamp without time zone), CAST( i.j ->>'updated_at' AS timestamp without time zone), "users"."id" FROM "_sg_input" i, "users" RETURNING *) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "__sj_1"."json" AS "user" FROM (SELECT "products"."id", "products"."name", "products"."user_id" FROM "products" LIMIT ('1') :: integer) AS "products_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "users_1"."id" AS "id", "users_1"."full_name" AS "full_name", "users_1"."email" AS "email" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" WHERE ((("users"."id") = ("products_0"."user_id"))) LIMIT ('1') :: integer) AS "users_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileInsert/nestedInsertOneToManyWithConnect
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "users" AS (INSERT INTO "users" ("full_name", "email", "created_at", "updated_at") SELECT CAST( i.j ->>'full_name' AS character varying), CAST( i.j ->>'email' AS character varying), CAST( i.j ->>'created_at' AS timestamp without time zone), CAST( i.j ->>'updated_at' AS timestamp without time zone) FROM "_sg_input" i RETURNING *), "products" AS ( UPDATE "products" SET "user_id" = "users"."id" FROM "users" WHERE ("products"."id"= ((i.j->'product'->'connect'->>'id'))::bigint) RETURNING "products".*) SELECT jsonb_build_object('user', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "users_0"."id" AS "id", "users_0"."full_name" AS "full_name", "users_0"."email" AS "email", "__sj_1"."json" AS "product" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" LIMIT ('1') :: integer) AS "users_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "products_1"."id" AS "id", "products_1"."name" AS "name", "products_1"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE ((("products"."user_id") = ("users_0"."id"))) LIMIT ('1') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileInsert/nestedInsertOneToOneWithConnect
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "_x_users" AS (SELECT "id" FROM "_sg_input" i,"users" WHERE "users"."id"= ((i.j->'user'->'connect'->>'id'))::bigint LIMIT 1), "products" AS (INSERT INTO "products" ("name", "price", "created_at", "updated_at", "user_id") SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'price' AS numeric(7,2)), CAST( i.j ->>'created_at' AS timestamp without time zone), CAST( i.j ->>'updated_at' AS timestamp without time zone), "_x_users"."id" FROM "_sg_input" i, "_x_users" RETURNING *) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "__sj_1"."json" AS "user", "__sj_2"."json" AS "tags" FROM (SELECT "products"."id", "products"."name", "products"."user_id", "products"."tags" FROM "products" LIMIT ('1') :: integer) AS "products_0" LEFT OUTER JOIN LATERAL (SELECT coalesce(jsonb_agg("__sj_2"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_2".*) AS "json"FROM (SELECT "tags_2"."id" AS "id", "tags_2"."name" AS "name" FROM (SELECT "tags"."id", "tags"."name" FROM "tags" WHERE ((("tags"."slug") = any ("products_0"."tags"))) LIMIT ('20') :: integer) AS "tags_2") AS "__sr_2") AS "__sj_2") AS "__sj_2" ON ('true') LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "users_1"."id" AS "id", "users_1"."full_name" AS "full_name", "users_1"."email" AS "email" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" WHERE ((("users"."id") = ("products_0"."user_id"))) LIMIT ('1') :: integer) AS "users_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileInsert/nestedInsertOneToOneWithConnectArray
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "_x_users" AS (SELECT "id" FROM "_sg_input" i,"users" WHERE "users"."id" = ANY((select a::bigint AS list from json_array_elements_text((i.j->'user'->'connect'->>'id')::json) AS a)) LIMIT 1), "products" AS (INSERT INTO "products" ("name", "price", "created_at", "updated_at", "user_id") SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'price' AS numeric(7,2)), CAST( i.j ->>'created_at' AS timestamp without time zone), CAST( i.j ->>'updated_at' AS timestamp without time zone), "_x_users"."id" FROM "_sg_input" i, "_x_users" RETURNING *) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "__sj_1"."json" AS "user" FROM (SELECT "products"."id", "products"."name", "products"."user_id" FROM "products" LIMIT ('1') :: integer) AS "products_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "users_1"."id" AS "id", "users_1"."full_name" AS "full_name", "users_1"."email" AS "email" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" WHERE ((("users"."id") = ("products_0"."user_id"))) LIMIT ('1') :: integer) AS "users_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+--- PASS: TestCompileInsert (0.04s)
+    --- PASS: TestCompileInsert/simpleInsert (0.00s)
+    --- PASS: TestCompileInsert/singleInsert (0.00s)
+    --- PASS: TestCompileInsert/bulkInsert (0.00s)
+    --- PASS: TestCompileInsert/simpleInsertWithPresets (0.00s)
+    --- PASS: TestCompileInsert/nestedInsertManyToMany (0.01s)
+    --- PASS: TestCompileInsert/nestedInsertOneToMany (0.01s)
+    --- PASS: TestCompileInsert/nestedInsertOneToOne (0.00s)
+    --- PASS: TestCompileInsert/nestedInsertOneToManyWithConnect (0.00s)
+    --- PASS: TestCompileInsert/nestedInsertOneToOneWithConnect (0.01s)
+    --- PASS: TestCompileInsert/nestedInsertOneToOneWithConnectArray (0.01s)
+=== RUN   TestCompileMutate
+=== RUN   TestCompileMutate/singleUpsert
+WITH "_sg_input" AS (SELECT '{{upsert}}' :: json AS j), "products" AS (INSERT INTO "products" ("name", "description") SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'description' AS text) FROM "_sg_input" i RETURNING *)  ON CONFLICT (id) DO UPDATE SET name = EXCLUDED.name, description = EXCLUDED.description RETURNING *) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name" FROM (SELECT "products"."id", "products"."name" FROM "products" LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileMutate/singleUpsertWhere
+WITH "_sg_input" AS (SELECT '{{upsert}}' :: json AS j), "products" AS (INSERT INTO "products" ("name", "description") SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'description' AS text) FROM "_sg_input" i RETURNING *)  ON CONFLICT (id) WHERE (("products"."price") > '3' :: numeric(7,2)) DO UPDATE SET name = EXCLUDED.name, description = EXCLUDED.description RETURNING *) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name" FROM (SELECT "products"."id", "products"."name" FROM "products" LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileMutate/bulkUpsert
+WITH "_sg_input" AS (SELECT '{{upsert}}' :: json AS j), "products" AS (INSERT INTO "products" ("name", "description") SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'description' AS text) FROM "_sg_input" i RETURNING *)  ON CONFLICT (id) DO UPDATE SET name = EXCLUDED.name, description = EXCLUDED.description RETURNING *) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name" FROM (SELECT "products"."id", "products"."name" FROM "products" LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileMutate/delete
+WITH "products" AS (DELETE FROM "products" WHERE (((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2))) AND (("products"."id") = '1' :: bigint)) RETURNING "products".*) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name" FROM (SELECT "products"."id", "products"."name" FROM "products" LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+--- PASS: TestCompileMutate (0.01s)
+    --- PASS: TestCompileMutate/singleUpsert (0.00s)
+    --- PASS: TestCompileMutate/singleUpsertWhere (0.00s)
+    --- PASS: TestCompileMutate/bulkUpsert (0.00s)
+    --- PASS: TestCompileMutate/delete (0.00s)
+=== RUN   TestCompileQuery
+=== RUN   TestCompileQuery/withComplexArgs
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "products_0"."price" AS "price" FROM (SELECT DISTINCT ON ("products"."price") "products"."id", "products"."name", "products"."price" FROM "products" WHERE (((("products"."id") < '28' :: bigint) AND (("products"."id") >= '20' :: bigint) AND ((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2))))) ORDER BY "products"."price" DESC LIMIT ('30') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/withWhereAndList
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "products_0"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE (((("products"."price") > '10' :: numeric(7,2)) AND NOT (("products"."id") IS NULL) AND ((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2))))) LIMIT ('20') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/withWhereIsNull
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "products_0"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE (((("products"."price") > '10' :: numeric(7,2)) AND NOT (("products"."id") IS NULL) AND ((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2))))) LIMIT ('20') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/withWhereMultiOr
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "products_0"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE ((((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2))) AND ((("products"."price") < '20' :: numeric(7,2)) OR (("products"."price") > '10' :: numeric(7,2)) OR NOT (("products"."id") IS NULL)))) LIMIT ('20') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/fetchByID
+SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name" FROM (SELECT "products"."id", "products"."name" FROM "products" WHERE ((((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2))) AND (("products"."id") =  '{{id}}' :: bigint))) LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileQuery/searchQuery
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0".*) AS "json"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" FROM (SELECT "products"."id", "products"."name", ts_rank("products"."tsv", websearch_to_tsquery('{{query}}')) AS "search_rank", ts_headline("products"."description", websearch_to_tsquery('{{query}}')) AS "search_headline_description" FROM "products" WHERE ((("products"."tsv") @@ websearch_to_tsquery('{{query}}'))) LIMIT ('20') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/oneToMany
+SELECT jsonb_build_object('users', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "users_0"."email" AS "email", "__sj_1"."json" AS "products" FROM (SELECT "users"."email", "users"."id" FROM "users" LIMIT ('20') :: integer) AS "users_0" LEFT OUTER JOIN LATERAL (SELECT coalesce(jsonb_agg("__sj_1"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "products_1"."name" AS "name", "products_1"."price" AS "price" FROM (SELECT "products"."name", "products"."price" FROM "products" WHERE ((("products"."user_id") = ("users_0"."id")) AND ((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2)))) LIMIT ('20') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/oneToManyReverse
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."name" AS "name", "products_0"."price" AS "price", "__sj_1"."json" AS "users" FROM (SELECT "products"."name", "products"."price", "products"."user_id" FROM "products" WHERE (((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2)))) LIMIT ('20') :: integer) AS "products_0" LEFT OUTER JOIN LATERAL (SELECT coalesce(jsonb_agg("__sj_1"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "users_1"."email" AS "email" FROM (SELECT "users"."email" FROM "users" WHERE ((("users"."id") = ("products_0"."user_id"))) LIMIT ('20') :: integer) AS "users_1") AS "__sr_1") AS "__sj_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/oneToManyArray
+SELECT jsonb_build_object('tags', "__sj_0"."json", 'product', "__sj_2"."json") as "__root" FROM (SELECT to_jsonb("__sr_2".*) AS "json"FROM (SELECT "products_2"."name" AS "name", "products_2"."price" AS "price", "__sj_3"."json" AS "tags" FROM (SELECT "products"."name", "products"."price", "products"."tags" FROM "products" LIMIT ('1') :: integer) AS "products_2" LEFT OUTER JOIN LATERAL (SELECT coalesce(jsonb_agg("__sj_3"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_3".*) AS "json"FROM (SELECT "tags_3"."id" AS "id", "tags_3"."name" AS "name" FROM (SELECT "tags"."id", "tags"."name" FROM "tags" WHERE ((("tags"."slug") = any ("products_2"."tags"))) LIMIT ('20') :: integer) AS "tags_3") AS "__sr_3") AS "__sj_3") AS "__sj_3" ON ('true')) AS "__sr_2") AS "__sj_2", (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "tags_0"."name" AS "name", "__sj_1"."json" AS "product" FROM (SELECT "tags"."name", "tags"."slug" FROM "tags" LIMIT ('20') :: integer) AS "tags_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "products_1"."name" AS "name" FROM (SELECT "products"."name" FROM "products" WHERE ((("tags_0"."slug") = any ("products"."tags"))) LIMIT ('1') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/manyToMany
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."name" AS "name", "__sj_1"."json" AS "customers" FROM (SELECT "products"."name", "products"."id" FROM "products" WHERE (((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2)))) LIMIT ('20') :: integer) AS "products_0" LEFT OUTER JOIN LATERAL (SELECT coalesce(jsonb_agg("__sj_1"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "customers_1"."email" AS "email", "customers_1"."full_name" AS "full_name" FROM (SELECT "customers"."email", "customers"."full_name" FROM "customers" LEFT OUTER JOIN "purchases" ON (("purchases"."product_id") = ("products_0"."id")) WHERE ((("customers"."id") = ("purchases"."customer_id"))) LIMIT ('20') :: integer) AS "customers_1") AS "__sr_1") AS "__sj_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/manyToManyReverse
+SELECT jsonb_build_object('customers', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "customers_0"."email" AS "email", "customers_0"."full_name" AS "full_name", "__sj_1"."json" AS "products" FROM (SELECT "customers"."email", "customers"."full_name", "customers"."id" FROM "customers" LIMIT ('20') :: integer) AS "customers_0" LEFT OUTER JOIN LATERAL (SELECT coalesce(jsonb_agg("__sj_1"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "products_1"."name" AS "name" 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' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2)))) LIMIT ('20') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/aggFunction
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."name" AS "name", "products_0"."count_price" AS "count_price" FROM (SELECT "products"."name", count("products"."price") AS "count_price" FROM "products" WHERE (((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2)))) GROUP BY "products"."name" LIMIT ('20') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/aggFunctionBlockedByCol
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."name" AS "name" FROM (SELECT "products"."name" FROM "products" GROUP BY "products"."name" LIMIT ('20') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/aggFunctionDisabled
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."name" AS "name" FROM (SELECT "products"."name" FROM "products" GROUP BY "products"."name" LIMIT ('20') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/aggFunctionWithFilter
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."max_price" AS "max_price" FROM (SELECT "products"."id", max("products"."price") AS "max_price" FROM "products" WHERE ((((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2))) AND (("products"."id") > '10' :: bigint))) GROUP BY "products"."id" LIMIT ('20') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/syntheticTables
+SELECT jsonb_build_object('me', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT  FROM (SELECT "users"."email" FROM "users" WHERE ((("users"."id") =  '{{user_id}}' :: bigint)) LIMIT ('1') :: integer) AS "users_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileQuery/queryWithVariables
+SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name" FROM (SELECT "products"."id", "products"."name" FROM "products" WHERE (((("products"."price") =  '{{product_price}}' :: numeric(7,2)) AND (("products"."id") =  '{{product_id}}' :: bigint) AND ((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2))))) LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileQuery/withWhereOnRelations
+SELECT jsonb_build_object('users', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "users_0"."id" AS "id", "users_0"."email" AS "email" FROM (SELECT "users"."id", "users"."email" FROM "users" WHERE (NOT EXISTS (SELECT 1 FROM products WHERE (("products"."user_id") = ("users"."id")) AND ((("products"."price") > '3' :: numeric(7,2))))) LIMIT ('20') :: integer) AS "users_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/multiRoot
+SELECT jsonb_build_object('customer', "__sj_0"."json", 'user', "__sj_1"."json", 'product', "__sj_2"."json") as "__root" FROM (SELECT to_jsonb("__sr_2".*) AS "json"FROM (SELECT "products_2"."id" AS "id", "products_2"."name" AS "name", "__sj_3"."json" AS "customers", "__sj_4"."json" AS "customer" FROM (SELECT "products"."id", "products"."name" FROM "products" WHERE (((("products"."price") > '0' :: numeric(7,2)) AND (("products"."price") < '8' :: numeric(7,2)))) LIMIT ('1') :: integer) AS "products_2" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_4".*) AS "json"FROM (SELECT "customers_4"."email" AS "email" FROM (SELECT "customers"."email" FROM "customers" LEFT OUTER JOIN "purchases" ON (("purchases"."product_id") = ("products_2"."id")) WHERE ((("customers"."id") = ("purchases"."customer_id"))) LIMIT ('1') :: integer) AS "customers_4") AS "__sr_4") AS "__sj_4" ON ('true') LEFT OUTER JOIN LATERAL (SELECT coalesce(jsonb_agg("__sj_3"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_3".*) AS "json"FROM (SELECT "customers_3"."email" AS "email" FROM (SELECT "customers"."email" FROM "customers" LEFT OUTER JOIN "purchases" ON (("purchases"."product_id") = ("products_2"."id")) WHERE ((("customers"."id") = ("purchases"."customer_id"))) LIMIT ('20') :: integer) AS "customers_3") AS "__sr_3") AS "__sj_3") AS "__sj_3" ON ('true')) AS "__sr_2") AS "__sj_2", (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "users_1"."id" AS "id", "users_1"."email" AS "email" FROM (SELECT "users"."id", "users"."email" FROM "users" LIMIT ('1') :: integer) AS "users_1") AS "__sr_1") AS "__sj_1", (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "customers_0"."id" AS "id" FROM (SELECT "customers"."id" FROM "customers" LIMIT ('1') :: integer) AS "customers_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileQuery/jsonColumnAsTable
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "__sj_1"."json" AS "tag_count" FROM (SELECT "products"."id", "products"."name" FROM "products" LIMIT ('20') :: integer) AS "products_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "tag_count_1"."count" AS "count", "__sj_2"."json" AS "tags" FROM (SELECT "tag_count"."count", "tag_count"."tag_id" FROM "products", json_to_recordset("products"."tag_count") AS "tag_count"(tag_id bigint, count int) WHERE ((("products"."id") = ("products_0"."id"))) LIMIT ('1') :: integer) AS "tag_count_1" LEFT OUTER JOIN LATERAL (SELECT coalesce(jsonb_agg("__sj_2"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_2".*) AS "json"FROM (SELECT "tags_2"."name" AS "name" FROM (SELECT "tags"."name" FROM "tags" WHERE ((("tags"."id") = ("tag_count_1"."tag_id"))) LIMIT ('20') :: integer) AS "tags_2") AS "__sr_2") AS "__sj_2") AS "__sj_2" ON ('true')) AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/withCursor
+SELECT jsonb_build_object('products', "__sj_0"."json", 'products_cursor', "__sj_0"."cursor") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json", CONCAT_WS(',', max("__cur_0"), max("__cur_1")) as "cursor" FROM (SELECT to_jsonb("__sr_0".*) - '__cur_0' - '__cur_1' AS "json", "__cur_0", "__cur_1"FROM (SELECT "products_0"."name" AS "name", LAST_VALUE("products_0"."price") OVER() AS "__cur_0", LAST_VALUE("products_0"."id") OVER() AS "__cur_1" FROM (WITH "__cur" AS (SELECT a[1] as "price", a[2] as "id" FROM string_to_array('{{cursor}}', ',') as a) SELECT "products"."name", "products"."id", "products"."price" FROM "products", "__cur" WHERE (((("products"."price") < "__cur"."price" :: numeric(7,2)) OR ((("products"."price") = "__cur"."price" :: numeric(7,2)) AND (("products"."id") > "__cur"."id" :: bigint)))) ORDER BY "products"."price" DESC, "products"."id" ASC LIMIT ('20') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/nullForAuthRequiredInAnon
+SELECT jsonb_build_object('products', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", NULL AS "user" FROM (SELECT "products"."id", "products"."name", "products"."user_id" FROM "products" LIMIT ('20') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+=== RUN   TestCompileQuery/blockedQuery
+SELECT jsonb_build_object('user', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "users_0"."id" AS "id", "users_0"."full_name" AS "full_name", "users_0"."email" AS "email" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" WHERE (false) LIMIT ('1') :: integer) AS "users_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileQuery/blockedFunctions
+SELECT jsonb_build_object('users', "__sj_0"."json") as "__root" FROM (SELECT coalesce(jsonb_agg("__sj_0"."json"), '[]') as "json" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "users_0"."email" AS "email" FROM (SELECT , "users"."email" FROM "users" WHERE (false) GROUP BY "users"."email" LIMIT ('20') :: integer) AS "users_0") AS "__sr_0") AS "__sj_0") AS "__sj_0"
+--- PASS: TestCompileQuery (0.05s)
+    --- PASS: TestCompileQuery/withComplexArgs (0.00s)
+    --- PASS: TestCompileQuery/withWhereAndList (0.00s)
+    --- PASS: TestCompileQuery/withWhereIsNull (0.00s)
+    --- PASS: TestCompileQuery/withWhereMultiOr (0.00s)
+    --- PASS: TestCompileQuery/fetchByID (0.00s)
+    --- PASS: TestCompileQuery/searchQuery (0.00s)
+    --- PASS: TestCompileQuery/oneToMany (0.00s)
+    --- PASS: TestCompileQuery/oneToManyReverse (0.00s)
+    --- PASS: TestCompileQuery/oneToManyArray (0.00s)
+    --- PASS: TestCompileQuery/manyToMany (0.00s)
+    --- PASS: TestCompileQuery/manyToManyReverse (0.00s)
+    --- PASS: TestCompileQuery/aggFunction (0.00s)
+    --- PASS: TestCompileQuery/aggFunctionBlockedByCol (0.00s)
+    --- PASS: TestCompileQuery/aggFunctionDisabled (0.00s)
+    --- PASS: TestCompileQuery/aggFunctionWithFilter (0.00s)
+    --- PASS: TestCompileQuery/syntheticTables (0.00s)
+    --- PASS: TestCompileQuery/queryWithVariables (0.00s)
+    --- PASS: TestCompileQuery/withWhereOnRelations (0.00s)
+    --- PASS: TestCompileQuery/multiRoot (0.01s)
+    --- PASS: TestCompileQuery/jsonColumnAsTable (0.00s)
+    --- PASS: TestCompileQuery/withCursor (0.00s)
+    --- PASS: TestCompileQuery/nullForAuthRequiredInAnon (0.00s)
+    --- PASS: TestCompileQuery/blockedQuery (0.00s)
+    --- PASS: TestCompileQuery/blockedFunctions (0.00s)
+=== RUN   TestCompileUpdate
+=== RUN   TestCompileUpdate/singleUpdate
+WITH "_sg_input" AS (SELECT '{{update}}' :: json AS j), "products" AS (UPDATE "products" SET ("name", "description") = (SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'description' AS text) FROM "_sg_input" i)  WHERE ((("products"."id") = '1' :: bigint) AND (("products"."id") =  '{{id}}' :: bigint)) RETURNING "products".*) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name" FROM (SELECT "products"."id", "products"."name" FROM "products" LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileUpdate/simpleUpdateWithPresets
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "products" AS (UPDATE "products" SET ("name", "price", "updated_at") = (SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'price' AS numeric(7,2)), 'now' :: timestamp without time zone FROM "_sg_input" i)  WHERE (("products"."user_id") =  '{{user_id}}' :: bigint) RETURNING "products".*) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id" FROM (SELECT "products"."id" FROM "products" LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileUpdate/nestedUpdateManyToMany
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "purchases" AS (UPDATE "purchases" SET ("sale_type", "quantity", "due_date") = (SELECT CAST( i.j ->>'sale_type' AS character varying), CAST( i.j ->>'quantity' AS integer), CAST( i.j ->>'due_date' AS timestamp without time zone) FROM "_sg_input" i)  WHERE (("purchases"."id") =  '{{id}}' :: bigint) RETURNING "purchases".*), "products" AS (UPDATE "products" SET ("name", "price") = (SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'price' AS numeric(7,2)) FROM "_sg_input" i) FROM "purchases" WHERE (("products"."id") = ("purchases"."product_id")) RETURNING "products".*), "customers" AS (UPDATE "customers" SET ("full_name", "email") = (SELECT CAST( i.j ->>'full_name' AS character varying), CAST( i.j ->>'email' AS character varying) FROM "_sg_input" i) FROM "purchases" WHERE (("customers"."id") = ("purchases"."customer_id")) RETURNING "customers".*) SELECT jsonb_build_object('purchase', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "purchases_0"."sale_type" AS "sale_type", "purchases_0"."quantity" AS "quantity", "purchases_0"."due_date" AS "due_date", "__sj_1"."json" AS "product", "__sj_2"."json" AS "customer" FROM (SELECT "purchases"."sale_type", "purchases"."quantity", "purchases"."due_date", "purchases"."product_id", "purchases"."customer_id" FROM "purchases" LIMIT ('1') :: integer) AS "purchases_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_2".*) AS "json"FROM (SELECT "customers_2"."id" AS "id", "customers_2"."full_name" AS "full_name", "customers_2"."email" AS "email" FROM (SELECT "customers"."id", "customers"."full_name", "customers"."email" FROM "customers" WHERE ((("customers"."id") = ("purchases_0"."customer_id"))) LIMIT ('1') :: integer) AS "customers_2") AS "__sr_2") AS "__sj_2" ON ('true') LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "products_1"."id" AS "id", "products_1"."name" AS "name", "products_1"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE ((("products"."id") = ("purchases_0"."product_id"))) LIMIT ('1') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "purchases" AS (UPDATE "purchases" SET ("sale_type", "quantity", "due_date") = (SELECT CAST( i.j ->>'sale_type' AS character varying), CAST( i.j ->>'quantity' AS integer), CAST( i.j ->>'due_date' AS timestamp without time zone) FROM "_sg_input" i)  WHERE (("purchases"."id") =  '{{id}}' :: bigint) RETURNING "purchases".*), "customers" AS (UPDATE "customers" SET ("full_name", "email") = (SELECT CAST( i.j ->>'full_name' AS character varying), CAST( i.j ->>'email' AS character varying) FROM "_sg_input" i) FROM "purchases" WHERE (("customers"."id") = ("purchases"."customer_id")) RETURNING "customers".*), "products" AS (UPDATE "products" SET ("name", "price") = (SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'price' AS numeric(7,2)) FROM "_sg_input" i) FROM "purchases" WHERE (("products"."id") = ("purchases"."product_id")) RETURNING "products".*) SELECT jsonb_build_object('purchase', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "purchases_0"."sale_type" AS "sale_type", "purchases_0"."quantity" AS "quantity", "purchases_0"."due_date" AS "due_date", "__sj_1"."json" AS "product", "__sj_2"."json" AS "customer" FROM (SELECT "purchases"."sale_type", "purchases"."quantity", "purchases"."due_date", "purchases"."product_id", "purchases"."customer_id" FROM "purchases" LIMIT ('1') :: integer) AS "purchases_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_2".*) AS "json"FROM (SELECT "customers_2"."id" AS "id", "customers_2"."full_name" AS "full_name", "customers_2"."email" AS "email" FROM (SELECT "customers"."id", "customers"."full_name", "customers"."email" FROM "customers" WHERE ((("customers"."id") = ("purchases_0"."customer_id"))) LIMIT ('1') :: integer) AS "customers_2") AS "__sr_2") AS "__sj_2" ON ('true') LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "products_1"."id" AS "id", "products_1"."name" AS "name", "products_1"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE ((("products"."id") = ("purchases_0"."product_id"))) LIMIT ('1') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileUpdate/nestedUpdateOneToMany
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "users" AS (UPDATE "users" SET ("full_name", "email", "created_at", "updated_at") = (SELECT CAST( i.j ->>'full_name' AS character varying), CAST( i.j ->>'email' AS character varying), CAST( i.j ->>'created_at' AS timestamp without time zone), CAST( i.j ->>'updated_at' AS timestamp without time zone) FROM "_sg_input" i)  WHERE (("users"."id") = '8' :: bigint) RETURNING "users".*), "products" AS (UPDATE "products" SET ("name", "price", "created_at", "updated_at") = (SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'price' AS numeric(7,2)), CAST( i.j ->>'created_at' AS timestamp without time zone), CAST( i.j ->>'updated_at' AS timestamp without time zone) FROM "_sg_input" i) FROM "users" WHERE (("products"."user_id") = ("users"."id") AND "products"."id"= ((i.j->'product'->'where'->>'id'))::bigint) RETURNING "products".*) SELECT jsonb_build_object('user', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "users_0"."id" AS "id", "users_0"."full_name" AS "full_name", "users_0"."email" AS "email", "__sj_1"."json" AS "product" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" LIMIT ('1') :: integer) AS "users_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "products_1"."id" AS "id", "products_1"."name" AS "name", "products_1"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE ((("products"."user_id") = ("users_0"."id"))) LIMIT ('1') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileUpdate/nestedUpdateOneToOne
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "products" AS (UPDATE "products" SET ("name", "price", "created_at", "updated_at") = (SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'price' AS numeric(7,2)), CAST( i.j ->>'created_at' AS timestamp without time zone), CAST( i.j ->>'updated_at' AS timestamp without time zone) FROM "_sg_input" i)  WHERE (("products"."id") =  '{{id}}' :: bigint) RETURNING "products".*), "users" AS (UPDATE "users" SET ("email") = (SELECT CAST( i.j ->>'email' AS character varying) FROM "_sg_input" i) FROM "products" WHERE (("users"."id") = ("products"."user_id")) RETURNING "users".*) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "__sj_1"."json" AS "user" FROM (SELECT "products"."id", "products"."name", "products"."user_id" FROM "products" LIMIT ('1') :: integer) AS "products_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "users_1"."id" AS "id", "users_1"."full_name" AS "full_name", "users_1"."email" AS "email" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" WHERE ((("users"."id") = ("products_0"."user_id"))) LIMIT ('1') :: integer) AS "users_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileUpdate/nestedUpdateOneToManyWithConnect
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "users" AS (UPDATE "users" SET ("full_name", "email", "created_at", "updated_at") = (SELECT CAST( i.j ->>'full_name' AS character varying), CAST( i.j ->>'email' AS character varying), CAST( i.j ->>'created_at' AS timestamp without time zone), CAST( i.j ->>'updated_at' AS timestamp without time zone) FROM "_sg_input" i)  WHERE (("users"."id") =  '{{id}}' :: bigint) RETURNING "users".*), "products_c" AS ( UPDATE "products" SET "user_id" = "users"."id" FROM "users" WHERE ("products"."id"= ((i.j->'product'->'connect'->>'id'))::bigint) RETURNING "products".*), "products_d" AS ( UPDATE "products" SET "user_id" =  NULL FROM "users" WHERE ("products"."id"= ((i.j->'product'->'disconnect'->>'id'))::bigint) RETURNING "products".*), "products" AS (SELECT * FROM "products_c" UNION ALL SELECT * FROM "products_d") SELECT jsonb_build_object('user', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "users_0"."id" AS "id", "users_0"."full_name" AS "full_name", "users_0"."email" AS "email", "__sj_1"."json" AS "product" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" LIMIT ('1') :: integer) AS "users_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "products_1"."id" AS "id", "products_1"."name" AS "name", "products_1"."price" AS "price" FROM (SELECT "products"."id", "products"."name", "products"."price" FROM "products" WHERE ((("products"."user_id") = ("users_0"."id"))) LIMIT ('1') :: integer) AS "products_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileUpdate/nestedUpdateOneToOneWithConnect
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "_x_users" AS (SELECT "id" FROM "_sg_input" i,"users" WHERE "users"."id"= ((i.j->'user'->'connect'->>'id'))::bigint AND "users"."email"= ((i.j->'user'->'connect'->>'email'))::character varying LIMIT 1), "products" AS (UPDATE "products" SET ("name", "price", "user_id") = (SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'price' AS numeric(7,2)), "_x_users"."id" FROM "_sg_input" i", "_x_users)  WHERE (("products"."id") =  '{{product_id}}' :: bigint) RETURNING "products".*) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "__sj_1"."json" AS "user" FROM (SELECT "products"."id", "products"."name", "products"."user_id" FROM "products" LIMIT ('1') :: integer) AS "products_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "users_1"."id" AS "id", "users_1"."full_name" AS "full_name", "users_1"."email" AS "email" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" WHERE ((("users"."id") = ("products_0"."user_id"))) LIMIT ('1') :: integer) AS "users_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "_x_users" AS (SELECT "id" FROM "_sg_input" i,"users" WHERE "users"."email"= ((i.j->'user'->'connect'->>'email'))::character varying AND "users"."id"= ((i.j->'user'->'connect'->>'id'))::bigint LIMIT 1), "products" AS (UPDATE "products" SET ("name", "price", "user_id") = (SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'price' AS numeric(7,2)), "_x_users"."id" FROM "_sg_input" i", "_x_users)  WHERE (("products"."id") =  '{{product_id}}' :: bigint) RETURNING "products".*) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "__sj_1"."json" AS "user" FROM (SELECT "products"."id", "products"."name", "products"."user_id" FROM "products" LIMIT ('1') :: integer) AS "products_0" LEFT OUTER JOIN LATERAL (SELECT to_jsonb("__sr_1".*) AS "json"FROM (SELECT "users_1"."id" AS "id", "users_1"."full_name" AS "full_name", "users_1"."email" AS "email" FROM (SELECT "users"."id", "users"."full_name", "users"."email" FROM "users" WHERE ((("users"."id") = ("products_0"."user_id"))) LIMIT ('1') :: integer) AS "users_1") AS "__sr_1") AS "__sj_1" ON ('true')) AS "__sr_0") AS "__sj_0"
+=== RUN   TestCompileUpdate/nestedUpdateOneToOneWithDisconnect
+WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "_x_users" AS (SELECT * FROM (VALUES(NULL::bigint)) AS LOOKUP("id")), "products" AS (UPDATE "products" SET ("name", "price", "user_id") = (SELECT CAST( i.j ->>'name' AS character varying), CAST( i.j ->>'price' AS numeric(7,2)), "_x_users"."id" FROM "_sg_input" i", "_x_users)  WHERE (("products"."id") =  '{{id}}' :: bigint) RETURNING "products".*) SELECT jsonb_build_object('product', "__sj_0"."json") as "__root" FROM (SELECT to_jsonb("__sr_0".*) AS "json"FROM (SELECT "products_0"."id" AS "id", "products_0"."name" AS "name", "products_0"."user_id" AS "user_id" FROM (SELECT "products"."id", "products"."name", "products"."user_id" FROM "products" LIMIT ('1') :: integer) AS "products_0") AS "__sr_0") AS "__sj_0"
+--- PASS: TestCompileUpdate (0.04s)
+    --- PASS: TestCompileUpdate/singleUpdate (0.00s)
+    --- PASS: TestCompileUpdate/simpleUpdateWithPresets (0.00s)
+    --- PASS: TestCompileUpdate/nestedUpdateManyToMany (0.01s)
+    --- PASS: TestCompileUpdate/nestedUpdateOneToMany (0.01s)
+    --- PASS: TestCompileUpdate/nestedUpdateOneToOne (0.00s)
+    --- PASS: TestCompileUpdate/nestedUpdateOneToManyWithConnect (0.00s)
+    --- PASS: TestCompileUpdate/nestedUpdateOneToOneWithConnect (0.01s)
+    --- PASS: TestCompileUpdate/nestedUpdateOneToOneWithDisconnect (0.00s)
+PASS
+ok  	github.com/dosco/super-graph/core/internal/psql	0.154s
+=== RUN   TestCompile1
+--- PASS: TestCompile1 (0.00s)
+=== RUN   TestCompile2
+--- PASS: TestCompile2 (0.00s)
+=== RUN   TestCompile3
+--- PASS: TestCompile3 (0.00s)
+=== RUN   TestInvalidCompile1
+--- PASS: TestInvalidCompile1 (0.00s)
+=== RUN   TestInvalidCompile2
+--- PASS: TestInvalidCompile2 (0.00s)
+=== RUN   TestEmptyCompile
+--- PASS: TestEmptyCompile (0.00s)
+=== RUN   TestInvalidPostfixCompile
+--- PASS: TestInvalidPostfixCompile (0.00s)
+=== RUN   TestGetQType
+=== RUN   TestGetQType/query
+=== RUN   TestGetQType/mutation
+=== RUN   TestGetQType/default_query
+=== RUN   TestGetQType/default_query_with_comment
+=== RUN   TestGetQType/failed_query_with_comment
+--- PASS: TestGetQType (0.00s)
+    --- PASS: TestGetQType/query (0.00s)
+    --- PASS: TestGetQType/mutation (0.00s)
+    --- PASS: TestGetQType/default_query (0.00s)
+    --- PASS: TestGetQType/default_query_with_comment (0.00s)
+    --- PASS: TestGetQType/failed_query_with_comment (0.00s)
+PASS
+ok  	github.com/dosco/super-graph/core/internal/qcode	0.012s
+?   	github.com/dosco/super-graph/core/internal/util	[no test files]
+=== RUN   TestFuzzCrashers
+--- PASS: TestFuzzCrashers (0.00s)
+=== RUN   TestGQLHash1
+--- PASS: TestGQLHash1 (0.00s)
+=== RUN   TestGQLHash2
+--- PASS: TestGQLHash2 (0.00s)
+=== RUN   TestGQLHash3
+--- PASS: TestGQLHash3 (0.00s)
+=== RUN   TestGQLHash4
+--- PASS: TestGQLHash4 (0.00s)
+=== RUN   TestGQLHashWithVars1
+--- PASS: TestGQLHashWithVars1 (0.00s)
+=== RUN   TestGQLHashWithVars2
+--- PASS: TestGQLHashWithVars2 (0.00s)
+PASS
+ok  	github.com/dosco/super-graph/internal/serv	0.033s
+?   	github.com/dosco/super-graph/internal/serv/internal/auth	[no test files]
+testing: warning: no tests to run
+PASS
+ok  	github.com/dosco/super-graph/internal/serv/internal/migrate	0.011s [no tests to run]
+=== RUN   TestRailsEncryptedSession1
+--- PASS: TestRailsEncryptedSession1 (0.01s)
+=== RUN   TestRailsEncryptedSession52
+--- PASS: TestRailsEncryptedSession52 (0.00s)
+=== RUN   TestRailsJsonSession
+--- PASS: TestRailsJsonSession (0.00s)
+=== RUN   TestRailsMarshaledSession
+--- PASS: TestRailsMarshaledSession (0.00s)
+PASS
+ok  	github.com/dosco/super-graph/internal/serv/internal/rails	0.023s
+=== RUN   TestFuzzCrashers
+--- PASS: TestFuzzCrashers (0.00s)
+=== RUN   TestGet
+--- PASS: TestGet (0.00s)
+=== RUN   TestGet1
+--- PASS: TestGet1 (0.00s)
+=== RUN   TestGet2
+--- PASS: TestGet2 (0.00s)
+=== RUN   TestGet3
+--- PASS: TestGet3 (0.00s)
+=== RUN   TestGet4
+--- PASS: TestGet4 (0.00s)
+=== RUN   TestValue
+--- PASS: TestValue (0.00s)
+=== RUN   TestFilter1
+--- PASS: TestFilter1 (0.00s)
+=== RUN   TestFilter2
+--- PASS: TestFilter2 (0.00s)
+=== RUN   TestStrip
+--- PASS: TestStrip (0.00s)
+=== RUN   TestValidateTrue
+--- PASS: TestValidateTrue (0.00s)
+=== RUN   TestValidateFalse
+--- PASS: TestValidateFalse (0.00s)
+=== RUN   TestReplace
+--- PASS: TestReplace (0.00s)
+=== RUN   TestReplaceEmpty
+--- PASS: TestReplaceEmpty (0.00s)
+=== RUN   TestKeys1
+--- PASS: TestKeys1 (0.00s)
+=== RUN   TestKeys2
+--- PASS: TestKeys2 (0.00s)
+=== RUN   TestKeys3
+--- PASS: TestKeys3 (0.00s)
+PASS
+ok  	github.com/dosco/super-graph/jsn	0.014s

core/internal/psql/update.go

@@ -0,0 +1,223 @@
+//nolint:errcheck
+package psql
+
+import (
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/dosco/super-graph/core/internal/qcode"
+	"github.com/dosco/super-graph/core/internal/util"
+)
+
+func (c *compilerContext) renderUpdate(qc *qcode.QCode, w io.Writer,
+	vars Variables, ti *DBTableInfo) (uint32, error) {
+
+	update, ok := vars[qc.ActionVar]
+	if !ok {
+		return 0, fmt.Errorf("variable '%s' not !defined", qc.ActionVar)
+	}
+	if len(update) == 0 {
+		return 0, fmt.Errorf("variable '%s' is empty", qc.ActionVar)
+	}
+
+	io.WriteString(c.w, `WITH "_sg_input" AS (SELECT '{{`)
+	io.WriteString(c.w, qc.ActionVar)
+	io.WriteString(c.w, `}}' :: json AS j)`)
+
+	st := util.NewStack()
+	st.Push(kvitem{_type: itemUpdate, key: ti.Name, val: update, ti: ti})
+
+	for {
+		if st.Len() == 0 {
+			break
+		}
+		if update[0] == '[' && st.Len() > 1 {
+			return 0, errors.New("Nested bulk update not supported")
+		}
+		intf := st.Pop()
+
+		switch item := intf.(type) {
+		case kvitem:
+			if err := c.handleKVItem(st, item); err != nil {
+				return 0, err
+			}
+
+		case renitem:
+			var err error
+
+			// if w := qc.Selects[0].Where; w != nil && w.Op == qcode.OpFalse {
+			// 	io.WriteString(c.w, ` WHERE false`)
+			// }
+
+			switch item._type {
+			case itemUpdate:
+				err = c.renderUpdateStmt(w, qc, item)
+			case itemConnect:
+				err = c.renderConnectStmt(qc, w, item)
+			case itemDisconnect:
+				err = c.renderDisconnectStmt(qc, w, item)
+			case itemUnion:
+				err = c.renderUnionStmt(w, item)
+			}
+
+			if err != nil {
+				return 0, err
+			}
+
+		}
+	}
+	io.WriteString(c.w, ` `)
+
+	return 0, nil
+}
+
+func (c *compilerContext) renderUpdateStmt(w io.Writer, qc *qcode.QCode, item renitem) error {
+	ti := item.ti
+	jt := item.data
+	sk := nestedUpdateRelColumnsMap(item.kvitem)
+
+	io.WriteString(c.w, `, `)
+	renderCteName(c.w, item.kvitem)
+	io.WriteString(c.w, ` AS (`)
+
+	io.WriteString(w, `UPDATE `)
+	quoted(w, ti.Name)
+	io.WriteString(w, ` SET (`)
+	renderInsertUpdateColumns(w, qc, jt, ti, sk, false)
+	renderNestedUpdateRelColumns(w, item.kvitem, false)
+
+	io.WriteString(w, `) = (SELECT `)
+	renderInsertUpdateColumns(w, qc, jt, ti, sk, true)
+	renderNestedUpdateRelColumns(w, item.kvitem, true)
+
+	io.WriteString(w, ` FROM "_sg_input" i`)
+	renderNestedUpdateRelTables(w, item.kvitem)
+	io.WriteString(w, `) `)
+
+	if item.id != 0 {
+		// Render sql to set id values if child-to-parent
+		// relationship is one-to-one
+		rel := item.relCP
+
+		io.WriteString(w, `FROM `)
+		quoted(w, rel.Right.Table)
+
+		io.WriteString(w, ` WHERE ((`)
+		colWithTable(w, rel.Left.Table, rel.Left.Col)
+		io.WriteString(w, `) = (`)
+		colWithTable(w, rel.Right.Table, rel.Right.Col)
+		io.WriteString(w, `)`)
+
+		if item.relPC.Type == RelOneToMany {
+			if conn, ok := item.data["where"]; ok {
+				io.WriteString(w, ` AND `)
+				renderWhereFromJSON(w, item.kvitem, "where", conn)
+			} else if conn, ok := item.data["_where"]; ok {
+				io.WriteString(w, ` AND `)
+				renderWhereFromJSON(w, item.kvitem, "_where", conn)
+			}
+		}
+		io.WriteString(w, `)`)
+
+	} else {
+		if qc.Selects[0].Where != nil {
+			io.WriteString(w, ` WHERE `)
+			if err := c.renderWhere(&qc.Selects[0], ti); err != nil {
+				return err
+			}
+		}
+	}
+
+	io.WriteString(w, ` RETURNING `)
+	quoted(w, ti.Name)
+	io.WriteString(w, `.*)`)
+
+	return nil
+}
+
+func nestedUpdateRelColumnsMap(item kvitem) map[string]struct{} {
+	sk := make(map[string]struct{}, len(item.items))
+
+	for _, v := range item.items {
+		if v._ctype > 0 && v.relCP.Type == RelOneToMany {
+			sk[v.relCP.Right.Col] = struct{}{}
+		}
+	}
+
+	return sk
+}
+
+func renderNestedUpdateRelColumns(w io.Writer, item kvitem, values bool) error {
+	// Render child foreign key columns if child-to-parent
+	// relationship is one-to-many
+	for _, v := range item.items {
+		if v._ctype > 0 && v.relCP.Type == RelOneToMany {
+			if values {
+				// if v.relCP.Right.Array {
+				// 	io.WriteString(w, `array_diff(`)
+				// 	colWithTable(w, v.relCP.Right.Table, v.relCP.Right.Col)
+				// 	io.WriteString(w, `, `)
+				// }
+
+				if v._ctype > 0 {
+					io.WriteString(w, `"_x_`)
+					io.WriteString(w, v.relCP.Left.Table)
+					io.WriteString(w, `".`)
+					quoted(w, v.relCP.Left.Col)
+				} else {
+					colWithTable(w, v.relCP.Left.Table, v.relCP.Left.Col)
+				}
+
+				// if v.relCP.Right.Array {
+				// 	io.WriteString(w, `)`)
+				// }
+			} else {
+
+				quoted(w, v.relCP.Right.Col)
+
+			}
+		}
+	}
+
+	return nil
+}
+
+func renderNestedUpdateRelTables(w io.Writer, item kvitem) error {
+	// Render tables needed to set values if child-to-parent
+	// relationship is one-to-many
+	for _, v := range item.items {
+		if v._ctype > 0 && v.relCP.Type == RelOneToMany {
+			io.WriteString(w, `", `)
+			io.WriteString(w, `"_x_`)
+			io.WriteString(w, v.relCP.Left.Table)
+		}
+	}
+
+	return nil
+}
+
+func (c *compilerContext) renderDelete(qc *qcode.QCode, w io.Writer,
+	vars Variables, ti *DBTableInfo) (uint32, error) {
+	root := &qc.Selects[0]
+
+	io.WriteString(c.w, `WITH `)
+	quoted(c.w, ti.Name)
+
+	io.WriteString(c.w, ` AS (DELETE FROM `)
+	quoted(c.w, ti.Name)
+	io.WriteString(c.w, ` WHERE `)
+
+	if root.Where == nil {
+		return 0, errors.New("'where' clause missing in delete mutation")
+	}
+
+	if err := c.renderWhere(root, ti); err != nil {
+		return 0, err
+	}
+
+	io.WriteString(w, ` RETURNING `)
+	quoted(w, ti.Name)
+	io.WriteString(w, `.*) `)
+	return 0, nil
+}

core/internal/psql/update_test.go

@@ -0,0 +1,258 @@
+package psql
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func singleUpdate(t *testing.T) {
+	gql := `mutation {
+		product(id: $id, update: $update, where: { id: { eq: 1 } }) {
+			id
+			name
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"update": json.RawMessage(` { "name": "my_name", "description": "my_desc"  }`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "anon")
+}
+
+func simpleUpdateWithPresets(t *testing.T) {
+	gql := `mutation {
+		product(update: $data) {
+			id
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{"name": "Apple", "price": 1.25}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "user")
+}
+
+func nestedUpdateManyToMany(t *testing.T) {
+	gql := `mutation {
+		purchase(update: $data, id: $id) {
+			sale_type
+			quantity
+			due_date
+			customer {
+				id
+				full_name
+				email
+			}
+			product {
+				id
+				name
+				price
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(` {
+			"sale_type": "bought",
+			"quantity": 5,
+			"due_date": "now",
+			"customer": {
+				"email": "thedude@rug.com",
+				"full_name": "The Dude"
+			},
+			"product": {
+				"name": "Apple",
+				"price": 1.25
+			}
+		}
+	`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func nestedUpdateOneToMany(t *testing.T) {
+	gql := `mutation {
+		user(update: $data, where: { id: { eq: 8 } }) {
+			id
+			full_name
+			email
+			product {
+				id
+				name
+				price
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{
+			"email": "thedude@rug.com",
+			"full_name": "The Dude",
+			"created_at": "now",
+			"updated_at": "now",
+			"product": {
+				"where": {
+					"id": 2
+				},
+				"name": "Apple",
+				"price": 1.25,
+				"created_at": "now",
+				"updated_at": "now"
+			}
+		}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func nestedUpdateOneToOne(t *testing.T) {
+	gql := `mutation {
+		product(update: $data, id: $id) {
+			id
+			name
+			user {
+				id
+				full_name
+				email
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{
+			"name": "Apple",
+			"price": 1.25,
+			"created_at": "now",
+			"updated_at": "now",
+			"user": {
+				"email": "thedude@rug.com"
+			}
+		}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+
+}
+
+func nestedUpdateOneToManyWithConnect(t *testing.T) {
+	gql := `mutation {
+		user(update: $data, id: $id) {
+			id
+			full_name
+			email
+			product {
+				id
+				name
+				price
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{
+			"email": "thedude@rug.com",
+			"full_name": "The Dude",
+			"created_at": "now",
+			"updated_at": "now",
+			"product": {
+				"connect": { "id": 7 },
+				"disconnect": { "id": 8 }
+			}
+		}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func nestedUpdateOneToOneWithConnect(t *testing.T) {
+	gql := `mutation {
+		product(update: $data, id: $product_id) {
+			id
+			name
+			user {
+				id
+				full_name
+				email
+			}
+		}
+	}`
+
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{
+			"name": "Apple",
+			"price": 1.25,
+			"user": {
+				"connect": { "id": 5, "email": "test@test.com" }
+			}
+		}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+func nestedUpdateOneToOneWithDisconnect(t *testing.T) {
+	gql := `mutation {
+		product(update: $data, id: $id) {
+			id
+			name
+			user_id
+		}
+	}`
+	vars := map[string]json.RawMessage{
+		"data": json.RawMessage(`{
+			"name": "Apple",
+			"price": 1.25,
+			"user": {
+				"disconnect": { "id": 5 }
+			}
+		}`),
+	}
+
+	compileGQLToPSQL(t, gql, vars, "admin")
+}
+
+// func nestedUpdateOneToOneWithDisconnectArray(t *testing.T) {
+// 	gql := `mutation {
+// 		product(update: $data, id: 2) {
+// 			id
+// 			name
+// 			user_id
+// 		}
+// 	}`
+
+// 	sql := `WITH "_sg_input" AS (SELECT '{{data}}' :: json AS j), "users" AS (SELECT * FROM (VALUES(NULL::bigint)) AS LOOKUP("id")), "products" AS (UPDATE "products" SET ("name", "price", "user_id") = (SELECT "t"."name", "t"."price", "users"."id" FROM "_sg_input" i, "users", json_populate_record(NULL::products, i.j) t) WHERE (("products"."id") = 2) RETURNING "products".*) SELECT json_object_agg('product', 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"."user_id" AS "user_id") AS "json_row_0")) AS "json_0" FROM (SELECT "products"."id", "products"."name", "products"."user_id" FROM "products" LIMIT ('1') :: integer) AS "products_0" LIMIT ('1') :: integer) AS "sel_0"`
+
+// 	vars := map[string]json.RawMessage{
+// 		"data": json.RawMessage(`{
+// 			"name": "Apple",
+// 			"price": 1.25,
+// 			"user": {
+// 				"disconnect": { "id": 5 }
+// 			}
+// 		}`),
+// 	}
+
+// 	resSQL, err := compileGQLToPSQL(gql, vars, "admin")
+// 	if err != nil {
+// 		t.Fatal(err)
+// 	}
+
+// 	if string(resSQL) != sql {
+// 		t.Fatal(errNotExpected)
+// 	}
+// }
+
+func TestCompileUpdate(t *testing.T) {
+	t.Run("singleUpdate", singleUpdate)
+	t.Run("simpleUpdateWithPresets", simpleUpdateWithPresets)
+	t.Run("nestedUpdateManyToMany", nestedUpdateManyToMany)
+	t.Run("nestedUpdateOneToMany", nestedUpdateOneToMany)
+	t.Run("nestedUpdateOneToOne", nestedUpdateOneToOne)
+	t.Run("nestedUpdateOneToManyWithConnect", nestedUpdateOneToManyWithConnect)
+	t.Run("nestedUpdateOneToOneWithConnect", nestedUpdateOneToOneWithConnect)
+	t.Run("nestedUpdateOneToOneWithDisconnect", nestedUpdateOneToOneWithDisconnect)
+	//t.Run("nestedUpdateOneToOneWithDisconnectArray", nestedUpdateOneToOneWithDisconnectArray)
+}

core/internal/qcode/config.go

@@ -8,7 +8,6 @@ import (
 
 type Config struct {
 	Blocklist []string
-	KeepArgs  bool
 }
 
 type QueryConfig struct {
@@ -46,6 +45,7 @@ type trval struct {
 	query struct {
 		limit   string
 		fil     *Exp
+		filNU   bool
 		cols    map[string]struct{}
 		disable struct {
 			funcs bool
@@ -54,6 +54,7 @@ type trval struct {
 
 	insert struct {
 		fil    *Exp
+		filNU  bool
 		cols   map[string]struct{}
 		psmap  map[string]string
 		pslist []string
@@ -61,14 +62,16 @@ type trval struct {
 
 	update struct {
 		fil    *Exp
+		filNU  bool
 		cols   map[string]struct{}
 		psmap  map[string]string
 		pslist []string
 	}
 
 	delete struct {
-		fil  *Exp
-		cols map[string]struct{}
+		fil   *Exp
+		filNU bool
+		cols  map[string]struct{}
 	}
 }
 
@@ -81,7 +84,7 @@ func (trv *trval) allowedColumns(qt QType) map[string]struct{} {
 	case QTUpdate:
 		return trv.update.cols
 	case QTDelete:
-		return trv.insert.cols
+		return trv.delete.cols
 	case QTUpsert:
 		return trv.insert.cols
 	}
@@ -89,21 +92,21 @@ func (trv *trval) allowedColumns(qt QType) map[string]struct{} {
 	return nil
 }
 
-func (trv *trval) filter(qt QType) *Exp {
+func (trv *trval) filter(qt QType) (*Exp, bool) {
 	switch qt {
 	case QTQuery:
-		return trv.query.fil
+		return trv.query.fil, trv.query.filNU
 	case QTInsert:
-		return trv.insert.fil
+		return trv.insert.fil, trv.insert.filNU
 	case QTUpdate:
-		return trv.update.fil
+		return trv.update.fil, trv.update.filNU
 	case QTDelete:
-		return trv.delete.fil
+		return trv.delete.fil, trv.delete.filNU
 	case QTUpsert:
-		return trv.insert.fil
+		return trv.insert.fil, trv.insert.filNU
 	}
 
-	return nil
+	return nil, false
 }
 
 func listToMap(list []string) map[string]struct{} {
@@ -116,7 +119,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)

core/internal/qcode/fuzz.go

@@ -4,6 +4,12 @@ package qcode
 
 // FuzzerEntrypoint for Fuzzbuzz
 func Fuzz(data []byte) int {
+	qt := GetQType(string(data))
+
+	if qt > QTUpsert {
+		panic("qt > QTUpsert")
+	}
+
 	qcompile, _ := NewCompiler(Config{})
 	_, err := qcompile.Compile(data, "user")
 	if err != nil {

core/internal/qcode/lex.go

@@ -28,10 +28,10 @@ type Pos int
 
 // item represents a token or text string returned from the scanner.
 type item struct {
-	typ  itemType // The type of this item.
-	pos  Pos      // The starting position, in bytes, of this item in the input string.
-	end  Pos      // The ending position, in bytes, of this item in the input string.
-	line uint16   // The line number at the start of this item.
+	_type itemType // The type of this item.
+	pos   Pos      // The starting position, in bytes, of this item in the input string.
+	end   Pos      // The ending position, in bytes, of this item in the input string.
+	line  int16    // The line number at the start of this item.
 }
 
 // itemType identifies the type of lex items.
@@ -87,7 +87,7 @@ type lexer struct {
 	width  Pos    // width of last rune read from input
 	items  []item // array of scanned items
 	itemsA [50]item
-	line   uint16 // 1+number of newlines seen
+	line   int16 // 1+number of newlines seen
 	err    error
 }
 
@@ -137,7 +137,7 @@ func (l *lexer) emit(t itemType) {
 	l.items = append(l.items, item{t, l.start, l.pos, l.line})
 	// Some items contain text internally. If so, count their newlines.
 	switch t {
-	case itemName:
+	case itemStringVal:
 		for i := l.start; i < l.pos; i++ {
 			if l.input[i] == '\n' {
 				l.line++
@@ -147,13 +147,14 @@ func (l *lexer) emit(t itemType) {
 	l.start = l.pos
 }
 
+func (l *lexer) emitL(t itemType) {
+	s, e := l.current()
+	lowercase(l.input, s, e)
+	l.emit(t)
+}
+
 // ignore skips over the pending input before this point.
 func (l *lexer) ignore() {
-	for i := l.start; i < l.pos; i++ {
-		if l.input[i] == '\n' {
-			l.line++
-		}
-	}
 	l.start = l.pos
 }
 
@@ -211,7 +212,7 @@ func lex(l *lexer, input []byte) error {
 
 	l.run()
 
-	if last := l.items[len(l.items)-1]; last.typ == itemError {
+	if last := l.items[len(l.items)-1]; last._type == itemError {
 		return l.err
 	}
 	return nil
@@ -295,19 +296,17 @@ func lexName(l *lexer) stateFn {
 			l.backup()
 			s, e := l.current()
 
-			lowercase(l.input, s, e)
-
 			switch {
 			case equals(l.input, s, e, queryToken):
-				l.emit(itemQuery)
+				l.emitL(itemQuery)
 			case equals(l.input, s, e, mutationToken):
-				l.emit(itemMutation)
+				l.emitL(itemMutation)
 			case equals(l.input, s, e, subscriptionToken):
-				l.emit(itemSub)
+				l.emitL(itemSub)
 			case equals(l.input, s, e, trueToken):
-				l.emit(itemBoolVal)
+				l.emitL(itemBoolVal)
 			case equals(l.input, s, e, falseToken):
-				l.emit(itemBoolVal)
+				l.emitL(itemBoolVal)
 			default:
 				l.emit(itemName)
 			}
@@ -432,10 +431,10 @@ func lowercase(b []byte, s Pos, e Pos) {
 	}
 }
 
-func (i *item) String() string {
+func (i item) String() string {
 	var v string
 
-	switch i.typ {
+	switch i._type {
 	case itemEOF:
 		v = "EOF"
 	case itemError:
@@ -461,7 +460,7 @@ func (i *item) String() string {
 	case itemStringVal:
 		v = "string"
 	}
-	return fmt.Sprintf("%s", v)
+	return v
 }
 
 /*

core/internal/qcode/parse.go

@@ -6,7 +6,7 @@ import (
 	"sync"
 	"unsafe"
 
-	"github.com/dosco/super-graph/util"
+	"github.com/dosco/super-graph/core/internal/util"
 )
 
 var (
@@ -16,8 +16,8 @@ var (
 type parserType int32
 
 const (
-	maxFields = 100
-	maxArgs   = 10
+	maxFields = 1200
+	maxArgs   = 25
 )
 
 const (
@@ -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
 }
 
@@ -157,12 +156,19 @@ func parseSelectionSet(gql []byte) (*Operation, error) {
 		return nil, err
 	}
 
-	lexPool.Put(l)
-
-	if err != nil {
-		return nil, err
+	if p.peek(itemObjClose) {
+		p.ignore()
+	} else {
+		return nil, fmt.Errorf("operation missing closing '}'")
 	}
 
+	if !p.peek(itemEOF) {
+		p.ignore()
+		return nil, fmt.Errorf("invalid '%s' found after closing '}'", p.current())
+	}
+
+	lexPool.Put(l)
+
 	return op, err
 }
 
@@ -170,7 +176,7 @@ func (p *Parser) next() item {
 	n := p.pos + 1
 	if n >= len(p.items) {
 		p.err = errEOT
-		return item{typ: itemEOF}
+		return item{_type: itemEOF}
 	}
 	p.pos = n
 	return p.items[p.pos]
@@ -185,25 +191,21 @@ 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) current() string {
+	item := p.items[p.pos]
+	return b2s(p.input[item.pos:item.end])
 }
 
 func (p *Parser) peek(types ...itemType) bool {
 	n := p.pos + 1
-	if p.items[n].typ == itemEOF {
-		return false
-	}
+	// if p.items[n]._type == itemEOF {
+	// 	return false
+	// }
 	if n >= len(p.items) {
 		return false
 	}
 	for i := 0; i < len(types); i++ {
-		if p.items[n].typ == types[i] {
+		if p.items[n]._type == types[i] {
 			return true
 		}
 	}
@@ -220,7 +222,7 @@ func (p *Parser) parseOp() (*Operation, error) {
 	op := opPool.Get().(*Operation)
 	op.Reset()
 
-	switch item.typ {
+	switch item._type {
 	case itemQuery:
 		op.Type = opQuery
 	case itemMutation:
@@ -240,7 +242,8 @@ func (p *Parser) parseOp() (*Operation, error) {
 
 	if p.peek(itemArgsOpen) {
 		p.ignore()
-		op.Args, err = p.parseArgs(op.Args)
+
+		op.Args, err = p.parseOpParams(op.Args)
 		if err != nil {
 			return nil, err
 		}
@@ -250,7 +253,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 +278,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
 		}
 
@@ -302,11 +305,12 @@ func (p *Parser) parseFields(fields []Field) ([]Field, error) {
 
 			if st.Len() == 0 {
 				break
+			} else {
+				continue
 			}
-			continue
 		}
 
-		if p.peek(itemName) == false {
+		if !p.peek(itemName) {
 			return nil, errors.New("expecting an alias or field name")
 		}
 
@@ -316,6 +320,8 @@ func (p *Parser) parseFields(fields []Field) ([]Field, error) {
 		f.Args = f.argsA[:0]
 		f.Children = f.childrenA[:0]
 
+		// Parse the inside of the the fields () parentheses
+		// in short parse the args like id, where, etc
 		if err := p.parseField(f); err != nil {
 			return nil, err
 		}
@@ -328,9 +334,18 @@ func (p *Parser) parseFields(fields []Field) ([]Field, error) {
 			f.ParentID = -1
 		}
 
+		// The first opening curley brackets after this
+		// comes the columns or child fields
 		if p.peek(itemObjOpen) {
 			p.ignore()
 			st.Push(f.ID)
+
+		} else if p.peek(itemObjClose) {
+			if st.Len() == 0 {
+				break
+			} else {
+				continue
+			}
 		}
 	}
 
@@ -339,17 +354,19 @@ func (p *Parser) parseFields(fields []Field) ([]Field, error) {
 
 func (p *Parser) parseField(f *Field) error {
 	var err error
-	f.Name = p.val(p.next())
+	v := p.next()
 
 	if p.peek(itemColon) {
 		p.ignore()
 
 		if p.peek(itemName) {
-			f.Alias = f.Name
-			f.Name = p.val(p.next())
+			f.Alias = p.val(v)
+			f.Name = p.vall(p.next())
 		} else {
 			return errors.New("expecting an aliased field name")
 		}
+	} else {
+		f.Name = p.vall(v)
 	}
 
 	if p.peek(itemArgsOpen) {
@@ -362,6 +379,22 @@ func (p *Parser) parseField(f *Field) error {
 	return nil
 }
 
+func (p *Parser) parseOpParams(args []Arg) ([]Arg, error) {
+	for {
+		if len(args) >= maxArgs {
+			return nil, fmt.Errorf("too many args (max %d)", maxArgs)
+		}
+
+		if p.peek(itemArgsClose) {
+			p.ignore()
+			break
+		}
+		p.next()
+	}
+
+	return args, nil
+}
+
 func (p *Parser) parseArgs(args []Arg) ([]Arg, error) {
 	var err error
 
@@ -374,13 +407,14 @@ 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 +457,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 +475,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 +494,7 @@ func (p *Parser) parseObj() (*Node, error) {
 		nodes = append(nodes, node)
 	}
 
-	parent.Type = nodeObj
+	parent.Type = NodeObj
 	parent.Children = nodes
 
 	return parent, nil
@@ -481,19 +515,19 @@ func (p *Parser) parseValue() (*Node, error) {
 	node := nodePool.Get().(*Node)
 	node.Reset()
 
-	switch item.typ {
+	switch item._type {
 	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()))
 	}
@@ -506,6 +540,11 @@ func (p *Parser) val(v item) string {
 	return b2s(p.input[v.pos:v.end])
 }
 
+func (p *Parser) vall(v item) string {
+	lowercase(p.input, v.pos, v.end)
+	return b2s(p.input[v.pos:v.end])
+}
+
 func b2s(b []byte) string {
 	return *(*string)(unsafe.Pointer(&b))
 }
@@ -524,24 +563,49 @@ 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)
 }
 
-func FreeNode(n *Node) {
+// type Frees struct {
+// 	n   *Node
+// 	loc int
+// }
+
+// var freeList []Frees
+
+// func FreeNode(n *Node, loc int) {
+// 	j := -1
+
+// 	for i := range freeList {
+// 		if n == freeList[i].n {
+// 			j = i
+// 			break
+// 		}
+// 	}
+
+// 	if j == -1 {
+// 		nodePool.Put(n)
+// 		freeList = append(freeList, Frees{n, loc})
+// 	} else {
+// 		fmt.Printf(">>>>(%d) RE_FREE %d %p %s %s\n", loc, freeList[j].loc, freeList[j].n, n.Name, n.Type)
+// 	}
+// }
+
+func FreeNode(n *Node, loc int) {
 	nodePool.Put(n)
 }

core/internal/qcode/parse_test.go

@@ -7,33 +7,39 @@ 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(`
-	{ product(id: 15) {
+	_, err = qc.Compile([]byte(`
+	query { product(id: 15) {
 			id
 			name
 		} }`), "user")
 
-	if err != nil {
-		t.Fatal(err)
+	if err == nil {
+		t.Fatal(errors.New("this should be an error id must be a variable"))
 	}
 }
 
 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(`
-	query { product(id: 15) {
+	_, err = qc.Compile([]byte(`
+	query { product(id: $id) {
 			id
 			name
 		} }`), "user")
@@ -45,15 +51,18 @@ 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") {
+		product(id: $test, name: "Test") {
 			id
 			name
 		}
@@ -91,6 +100,35 @@ func TestEmptyCompile(t *testing.T) {
 	}
 }
 
+func TestInvalidPostfixCompile(t *testing.T) {
+	gql := `mutation 
+updateThread {
+  thread(update: $data, where: { slug: { eq: $slug } }) {
+    slug
+    title
+    published
+    createdAt : created_at
+    totalVotes : cached_votes_total
+    totalPosts : cached_posts_total
+    vote : thread_vote(where: { user_id: { eq: $user_id } }) {
+     id
+    }
+    topics {
+      slug
+      name
+    }
+	}
+}
+}`
+	qcompile, _ := NewCompiler(Config{})
+	_, err := qcompile.Compile([]byte(gql), "anon")
+
+	if err == nil {
+		t.Fatal(errors.New("expecting an error"))
+	}
+
+}
+
 var gql = []byte(`
 	products(
 		# returns only 30 items

core/internal/qcode/qcode.go

@@ -7,7 +7,7 @@ import (
 	"strings"
 	"sync"
 
-	"github.com/dosco/super-graph/util"
+	"github.com/dosco/super-graph/core/internal/util"
 	"github.com/gobuffalo/flect"
 )
 
@@ -20,6 +20,7 @@ const (
 
 const (
 	QTQuery QType = iota + 1
+	QTMutation
 	QTInsert
 	QTUpdate
 	QTDelete
@@ -38,7 +39,7 @@ type Select struct {
 	ID         int32
 	ParentID   int32
 	Args       map[string]*Node
-	Table      string
+	Name       string
 	FieldName  string
 	Cols       []Column
 	Where      *Exp
@@ -50,6 +51,7 @@ type Select struct {
 	Allowed    map[string]struct{}
 	PresetMap  map[string]string
 	PresetList []string
+	SkipRender bool
 }
 
 type Column struct {
@@ -63,6 +65,7 @@ type Exp struct {
 	Col        string
 	NestedCols []string
 	Type       ValType
+	Table      string
 	Val        string
 	ListType   ValType
 	ListVal    []string
@@ -82,9 +85,19 @@ type OrderBy struct {
 	Order Order
 }
 
+type PagingType int
+
+const (
+	PtOffset PagingType = iota
+	PtForward
+	PtBackward
+)
+
 type Paging struct {
+	Type    PagingType
 	Limit   string
 	Offset  string
+	Cursor  bool
 	NoLimit bool
 }
 
@@ -118,6 +131,8 @@ const (
 	OpEqID
 	OpTsQuery
 	OpFalse
+	OpNotDistinct
+	OpDistinct
 )
 
 type ValType int
@@ -130,6 +145,7 @@ const (
 	ValList
 	ValVar
 	ValNone
+	ValRef
 )
 
 type AggregrateOp int
@@ -156,7 +172,6 @@ const (
 type Compiler struct {
 	tr map[string]map[string]*trval
 	bl map[string]struct{}
-	ka bool
 }
 
 var expPool = sync.Pool{
@@ -164,7 +179,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))
 
@@ -182,12 +197,19 @@ func NewCompiler(c Config) (*Compiler, error) {
 	return co, nil
 }
 
+func NewFilter() *Exp {
+	ex := expPool.Get().(*Exp)
+	ex.Reset()
+
+	return ex
+}
+
 func (com *Compiler) AddRole(role, table string, trc TRConfig) error {
 	var err error
 	trv := &trval{}
 
 	// query config
-	trv.query.fil, err = compileFilter(trc.Query.Filters)
+	trv.query.fil, trv.query.filNU, err = compileFilter(trc.Query.Filters)
 	if err != nil {
 		return err
 	}
@@ -198,7 +220,8 @@ func (com *Compiler) AddRole(role, table string, trc TRConfig) error {
 	trv.query.disable.funcs = trc.Query.DisableFunctions
 
 	// insert config
-	if trv.insert.fil, err = compileFilter(trc.Insert.Filters); err != nil {
+	trv.insert.fil, trv.insert.filNU, err = compileFilter(trc.Insert.Filters)
+	if err != nil {
 		return err
 	}
 	trv.insert.cols = listToMap(trc.Insert.Columns)
@@ -206,7 +229,8 @@ func (com *Compiler) AddRole(role, table string, trc TRConfig) error {
 	trv.insert.pslist = mapToList(trv.insert.psmap)
 
 	// update config
-	if trv.update.fil, err = compileFilter(trc.Update.Filters); err != nil {
+	trv.update.fil, trv.update.filNU, err = compileFilter(trc.Update.Filters)
+	if err != nil {
 		return err
 	}
 	trv.update.cols = listToMap(trc.Update.Columns)
@@ -214,7 +238,8 @@ func (com *Compiler) AddRole(role, table string, trc TRConfig) error {
 	trv.update.pslist = mapToList(trv.update.psmap)
 
 	// delete config
-	if trv.delete.fil, err = compileFilter(trc.Delete.Filters); err != nil {
+	trv.delete.fil, trv.delete.filNU, err = compileFilter(trc.Delete.Filters)
+	if err != nil {
 		return err
 	}
 	trv.delete.cols = listToMap(trc.Delete.Columns)
@@ -253,7 +278,6 @@ func (com *Compiler) Compile(query []byte, role string) (*QCode, error) {
 
 func (com *Compiler) compileQuery(qc *QCode, op *Operation, role string) error {
 	id := int32(0)
-	parentID := int32(-1)
 
 	if len(op.Fields) == 0 {
 		return errors.New("invalid graphql no query found")
@@ -275,7 +299,8 @@ func (com *Compiler) compileQuery(qc *QCode, op *Operation, role string) error {
 
 	for i := range op.Fields {
 		if op.Fields[i].ParentID == -1 {
-			st.Push(op.Fields[i].ID)
+			val := op.Fields[i].ID | (-1 << 16)
+			st.Push(val)
 		}
 	}
 
@@ -288,19 +313,26 @@ func (com *Compiler) compileQuery(qc *QCode, op *Operation, role string) error {
 			return fmt.Errorf("selector limit reached (%d)", maxSelectors)
 		}
 
-		fid := st.Pop()
+		val := st.Pop()
+		fid := val & 0xFFFF
+		parentID := (val >> 16) & 0xFFFF
+
 		field := &op.Fields[fid]
 
 		if _, ok := com.bl[field.Name]; ok {
 			continue
 		}
 
+		if field.ParentID == -1 {
+			parentID = -1
+		}
+
 		trv := com.getRole(role, field.Name)
 
 		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,
@@ -324,18 +356,19 @@ 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)
+		err := com.compileArgs(qc, s, field.Args, role)
 		if err != nil {
 			return err
 		}
 
-		// Order is important addFilters must come after compileArgs
+		// 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)
@@ -352,8 +385,8 @@ func (com *Compiler) compileQuery(qc *QCode, op *Operation, role string) error {
 			}
 
 			if len(f.Children) != 0 {
-				parentID = s.ID
-				st.Push(f.ID)
+				val := f.ID | (s.ID << 16)
+				st.Push(val)
 				continue
 			}
 
@@ -378,74 +411,87 @@ 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
+	var nu bool
 
-	if trv, ok := com.tr[role][root.Table]; ok {
-		fil = trv.filter(qc.Type)
+	if trv, ok := com.tr[role][sel.Name]; ok {
+		fil, nu = trv.filter(qc.Type)
+
+	} else if role == "anon" {
+		// Tables not defined under the anon role will not be rendered
+		sel.SkipRender = true
 	}
 
 	if fil == nil {
 		return
 	}
 
+	if nu && role == "anon" {
+		sel.SkipRender = true
+	}
+
 	switch fil.Op {
 	case OpNop:
 	case OpFalse:
-		root.Where = fil
-
+		sel.Where = fil
 	default:
-		if root.Where != nil {
-			ow := root.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
-		} else {
-			root.Where = fil
-		}
+		AddFilter(sel, fil)
 	}
 }
 
-func (com *Compiler) compileArgs(qc *QCode, sel *Select, args []Arg) error {
+func (com *Compiler) compileArgs(qc *QCode, sel *Select, args []Arg, role string) error {
 	var err error
 
-	if com.ka {
-		sel.Args = make(map[string]*Node, len(args))
-	}
+	// don't free this arg either previously done or will be free'd
+	// in the future like in psql
+	var df bool
 
 	for i := range args {
 		arg := &args[i]
 
 		switch arg.Name {
 		case "id":
-			err = com.compileArgID(sel, arg)
+			err, df = com.compileArgID(sel, arg)
+
 		case "search":
-			err = com.compileArgSearch(sel, arg)
+			err, df = com.compileArgSearch(sel, arg)
+
 		case "where":
-			err = com.compileArgWhere(sel, arg)
+			err, df = com.compileArgWhere(sel, arg, role)
+
 		case "orderby", "order_by", "order":
-			err = com.compileArgOrderBy(sel, arg)
+			err, df = com.compileArgOrderBy(sel, arg)
+
 		case "distinct_on", "distinct":
-			err = com.compileArgDistinctOn(sel, arg)
+			err, df = com.compileArgDistinctOn(sel, arg)
+
 		case "limit":
-			err = com.compileArgLimit(sel, arg)
+			err, df = com.compileArgLimit(sel, arg)
+
 		case "offset":
-			err = com.compileArgOffset(sel, arg)
+			err, df = com.compileArgOffset(sel, arg)
+
+		case "first":
+			err, df = com.compileArgFirstLast(sel, arg, PtForward)
+
+		case "last":
+			err, df = com.compileArgFirstLast(sel, arg, PtBackward)
+
+		case "after":
+			err, df = com.compileArgAfterBefore(sel, arg, PtForward)
+
+		case "before":
+			err, df = com.compileArgAfterBefore(sel, arg, PtBackward)
+		}
+
+		if !df {
+			FreeNode(arg.Val, 5)
 		}
 
 		if err != nil {
 			return err
 		}
-
-		if sel.Args != nil {
-			sel.Args[arg.Name] = arg.Val
-		} else {
-			nodePool.Put(arg.Val)
-		}
 	}
 
 	return nil
@@ -453,8 +499,8 @@ 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 {
-			return fmt.Errorf("value for argument '%s' must be a variable", arg.Name)
+		if arg.Val.Type != NodeVar {
+			return argErr(arg.Name, "variable")
 		}
 		qc.ActionVar = arg.Val.Val
 		return nil
@@ -476,8 +522,8 @@ func (com *Compiler) setMutationType(qc *QCode, args []Arg) error {
 		case "delete":
 			qc.Type = QTDelete
 
-			if arg.Val.Type != nodeBool {
-				return fmt.Errorf("value for argument '%s' must be a boolean", arg.Name)
+			if arg.Val.Type != NodeBool {
+				return argErr(arg.Name, "boolen")
 			}
 
 			if arg.Val.Val == "false" {
@@ -490,19 +536,20 @@ func (com *Compiler) setMutationType(qc *QCode, args []Arg) error {
 	return nil
 }
 
-func (com *Compiler) compileArgObj(st *util.Stack, arg *Arg) (*Exp, error) {
-	if arg.Val.Type != nodeObj {
-		return nil, fmt.Errorf("expecting an object")
+func (com *Compiler) compileArgObj(st *util.Stack, arg *Arg) (*Exp, bool, error) {
+	if arg.Val.Type != NodeObj {
+		return nil, false, fmt.Errorf("expecting an object")
 	}
 
 	return com.compileArgNode(st, arg.Val, true)
 }
 
-func (com *Compiler) compileArgNode(st *util.Stack, node *Node, usePool bool) (*Exp, error) {
+func (com *Compiler) compileArgNode(st *util.Stack, node *Node, usePool bool) (*Exp, bool, error) {
 	var root *Exp
+	var needsUser bool
 
 	if node == nil || len(node.Children) == 0 {
-		return nil, errors.New("invalid argument value")
+		return nil, false, errors.New("invalid argument value")
 	}
 
 	pushChild(st, nil, node)
@@ -513,9 +560,10 @@ func (com *Compiler) compileArgNode(st *util.Stack, node *Node, usePool bool) (*
 		}
 
 		intf := st.Pop()
+
 		node, ok := intf.(*Node)
 		if !ok || node == nil {
-			return nil, fmt.Errorf("16: unexpected value %v (%t)", intf, intf)
+			return nil, needsUser, fmt.Errorf("16: unexpected value %v (%t)", intf, intf)
 		}
 
 		// Objects inside a list
@@ -531,126 +579,112 @@ func (com *Compiler) compileArgNode(st *util.Stack, node *Node, usePool bool) (*
 
 		ex, err := newExp(st, node, usePool)
 		if err != nil {
-			return nil, err
+			return nil, needsUser, err
 		}
 
 		if ex == nil {
 			continue
 		}
 
+		if ex.Type == ValVar && ex.Val == "user_id" {
+			needsUser = true
+		}
+
 		if node.exp == nil {
 			root = ex
 		} else {
 			node.exp.Children = append(node.exp.Children, ex)
 		}
-
 	}
 
-	if com.ka {
-		return root, nil
-	}
+	if usePool {
+		st.Push(node)
 
-	pushChild(st, nil, node)
-
-	for {
-		if st.Len() == 0 {
-			break
+		for {
+			if st.Len() == 0 {
+				break
+			}
+			intf := st.Pop()
+			node, ok := intf.(*Node)
+			if !ok || node == nil {
+				continue
+			}
+			for i := range node.Children {
+				st.Push(node.Children[i])
+			}
+			FreeNode(node, 1)
 		}
-		intf := st.Pop()
-		node, _ := intf.(*Node)
-
-		for i := range node.Children {
-			st.Push(node.Children[i])
-		}
-		nodePool.Put(node)
 	}
 
-	return root, nil
+	return root, needsUser, 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
+	}
+
+	if arg.Val.Type != NodeVar {
+		return argErr("id", "variable"), false
 	}
 
 	ex := expPool.Get().(*Exp)
 	ex.Reset()
 
 	ex.Op = OpEqID
+	ex.Type = ValVar
 	ex.Val = arg.Val.Val
 
-	switch arg.Val.Type {
-	case nodeStr:
-		ex.Type = ValStr
-	case nodeInt:
-		ex.Type = ValInt
-	case nodeFloat:
-		ex.Type = ValFloat
-	case nodeVar:
-		ex.Type = ValVar
-	default:
-		return fmt.Errorf("expecting a string, int, float or variable")
-	}
-
 	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) {
+	if arg.Val.Type != NodeVar {
+		return argErr("search", "variable"), false
+	}
+
 	ex := expPool.Get().(*Exp)
 	ex.Reset()
 
 	ex.Op = OpTsQuery
-	ex.Type = ValStr
+	ex.Type = ValVar
 	ex.Val = arg.Val.Val
 
-	if sel.Where != nil {
-		ow := sel.Where
-
-		sel.Where = expPool.Get().(*Exp)
-		sel.Where.Reset()
-		sel.Where.Op = OpAnd
-		sel.Where.Children = sel.Where.childrenA[:2]
-		sel.Where.Children[0] = ex
-		sel.Where.Children[1] = ow
-	} else {
-		sel.Where = ex
+	if sel.Args == nil {
+		sel.Args = make(map[string]*Node)
 	}
-	return nil
+
+	sel.Args[arg.Name] = arg.Val
+	AddFilter(sel, ex)
+
+	return nil, true
 }
 
-func (com *Compiler) compileArgWhere(sel *Select, arg *Arg) error {
+func (com *Compiler) compileArgWhere(sel *Select, arg *Arg, role string) (error, bool) {
 	st := util.NewStack()
 	var err error
 
-	ex, err := com.compileArgObj(st, arg)
+	ex, nu, err := com.compileArgObj(st, arg)
 	if err != nil {
-		return err
+		return err, false
 	}
 
-	if sel.Where != nil {
-		ow := sel.Where
-
-		sel.Where = expPool.Get().(*Exp)
-		sel.Where.Reset()
-		sel.Where.Op = OpAnd
-		sel.Where.Children = sel.Where.childrenA[:2]
-		sel.Where.Children[0] = ex
-		sel.Where.Children[1] = ow
-	} else {
-		sel.Where = ex
+	if nu && role == "anon" {
+		sel.SkipRender = true
 	}
+	AddFilter(sel, ex)
 
-	return nil
+	return nil, true
 }
 
-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()
@@ -668,24 +702,16 @@ 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)
-			}
+			FreeNode(node, 2)
 			continue
 		}
 
-		if node.Type == nodeObj {
-			for i := range node.Children {
-				st.Push(node.Children[i])
-			}
-			if !com.ka {
-				nodePool.Put(node)
-			}
-			continue
+		if node.Type != NodeStr && node.Type != NodeVar {
+			return fmt.Errorf("expecting a string or variable"), false
 		}
 
 		ob := &OrderBy{}
@@ -704,65 +730,85 @@ 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)
-		}
+		FreeNode(node, 3)
 	}
-	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])
-		}
+		FreeNode(node.Children[i], 5)
 	}
 
-	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 argErr("limit", "number"), 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 != NodeVar {
+		return argErr("offset", "variable"), false
 	}
 
 	sel.Paging.Offset = node.Val
-	return nil
+	return nil, false
+}
+
+func (com *Compiler) compileArgFirstLast(sel *Select, arg *Arg, pt PagingType) (error, bool) {
+	node := arg.Val
+
+	if node.Type != NodeInt {
+		return argErr(arg.Name, "number"), false
+	}
+
+	sel.Paging.Type = pt
+	sel.Paging.Limit = node.Val
+
+	return nil, false
+}
+
+func (com *Compiler) compileArgAfterBefore(sel *Select, arg *Arg, pt PagingType) (error, bool) {
+	node := arg.Val
+
+	if node.Type != NodeVar || node.Val != "cursor" {
+		return fmt.Errorf("value for argument '%s' must be a variable named $cursor", arg.Name), false
+	}
+	sel.Paging.Type = pt
+	sel.Paging.Cursor = true
+
+	return nil, false
 }
 
 var zeroTrv = &trval{}
@@ -775,6 +821,27 @@ func (com *Compiler) getRole(role, field string) *trval {
 	}
 }
 
+func AddFilter(sel *Select, fil *Exp) {
+	if sel.Where != nil {
+		ow := sel.Where
+
+		if sel.Where.Op != OpAnd || !sel.Where.doFree {
+			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 {
+			sel.Where.Children = append(sel.Where.Children, fil)
+		}
+
+	} else {
+		sel.Where = fil
+	}
+}
+
 func newExp(st *util.Stack, node *Node, usePool bool) (*Exp, error) {
 	name := node.Name
 	if name[0] == '_' {
@@ -789,6 +856,7 @@ func newExp(st *util.Stack, node *Node, usePool bool) (*Exp, error) {
 	} else {
 		ex = &Exp{doFree: false}
 	}
+
 	ex.Children = ex.childrenA[:0]
 
 	switch name {
@@ -870,6 +938,12 @@ func newExp(st *util.Stack, node *Node, usePool bool) (*Exp, error) {
 	case "is_null":
 		ex.Op = OpIsNull
 		ex.Val = node.Val
+	case "null_eq", "ndis", "not_distinct":
+		ex.Op = OpNotDistinct
+		ex.Val = node.Val
+	case "null_neq", "dis", "distinct":
+		ex.Op = OpDistinct
+		ex.Val = node.Val
 	default:
 		pushChildren(st, node.exp, node)
 		return nil, nil // skip node
@@ -877,17 +951,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)
@@ -901,13 +975,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
 		}
 	}
@@ -920,7 +994,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 {
@@ -932,10 +1006,13 @@ func setWhereColName(ex *Exp, node *Node) {
 			list = append([]string{k}, list...)
 		}
 	}
-	if len(list) == 1 {
+	listlen := len(list)
+
+	if listlen == 1 {
 		ex.Col = list[0]
-	} else if len(list) > 1 {
-		ex.NestedCols = list
+	} else if listlen > 1 {
+		ex.Col = list[listlen-1]
+		ex.NestedCols = list[:listlen]
 	}
 }
 
@@ -962,31 +1039,40 @@ func pushChildren(st *util.Stack, exp *Exp, node *Node) {
 func pushChild(st *util.Stack, exp *Exp, node *Node) {
 	node.Children[0].exp = exp
 	st.Push(node.Children[0])
-
 }
 
-func compileFilter(filter []string) (*Exp, error) {
+func compileFilter(filter []string) (*Exp, bool, error) {
 	var fl *Exp
+	var needsUser bool
+
 	com := &Compiler{}
 	st := util.NewStack()
 
 	if len(filter) == 0 {
-		return &Exp{Op: OpNop, doFree: false}, nil
+		return &Exp{Op: OpNop, doFree: false}, false, nil
 	}
 
 	for i := range filter {
 		if filter[i] == "false" {
-			return &Exp{Op: OpFalse, doFree: false}, nil
+			return &Exp{Op: OpFalse, doFree: false}, false, nil
 		}
 
 		node, err := ParseArgValue(filter[i])
 		if err != nil {
-			return nil, err
+			return nil, false, err
 		}
-		f, err := com.compileArgNode(st, node, false)
+		f, nu, err := com.compileArgNode(st, node, false)
 		if err != nil {
-			return nil, err
+			return nil, false, err
 		}
+		if nu {
+			needsUser = true
+		}
+
+		// TODO: Invalid table names in nested where causes fail silently
+		// returning a nil 'f' this needs to be fixed
+
+		// TODO: Invalid where clauses such as missing op (eg. eq) also fail silently
 
 		if fl == nil {
 			fl = f
@@ -994,7 +1080,7 @@ func compileFilter(filter []string) (*Exp, error) {
 			fl = &Exp{Op: OpAnd, Children: []*Exp{fl, f}, doFree: false}
 		}
 	}
-	return fl, nil
+	return fl, needsUser, nil
 }
 
 func buildPath(a []string) string {
@@ -1081,8 +1167,11 @@ func (t ExpOp) String() string {
 }
 
 func FreeExp(ex *Exp) {
-	//	fmt.Println(">", ex.doFree)
 	if ex.doFree {
 		expPool.Put(ex)
 	}
 }
+
+func argErr(name, ty string) error {
+	return fmt.Errorf("value for argument '%s' must be a %s", name, ty)
+}

core/internal/qcode/utils.go

@@ -0,0 +1,47 @@
+package qcode
+
+func GetQType(gql string) QType {
+	ic := false
+	for i := range gql {
+		b := gql[i]
+		switch {
+		case b == '#':
+			ic = true
+		case b == '\n':
+			ic = false
+		case !ic && b == '{':
+			return QTQuery
+		case !ic && al(b):
+			switch b {
+			case 'm', 'M':
+				return QTMutation
+			case 'q', 'Q':
+				return QTQuery
+			}
+		}
+	}
+	return -1
+}
+
+func al(b byte) bool {
+	return (b >= 'a' && b <= 'z') || (b >= 'A' && b <= 'Z') || (b >= '0' && b <= '9')
+}
+
+func (qt QType) String() string {
+	switch qt {
+	case QTQuery:
+		return "query"
+	case QTMutation:
+		return "mutation"
+	case QTInsert:
+		return "insert"
+	case QTUpdate:
+		return "update"
+	case QTDelete:
+		return "delete"
+	case QTUpsert:
+		return "upsert"
+	}
+
+	return ""
+}

core/internal/qcode/utils_test.go

@@ -0,0 +1,50 @@
+package qcode
+
+import "testing"
+
+func TestGetQType(t *testing.T) {
+	type args struct {
+		gql string
+	}
+	type ts struct {
+		name string
+		args args
+		want QType
+	}
+	tests := []ts{
+		ts{
+			name: "query",
+			args: args{gql: "  query {"},
+			want: QTQuery,
+		},
+		ts{
+			name: "mutation",
+			args: args{gql: "  mutation {"},
+			want: QTMutation,
+		},
+		ts{
+			name: "default query",
+			args: args{gql: "  {"},
+			want: QTQuery,
+		},
+		ts{
+			name: "default query with comment",
+			args: args{gql: `# query is good 
+			{`},
+			want: QTQuery,
+		},
+		ts{
+			name: "failed query with comment",
+			args: args{gql: `# query is good query {`},
+			want: -1,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := GetQType(tt.args.gql); got != tt.want {
+				t.Errorf("GetQType() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

core/prepare.go

@@ -0,0 +1,277 @@
+package core
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha1"
+	"database/sql"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/dosco/super-graph/core/internal/allow"
+	"github.com/dosco/super-graph/core/internal/psql"
+	"github.com/dosco/super-graph/core/internal/qcode"
+	"github.com/valyala/fasttemplate"
+)
+
+type preparedItem struct {
+	sd      *sql.Stmt
+	args    [][]byte
+	st      stmt
+	roleArg bool
+}
+
+func (sg *SuperGraph) initPrepared() error {
+	ct := context.Background()
+
+	if sg.allowList.IsPersist() {
+		return nil
+	}
+	sg.prepared = make(map[string]*preparedItem)
+
+	tx, err := sg.db.BeginTx(ct, nil)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback() //nolint: errcheck
+
+	if err = sg.prepareRoleStmt(tx); err != nil {
+		return fmt.Errorf("prepareRoleStmt: %w", err)
+	}
+
+	if err := tx.Commit(); err != nil {
+		return err
+	}
+
+	success := 0
+
+	list, err := sg.allowList.Load()
+	if err != nil {
+		return err
+	}
+
+	for _, v := range list {
+		if len(v.Query) == 0 {
+			continue
+		}
+
+		err := sg.prepareStmt(v)
+		if err == nil {
+			success++
+			continue
+		}
+
+		// if len(v.Vars) == 0 {
+		// 	logger.Warn().Err(err).Msg(v.Query)
+		// } else {
+		// 	logger.Warn().Err(err).Msgf("%s %s", v.Vars, v.Query)
+		// }
+	}
+
+	// logger.Info().
+	// 	Msgf("Registered %d of %d queries from allow.list as prepared statements",
+	// 		success, len(list))
+
+	return nil
+}
+
+func (sg *SuperGraph) prepareStmt(item allow.Item) error {
+	query := item.Query
+	qb := []byte(query)
+	vars := item.Vars
+
+	qt := qcode.GetQType(query)
+	ct := context.Background()
+
+	tx, err := sg.db.BeginTx(ct, nil)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback() //nolint: errcheck
+
+	switch qt {
+	case qcode.QTQuery:
+		var stmts1 []stmt
+		var err error
+
+		if sg.abacEnabled {
+			stmts1, err = sg.buildMultiStmt(qb, vars)
+		} else {
+			stmts1, err = sg.buildRoleStmt(qb, vars, "user")
+		}
+
+		if err != nil {
+			return err
+		}
+
+		//logger.Debug().Msgf("Prepared statement 'query %s' (user)", item.Name)
+
+		err = sg.prepare(ct, tx, stmts1, stmtHash(item.Name, "user"))
+		if err != nil {
+			return err
+		}
+
+		if sg.anonExists {
+			// logger.Debug().Msgf("Prepared statement 'query %s' (anon)", item.Name)
+
+			stmts2, err := sg.buildRoleStmt(qb, vars, "anon")
+			if err == psql.ErrAllTablesSkipped {
+				return nil
+			}
+			if err != nil {
+				return err
+			}
+
+			err = sg.prepare(ct, tx, stmts2, stmtHash(item.Name, "anon"))
+			if err != nil {
+				return err
+			}
+		}
+
+	case qcode.QTMutation:
+		for _, role := range sg.conf.Roles {
+			// logger.Debug().Msgf("Prepared statement 'mutation %s' (%s)", item.Name, role.Name)
+
+			stmts, err := sg.buildRoleStmt(qb, vars, role.Name)
+
+			if err != nil {
+				// if len(item.Vars) == 0 {
+				// 	logger.Warn().Err(err).Msg(item.Query)
+				// } else {
+				// 	logger.Warn().Err(err).Msgf("%s %s", item.Vars, item.Query)
+				// }
+				continue
+			}
+
+			err = sg.prepare(ct, tx, stmts, stmtHash(item.Name, role.Name))
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	if err := tx.Commit(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (sg *SuperGraph) prepare(ct context.Context, tx *sql.Tx, st []stmt, key string) error {
+	finalSQL, am := processTemplate(st[0].sql)
+
+	sd, err := tx.Prepare(finalSQL)
+	if err != nil {
+		return err
+	}
+
+	sg.prepared[key] = &preparedItem{
+		sd:      sd,
+		args:    am,
+		st:      st[0],
+		roleArg: len(st) > 1,
+	}
+	return nil
+}
+
+// nolint: errcheck
+func (sg *SuperGraph) prepareRoleStmt(tx *sql.Tx) error {
+	var err error
+
+	if !sg.abacEnabled {
+		return nil
+	}
+
+	w := &bytes.Buffer{}
+
+	io.WriteString(w, `SELECT (CASE WHEN EXISTS (`)
+	io.WriteString(w, sg.conf.RolesQuery)
+	io.WriteString(w, `) THEN `)
+
+	io.WriteString(w, `(SELECT (CASE`)
+	for _, role := range sg.conf.Roles {
+		if len(role.Match) == 0 {
+			continue
+		}
+		io.WriteString(w, ` WHEN `)
+		io.WriteString(w, role.Match)
+		io.WriteString(w, ` THEN '`)
+		io.WriteString(w, role.Name)
+		io.WriteString(w, `'`)
+	}
+
+	io.WriteString(w, ` ELSE {{role}} END) FROM (`)
+	io.WriteString(w, sg.conf.RolesQuery)
+	io.WriteString(w, `) AS "_sg_auth_roles_query" LIMIT 1) `)
+	io.WriteString(w, `ELSE 'anon' END) FROM (VALUES (1)) AS "_sg_auth_filler" LIMIT 1; `)
+
+	roleSQL, _ := processTemplate(w.String())
+
+	sg.getRole, err = tx.Prepare(roleSQL)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func processTemplate(tmpl string) (string, [][]byte) {
+	st := struct {
+		vmap map[string]int
+		am   [][]byte
+		i    int
+	}{
+		vmap: make(map[string]int),
+		am:   make([][]byte, 0, 5),
+		i:    0,
+	}
+
+	execFunc := func(w io.Writer, tag string) (int, error) {
+		if n, ok := st.vmap[tag]; ok {
+			return w.Write([]byte(fmt.Sprintf("$%d", n)))
+		}
+		st.am = append(st.am, []byte(tag))
+		st.i++
+		st.vmap[tag] = st.i
+		return w.Write([]byte(fmt.Sprintf("$%d", st.i)))
+	}
+
+	t1 := fasttemplate.New(tmpl, `'{{`, `}}'`)
+	ts1 := t1.ExecuteFuncString(execFunc)
+
+	t2 := fasttemplate.New(ts1, `{{`, `}}`)
+	ts2 := t2.ExecuteFuncString(execFunc)
+
+	return ts2, st.am
+}
+
+func (sg *SuperGraph) initAllowList() error {
+	var ac allow.Config
+	var err error
+
+	if len(sg.conf.AllowListFile) == 0 {
+		sg.conf.UseAllowList = false
+		sg.log.Printf("WRN allow list disabled no file specified")
+	}
+
+	if !sg.conf.UseAllowList {
+		ac = allow.Config{CreateIfNotExists: true, Persist: true}
+	}
+
+	sg.allowList, err = allow.New(sg.conf.AllowListFile, ac)
+	if err != nil {
+		return fmt.Errorf("failed to initialize allow list: %w", err)
+	}
+
+	return nil
+}
+
+// nolint: errcheck
+func stmtHash(name string, role string) string {
+	h := sha1.New()
+	io.WriteString(h, strings.ToLower(name))
+	io.WriteString(h, role)
+	return hex.EncodeToString(h.Sum(nil))
+}

core/remote.go

@@ -0,0 +1,249 @@
+package core
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"net/http"
+	"sync"
+
+	"github.com/cespare/xxhash/v2"
+	"github.com/dosco/super-graph/core/internal/qcode"
+	"github.com/dosco/super-graph/jsn"
+)
+
+func (sg *SuperGraph) execRemoteJoin(st *stmt, data []byte, hdr http.Header) ([]byte, error) {
+	var err error
+
+	sel := st.qc.Selects
+	h := xxhash.New()
+
+	// fetch the field name used within the db response json
+	// that are used to mark insertion points and the mapping between
+	// those field names and their select objects
+	fids, sfmap := sg.parentFieldIds(h, sel, st.skipped)
+
+	// fetch the field values of the marked insertion points
+	// these values contain the id to be used with fetching remote data
+	from := jsn.Get(data, fids)
+	var to []jsn.Field
+
+	switch {
+	case len(from) == 1:
+		to, err = sg.resolveRemote(hdr, h, from[0], sel, sfmap)
+
+	case len(from) > 1:
+		to, err = sg.resolveRemotes(hdr, h, from, sel, sfmap)
+
+	default:
+		return nil, errors.New("something wrong no remote ids found in db response")
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	var ob bytes.Buffer
+
+	err = jsn.Replace(&ob, data, from, to)
+	if err != nil {
+		return nil, err
+	}
+
+	return ob.Bytes(), nil
+}
+
+func (sg *SuperGraph) resolveRemote(
+	hdr http.Header,
+	h *xxhash.Digest,
+	field jsn.Field,
+	sel []qcode.Select,
+	sfmap map[uint64]*qcode.Select) ([]jsn.Field, error) {
+
+	// replacement data for the marked insertion points
+	// key and value will be replaced by whats below
+	toA := [1]jsn.Field{}
+	to := toA[:1]
+
+	// use the json key to find the related Select object
+	k1 := xxhash.Sum64(field.Key)
+
+	s, ok := sfmap[k1]
+	if !ok {
+		return nil, nil
+	}
+	p := sel[s.ParentID]
+
+	// 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.Name, p.Name)
+
+	r, ok := sg.rmap[k2]
+	if !ok {
+		return nil, nil
+	}
+
+	id := jsn.Value(field.Value)
+	if len(id) == 0 {
+		return nil, nil
+	}
+
+	//st := time.Now()
+
+	b, err := r.Fn(hdr, id)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(r.Path) != 0 {
+		b = jsn.Strip(b, r.Path)
+	}
+
+	var ob bytes.Buffer
+
+	if len(s.Cols) != 0 {
+		err = jsn.Filter(&ob, b, colsToList(s.Cols))
+		if err != nil {
+			return nil, err
+		}
+
+	} else {
+		ob.WriteString("null")
+	}
+
+	to[0] = jsn.Field{Key: []byte(s.FieldName), Value: ob.Bytes()}
+	return to, nil
+}
+
+func (sg *SuperGraph) resolveRemotes(
+	hdr http.Header,
+	h *xxhash.Digest,
+	from []jsn.Field,
+	sel []qcode.Select,
+	sfmap map[uint64]*qcode.Select) ([]jsn.Field, error) {
+
+	// replacement data for the marked insertion points
+	// key and value will be replaced by whats below
+	to := make([]jsn.Field, len(from))
+
+	var wg sync.WaitGroup
+	wg.Add(len(from))
+
+	var cerr error
+
+	for i, id := range from {
+
+		// use the json key to find the related Select object
+		k1 := xxhash.Sum64(id.Key)
+
+		s, ok := sfmap[k1]
+		if !ok {
+			return nil, nil
+		}
+		p := sel[s.ParentID]
+
+		// 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.Name, p.Name)
+
+		r, ok := sg.rmap[k2]
+		if !ok {
+			return nil, nil
+		}
+
+		id := jsn.Value(id.Value)
+		if len(id) == 0 {
+			return nil, nil
+		}
+
+		go func(n int, id []byte, s *qcode.Select) {
+			defer wg.Done()
+
+			//st := time.Now()
+
+			b, err := r.Fn(hdr, id)
+			if err != nil {
+				cerr = fmt.Errorf("%s: %s", s.Name, err)
+				return
+			}
+
+			if len(r.Path) != 0 {
+				b = jsn.Strip(b, r.Path)
+			}
+
+			var ob bytes.Buffer
+
+			if len(s.Cols) != 0 {
+				err = jsn.Filter(&ob, b, colsToList(s.Cols))
+				if err != nil {
+					cerr = fmt.Errorf("%s: %s", s.Name, err)
+					return
+				}
+
+			} else {
+				ob.WriteString("null")
+			}
+
+			to[n] = jsn.Field{Key: []byte(s.FieldName), Value: ob.Bytes()}
+		}(i, id, s)
+	}
+	wg.Wait()
+
+	return to, cerr
+}
+
+func (sg *SuperGraph) parentFieldIds(h *xxhash.Digest, sel []qcode.Select, skipped uint32) (
+	[][]byte,
+	map[uint64]*qcode.Select) {
+
+	c := 0
+	for i := range sel {
+		s := &sel[i]
+		if isSkipped(skipped, uint32(s.ID)) {
+			c++
+		}
+	}
+
+	// list of keys (and it's related value) to extract from
+	// the db json response
+	fm := make([][]byte, c)
+
+	// mapping between the above extracted key and a Select
+	// object
+	sm := make(map[uint64]*qcode.Select, c)
+	n := 0
+
+	for i := range sel {
+		s := &sel[i]
+
+		if !isSkipped(skipped, uint32(s.ID)) {
+			continue
+		}
+
+		p := sel[s.ParentID]
+		k := mkkey(h, s.Name, p.Name)
+
+		if r, ok := sg.rmap[k]; ok {
+			fm[n] = r.IDField
+			n++
+
+			k := xxhash.Sum64(r.IDField)
+			sm[k] = s
+		}
+	}
+
+	return fm, sm
+}
+
+func isSkipped(n uint32, pos uint32) bool {
+	return ((n & (1 << pos)) != 0)
+}
+
+func colsToList(cols []qcode.Column) []string {
+	var f []string
+
+	for i := range cols {
+		f = append(f, cols[i].Name)
+	}
+	return f
+}

core/resolve.go

@@ -1,19 +1,14 @@
-package serv
+package core
 
 import (
 	"fmt"
 	"io/ioutil"
 	"net/http"
-	"net/http/httputil"
 	"strings"
 
 	"github.com/cespare/xxhash/v2"
+	"github.com/dosco/super-graph/core/internal/psql"
 	"github.com/dosco/super-graph/jsn"
-	"github.com/dosco/super-graph/psql"
-)
-
-var (
-	rmap map[uint64]*resolvFn
 )
 
 type resolvFn struct {
@@ -22,21 +17,26 @@ type resolvFn struct {
 	Fn      func(h http.Header, id []byte) ([]byte, error)
 }
 
-func initResolvers() error {
-	rmap = make(map[uint64]*resolvFn)
+func (sg *SuperGraph) initResolvers() error {
+	var err error
+	sg.rmap = make(map[uint64]*resolvFn)
 
-	for _, t := range conf.Tables {
-		err := initRemotes(t)
+	for _, t := range sg.conf.Tables {
+		err = sg.initRemotes(t)
 		if err != nil {
-			return err
+			break
 		}
 	}
+
+	if err != nil {
+		return fmt.Errorf("failed to initialize resolvers: %v", err)
+	}
+
 	return nil
 }
 
-func initRemotes(t configTable) error {
+func (sg *SuperGraph) initRemotes(t Table) error {
 	h := xxhash.New()
-	var err error
 
 	for _, r := range t.Remotes {
 		// defines the table column to be used as an id in the
@@ -46,23 +46,22 @@ func initRemotes(t configTable) error {
 		// if no table column specified in the config then
 		// use the primary key of the table as the id
 		if len(idcol) == 0 {
-			idcol, err = pcompile.IDColumn(t.Name)
+			pcol, err := sg.pc.IDColumn(t.Name)
 			if err != nil {
 				return err
 			}
+			idcol = pcol.Key
 		}
 		idk := fmt.Sprintf("__%s_%s", t.Name, idcol)
 
 		// register a relationship between the remote data
 		// and the database table
 
-		val := &psql.DBRel{
-			Type: psql.RelRemote,
-			Col1: idcol,
-			Col2: idk,
-		}
+		val := &psql.DBRel{Type: psql.RelRemote}
+		val.Left.Col = idcol
+		val.Right.Col = idk
 
-		err := pcompile.AddRelationship(strings.ToLower(r.Name), t.Name, val)
+		err := sg.pc.AddRelationship(sanitize(r.Name), t.Name, val)
 		if err != nil {
 			return err
 		}
@@ -83,16 +82,16 @@ func initRemotes(t configTable) error {
 		}
 
 		// index resolver obj by parent and child names
-		rmap[mkkey(h, r.Name, t.Name)] = rf
+		sg.rmap[mkkey(h, r.Name, t.Name)] = rf
 
 		// index resolver obj by IDField
-		rmap[xxhash.Sum64(rf.IDField)] = rf
+		sg.rmap[xxhash.Sum64(rf.IDField)] = rf
 	}
 
 	return nil
 }
 
-func buildFn(r configRemote) func(http.Header, []byte) ([]byte, error) {
+func buildFn(r Remote) func(http.Header, []byte) ([]byte, error) {
 	reqURL := strings.Replace(r.URL, "$id", "%s", 1)
 	client := &http.Client{}
 
@@ -103,6 +102,10 @@ func buildFn(r configRemote) func(http.Header, []byte) ([]byte, error) {
 			return nil, err
 		}
 
+		if host, ok := hdr["Host"]; ok {
+			req.Host = host[0]
+		}
+
 		for _, v := range r.SetHeaders {
 			req.Header.Set(v.Name, v.Value)
 		}
@@ -111,30 +114,25 @@ func buildFn(r configRemote) func(http.Header, []byte) ([]byte, error) {
 			req.Header.Set(v, hdr.Get(v))
 		}
 
-		if host, ok := hdr["Host"]; ok {
-			req.Host = host[0]
-		}
-
 		res, err := client.Do(req)
 		if err != nil {
-			logger.Error().Err(err).Msgf("Failed to connect to: %s", uri)
-			return nil, err
+			return nil, fmt.Errorf("failed to connect to '%s': %v", uri, err)
 		}
 		defer res.Body.Close()
 
 		if r.Debug {
-			reqDump, err := httputil.DumpRequestOut(req, true)
-			if err != nil {
-				return nil, err
-			}
+			// reqDump, err := httputil.DumpRequestOut(req, true)
+			// if err != nil {
+			// 	return nil, err
+			// }
 
-			resDump, err := httputil.DumpResponse(res, true)
-			if err != nil {
-				return nil, err
-			}
+			// resDump, err := httputil.DumpResponse(res, true)
+			// if err != nil {
+			// 	return nil, err
+			// }
 
-			logger.Warn().Msgf("Remote Request Debug:\n%s\n%s",
-				reqDump, resDump)
+			// logger.Debug().Msgf("Remote Request Debug:\n%s\n%s",
+			// 	reqDump, resDump)
 		}
 
 		if res.StatusCode != 200 {

core/utils.go

@@ -0,0 +1,15 @@
+package core
+
+import (
+	"github.com/cespare/xxhash/v2"
+)
+
+// nolint: errcheck
+func mkkey(h *xxhash.Digest, k1 string, k2 string) uint64 {
+	h.WriteString(k1)
+	h.WriteString(k2)
+	v := h.Sum64()
+	h.Reset()
+
+	return v
+}

docker-compose.yml

@@ -1,7 +1,10 @@
 version: '3.4'
 services:
   db:
-    image: postgres
+    image: postgres:12
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
     ports:
       - "5432:5432"
 
@@ -37,6 +40,6 @@ services:
     command: wtc
     depends_on:
       - db
-      - rails_app
+      # - rails_app
 
     # - redis

docs/.vuepress/components/HomeLayout.vue

@@ -1,271 +0,0 @@
-<template>
-  <div>
-    <main aria-labelledby="main-title" >
-    <Navbar />
-
-    <div class="container mx-auto">
-      <div class="flex flex-col md:flex-row justify-between px-10 md:px-20">
-        <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' }}
-            </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>
-
-            <NavLink
-              class="inline-block px-4 py-3 my-8 bg-blue-600 text-blue-100 font-bold rounded"
-              :item="actionLink"
-            />
-
-            <a
-              class="px-4 py-3 my-8 border-2 border-gray-500 text-gray-600 font-bold rounded"
-              href="https://github.com/dosco/super-graph"
-              target="_blank"
-            >Github</a>
-
-          </div>
-        </div>
-
-        <div class="py-10 md:p-20">
-          <img src="/hologram.svg" class="h-64">
-        </div>
-
-      </div>
-      </div>
-
-      <div>
-        <div
-          class="flex flex-wrap mx-2 md:mx-20"
-          v-if="data.features && data.features.length"
-        >
-          <div
-            class="w-2/4 md:w-1/3 shadow"
-            v-for="(feature, index) in data.features"
-            :key="index"
-          >
-            <div class="p-8">
-            <h2 class="md:text-xl text-blue-800 font-medium border-0 mb-1">{{ feature.title }}</h2>
-            <p class="md:text-xl text-gray-700 leading-snug">{{ feature.details }}</p>
-            </div>
-          </div>
-        </div>
-      </div>
-
-
-      <div class="bg-gray-100 mt-10">
-        <div class="container mx-auto px-10 md:px-0 py-32">
-
-          <div class="pb-8 hidden md:block ">
-            <img src="arch-basic.svg">
-          </div>
-
-          <h1 class="uppercase font-semibold text-xl text-blue-800 mb-4">
-            What is {{ data.heroText }}?
-          </h1>
-          <div class="text-2xl md:text-3xl">
-            Super Graph can automatically learn a Postgres database and instantly serve it as a fast and secured GraphQL API. It comes with tools to create a new app and manage it's database. You get it all, a very productive developer and a highly scalable app backend. It's designed to work well on serverless platforms by Google, AWS, Microsoft, etc. The goal is to save you a ton of time and money so you can focus on you're apps core value.
-          </div>
-
-
-        </div>
-      </div>
-
-
-      <div class="flex flex-wrap">
-        <div class="md:w-2/4">
-          <img src="/graphql.png">
-        </div>
-
-        <div class="md:w-2/4">
-          <img src="/json.png">
-        </div>
-      </div>
-
-      <div class="mt-10 py-10 md:py-20">
-        <div class="container mx-auto px-10 md:px-0">
-          <h1 class="uppercase font-semibold text-xl text-blue-800 mb-4">
-            How to use {{ data.heroText }}?
-          </h1>
-          <div class="text-2xl md:text-3xl">
-            <small class="text-sm">Use the below command to download and install Super Graph. You will need Go 1.13 or above</small>
-            <pre>&#8227; GO111MODULE=on go get -u github.com/dosco/super-graph</pre>
-
-            <small class="text-sm">Create a new app and change to it's directory</small>
-            <pre>&#8227; super-graph new blog; cd blog</pre>
-
-            <small class="text-sm">Setup the app database and seed it with fake data. Docker compose will start a Postgres database for your app</small>
-            <pre>&#8227; docker-compose run blog_api ./super-graph db:setup</pre>
-
-            <small class="text-sm">And finally launch Super Graph configured for your app</small>
-            <pre>&#8227; docker-compose up</pre>
-          </div>
-        </div>
-      </div>
-
-      <div class="bg-gray-100 mt-10">
-        <div class="container mx-auto px-10 md:px-0 py-32">
-          <h1 class="uppercase font-semibold text-xl text-blue-800 mb-4">
-            The story of {{ data.heroText }}
-          </h1>
-          <div class="text-2xl md:text-3xl">
-            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.<br><br>
-            
-            It's always the same thing, figure out what the UI needs then build an endpoint for it. Most API code involves struggling with an ORM to query a database and mangle the data into a shape that the UI expects to see.<br><br>
-            
-            I didn't want to write this code anymore, I wanted the computer to do it. Enter GraphQL, to me it sounded great, but it still required me to write all the same database query code.<br><br>
-            
-            Having worked with compilers before I saw this as a compiler problem. Why not build a compiler that converts GraphQL to highly efficient SQL.<br><br>
-            
-            This compiler is what sits at the heart of Super Graph with layers of useful functionality around it like authentication, remote joins, rails integration, database migrations and everything else needed for you to build production ready apps with it.
-          </div>
-        </div>
-      </div>
-
-      <div class="overflow-hidden bg-indigo-900">
-        <div class="container mx-auto py-20">
-        <img src="/super-graph-web-ui.png">
-        </div>
-      </div>
-
-      <div class="py-10 md:py-20">
-        <div class="container mx-auto px-10 md:px-0">
-          <h1 class="uppercase font-semibold text-xl text-blue-800 mb-4">
-            Try it with a demo Rails app
-          </h1>
-          <div class="text-2xl md:text-3xl">
-            <small class="text-sm">Download the Docker compose config for the demo</small>
-            <pre>&#8227; curl -L -o demo.yml https://bit.ly/2mq05lW</pre>
-
-            <small class="text-sm">Setup the demo database</small>
-            <pre>&#8227; docker-compose -f demo.yml run rails_app rake db:create db:migrate db:seed</pre>
-
-            <small class="text-sm">Run the demo</small>
-            <pre>&#8227; docker-compose -f demo.yml up</pre>
-
-            <small class="text-sm">Signin to the demo app (user1@demo.com / 123456)</small>
-            <pre>&#8227; open http://localhost:3000</pre>
-
-            <small class="text-sm">Try the super graph web ui</small>
-            <pre>&#8227; open http://localhost:8080</pre>
-          </div>
-        </div>
-      </div>
-
-      <div class="border-t py-10">
-        <div class="block md:hidden w-100">
-          <iframe src='https://www.youtube.com/embed/MfPL2A-DAJk' frameborder='0' allowfullscreen style="width: 100%; height: 250px;">
-          </iframe>
-        </div>
-        
-        <div class="container mx-auto flex flex-col md:flex-row items-center">
-          <div class="w-100 md:w-1/2 p-8">
-            <h1 class="text-2xl font-bold">GraphQL the future of APIs</h1>
-            <p class="text-xl text-gray-600">Keeping a tight and fast development loop helps you iterate quickly. Leveraging technology like Super Graph focuses your team on building the core product and not reinventing wheels. GraphQL eliminate the dependency on the backend engineering and keeps the things moving fast</p>
-          </div>
-
-          <div class="hidden md:block md:w-1/2">
-            <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }</style>
-            <div class="embed-container shadow">
-              <iframe src='https://www.youtube.com/embed/MfPL2A-DAJk' frameborder='0' allowfullscreen >
-              </iframe>
-            </div>
-          </div>
-        </div>
-      </div>
-
-      <div class="bg-gray-200 mt-10">
-        <div class="container mx-auto px-10 md:px-0 py-32">
-          <h1 class="uppercase font-semibold text-xl text-blue-800 mb-4">
-            Build Secure Apps
-          </h1>
-          <div class="flex flex-col text-2xl md:text-3xl">
-            <card className="mb-1 p-8">
-              <template #image><font-awesome-icon icon="portrait" class="text-red-500" /></template>
-              <template #title>Role Based Access Control</template>
-              <template #body>Dynamically assign roles like admin, manager or anon to specific users. Generate role specific queries at runtime. For example admins can get all users while others can only fetch their own user.</template>
-            </card>
-            <card className="mb-1 p-8">
-              <template #image><font-awesome-icon icon="shield-alt" class="text-blue-500" /></template>
-              <template #title>Prepared Statements</template>
-              <template #body>An additional layer of protection from a variety of security issues like SQL injection. In production mode all queries are precompiled into prepared statements so only those can be executed. This also significantly speeds up all queries.</template>
-            </card>
-            <card className="p-8">
-              <template #image><font-awesome-icon icon="lock" class="text-green-500"/></template>
-              <template #title>Fuzz Tested Code</template>
-              <template #body>Fuzzing is done by complex software that generates massives amounts of random input to detect if code is free of security bugs. Google uses fuzzing to protects everything from their cloud infrastructure to the Chrome browser.</template>
-            </card>         
-          </div>
-        </div>
-      </div>
-
-      <div class="">
-        <div class="container mx-auto px-10 md:px-0 py-32">
-          <h1 class="uppercase font-semibold text-xl text-blue-800 mb-4">
-            More Features
-          </h1>
-          <div class="flex flex-col md:flex-row text-2xl md:text-3xl">
-            <card className="mr-0 md:mr-1 mb-1 flex-col w-100 md:w-1/3 items-center">
-              <template #image><img src="/arch-remote-join.svg" class="h-64"></template>
-              <template #title>Remote Joins</template>
-              <template #body>A powerful feature that allows you to query your database and remote REST APIs at the same time. For example fetch a user from the DB, his tweets from Twitter and his payments from Stripe with a single GraphQL query.</template>
-            </card>
-            <card className="mr-0 md:mr-1 mb-1 flex-col w-100 md:w-1/3">
-              <template #image><img src="/arch-search.svg" class="h-64"></template>
-              <template #title>Full Text Search</template>
-              <template #body>Postgres has excellent full-text search built-in. You don't need another expensive service. Super Graph makes it super easy to use with keyword ranking and highlighting also supported.</template>
-            </card>
-            <card className="mb-1 flex-col w-100 md:w-1/3">
-              <template #image><img src="/arch-bulk.svg" class="h-64"></template>
-              <template #title>Bulk Inserts</template>
-              <template #body>Efficiently insert, update and delete multiple items with a single query. Upserts are also supported</template>
-            </card>         
-          </div>
-        </div>
-      </div>
-
-      <div
-        class="mx-auto text-center py-8"
-        v-if="data.footer"
-      >
-        {{ data.footer }}
-      </div>
-    </main>
-  </div>
-</template>
-
-<script>
-import NavLink from '@theme/components/NavLink.vue'
-import Navbar from '@theme/components/Navbar.vue'
-import Card from './Card.vue'
-
-
-import { library } from '@fortawesome/fontawesome-svg-core'
-import { faPortrait, faShieldAlt, faLock } from '@fortawesome/free-solid-svg-icons'
-import { FontAwesomeIcon } from '@fortawesome/vue-fontawesome'
-
-library.add(faPortrait, faShieldAlt, faLock)
-
-export default {
-  components: { NavLink, Navbar, FontAwesomeIcon, Card },
-
-  computed: {
-    data () {
-      return this.$page.frontmatter
-    },
-
-    actionLink () {
-      return {
-        link: this.data.actionLink,
-        text: this.data.actionText
-      }
-    }
-  }
-}
-</script>

docs/guide/.vuepress/components/Card.vue

@@ -1,5 +1,5 @@
 <template>
-<div class="shadow bg-white p-4 flex items-start" :class="className">
+<div class="shadow p-4 flex items-start" :class="className">
   <slot name="image"></slot>
   <div class="pl-4">
     <h2 class="p-0">

docs/guide/.vuepress/components/HomeLayout.vue

@@ -0,0 +1,436 @@
+<template>
+  <div>
+    <main aria-labelledby="main-title" >
+    <Navbar />
+    <div style="height: 3.6rem"></div>
+
+    <div class="container mx-auto pt-4">
+      <div class="text-center">
+        <div class="text-center text-3xl md:text-4xl text-black leading-tight font-semibold">
+          Fetch data without code
+        </div>
+
+        <NavLink
+          class="inline-block px-4 py-3 my-8 bg-blue-600 text-white font-bold rounded"
+          :item="actionLink"
+        />
+
+        <a
+          class="px-4 py-3 my-8 border-2 border-blue-600 text-blue-600 font-bold rounded"
+          href="https://github.com/dosco/super-graph"
+          target="_blank"
+        >Github</a>
+      </div>
+    </div>
+
+
+    <div class="container mx-auto mb-8 mt-0 md:mt-20 bg-green-100">
+      <div class="flex flex-wrap">
+        <div class="w-100 md:w-1/2 border border-green-500 text-gray-6 00 text-sm md:text-lg p-6">
+          <div class="text-xl font-bold pb-4">Before, struggle with SQL</div>
+          <pre>
+type User struct {
+  gorm.Model
+  Profile   Profile
+  ProfileID int
+}
+
+type Profile struct {
+  gorm.Model
+  Name string
+}
+
+db.Model(&user).
+  Related(&profile).
+  Association("Languages").
+  Where("name in (?)", []string{"test"}).
+  Joins("left join emails on emails.user_id = users.id")
+  Find(&users)
+
+and more ...
+        </pre>
+        </div>
+
+        <div class="w-100 md:w-1/2 border border-l md:border-l-0 border-green-500 text-blue-900 text-sm md:text-lg p-6">
+          <div class="text-xl font-bold pb-4">With Super Graph, just ask.</div>
+          <pre>
+query {
+  user(id: 5) {
+    id
+    first_name
+    last_name
+    picture_url
+    posts(first: 20, order_by: { score: desc }) {
+      slug
+      title
+      created_at
+      votes_total
+      votes { created_at }
+      author { id name }
+      tags { id name }
+    }
+    posts_cursor
+  }
+}
+          </pre>
+        </div>
+      </div>
+    </div>
+
+    <div class="mt-0 md:mt-20">
+      <div
+        class="flex flex-wrap mx-2 md:mx-20"
+        v-if="data.features && data.features.length"
+      >
+        <div
+          class="w-2/4 md:w-1/3 shadow"
+          v-for="(feature, index) in data.features"
+          :key="index"
+        >
+          <div class="p-8">
+          <h2 class="text-lg uppercase border-0">{{ feature.title }}</h2>
+          <div class="text-xl text-gray-900 leading-snug">{{ feature.details }}</div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+
+    <div class="pt-0 md:pt-20">
+      <div class="container mx-auto p-10">
+
+        <div class="flex justify-center pb-20">
+          <img src="arch-basic.svg">
+        </div>
+
+        <div class="text-2xl md:text-3xl">
+          Super Graph is a library and service that fetches data from any Postgres database using just GraphQL. No more struggling with ORMs and SQL to wrangle data out of the database. No more having to figure out the right joins or making ineffiient queries. However complex the GraphQL, Super Graph will always generate just one single efficient SQL query. The goal is to save you time and money so you can focus on you're apps core value.
+        </div>
+      </div>
+    </div>
+
+
+    <div class="pt-20">
+      <div class="container mx-auto px-10 md:px-0">
+        <h1 class="uppercase font-semibold text-2xl text-blue-800 text-center">
+          Try Super Graph
+        </h1>
+
+        <h1 class="uppercase font-semibold text-lg text-gray-800">
+          Deploy as a service using docker
+        </h1>
+        <div class="p-4 rounded bg-black text-white">
+          <pre>$ git clone https://github.com/dosco/super-graph && cd super-graph && make install</pre>
+          <pre>$ super-graph new blog; cd blog</pre>
+          <pre>$ docker-compose run blog_api ./super-graph db:setup</pre>
+          <pre>$ docker-compose up</pre>
+        </div>
+
+        <h1 class="uppercase font-semibold text-lg text-gray-800">
+          Or use it with your own code
+        </h1>
+        <div class="text-md">
+          <pre class="p-4 rounded bg-black text-white">
+package main
+
+import (
+  "database/sql"
+  "fmt"
+  "time"
+  "github.com/dosco/super-graph/config"
+  "github.com/dosco/super-graph/core"
+  _ "github.com/jackc/pgx/v4/stdlib"
+)
+
+func main() {
+  db, err := sql.Open("pgx", "postgres://postgrs:@localhost:5432/example_db")
+  if err != nil {
+    log.Fatalf(err)
+  }
+
+  conf, err := config.NewConfig("./config")
+  if err != nil {
+    log.Fatalf(err)
+  }
+
+  sg, err = core.NewSuperGraph(conf, db)
+  if err != nil {
+    log.Fatalf(err)
+  }
+
+  graphqlQuery := `
+    query {
+      posts {
+      id
+      title
+    }
+  }`
+
+  res, err := sg.GraphQL(context.Background(), graphqlQuery, nil)
+  if err != nil {
+    log.Fatalf(err)
+  }
+
+  fmt.Println(string(res.Data))
+}
+          </pre>
+        </div>
+      </div>
+    </div>
+
+    <div class="pt-0 md:pt-20">
+      <div class="container mx-auto px-10 md:px-0 py-32">
+        <h1 class="uppercase font-semibold text-xl text-blue-800 mb-4">
+          The story of {{ data.heroText }}
+        </h1>
+        <div class="text-2xl md:text-3xl">
+          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.<br><br>
+          
+          It's always the same thing, figure out what the UI needs then build an endpoint for it. Most API code involves struggling with an ORM to query a database and mangle the data into a shape that the UI expects to see.<br><br>
+          
+          I didn't want to write this code anymore, I wanted the computer to do it. Enter GraphQL, to me it sounded great, but it still required me to write all the same database query code.<br><br>
+          
+          Having worked with compilers before I saw this as a compiler problem. Why not build a compiler that converts GraphQL to highly efficient SQL.<br><br>
+          
+          This compiler is what sits at the heart of Super Graph with layers of useful functionality around it like authentication, remote joins, rails integration, database migrations and everything else needed for you to build production ready apps with it.
+        </div>
+      </div>
+    </div>
+
+    <div class="overflow-hidden bg-indigo-900">
+      <div class="container mx-auto py-20">
+      <img src="/super-graph-web-ui.png">
+      </div>
+    </div>
+
+    <!--
+    <div class="py-10 md:py-20">
+      <div class="container mx-auto px-10 md:px-0">
+        <h1 class="uppercase font-semibold text-xl text-blue-800 mb-4">
+          Try it with a demo Rails app
+        </h1>
+        <div class="text-2xl md:text-3xl">
+          <small class="text-sm">Download the Docker compose config for the demo</small>
+          <pre>&#8227; curl -L -o demo.yml https://bit.ly/2FZS0uw</pre>
+
+          <small class="text-sm">Setup the demo database</small>
+          <pre>&#8227; docker-compose -f demo.yml run rails_app rake db:create db:migrate db:seed</pre>
+
+          <small class="text-sm">Run the demo</small>
+          <pre>&#8227; docker-compose -f demo.yml up</pre>
+
+          <small class="text-sm">Signin to the demo app (user1@demo.com / 123456)</small>
+          <pre>&#8227; open http://localhost:3000</pre>
+
+          <small class="text-sm">Try the super graph web ui</small>
+          <pre>&#8227; open http://localhost:8080</pre>
+        </div>
+      </div>
+    </div>
+    -->
+
+    <div class="pt-0 md:pt-20">
+      <div class="block md:hidden w-100">
+        <iframe src='https://www.youtube.com/embed/MfPL2A-DAJk' frameborder='0' allowfullscreen style="width: 100%; height: 250px;">
+        </iframe>
+      </div>
+      
+      <div class="container mx-auto flex flex-col md:flex-row items-center">
+        <div class="w-100 md:w-1/2 p-8">
+          <h1 class="text-2xl font-bold">GraphQL the future of APIs</h1>
+          <p class="text-xl text-gray-600">Keeping a tight and fast development loop helps you iterate quickly. Leveraging technology like Super Graph focuses your team on building the core product and not reinventing wheels. GraphQL eliminate the dependency on the backend engineering and keeps the things moving fast</p>
+        </div>
+
+        <div class="hidden md:block md:w-1/2">
+          <style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }</style>
+          <div class="embed-container shadow">
+            <iframe src='https://www.youtube.com/embed/MfPL2A-DAJk' frameborder='0' allowfullscreen >
+            </iframe>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <div class="container mx-auto pt-0 md:pt-20">
+      <div class="flex flex-wrap bg-green-100">
+        <div class="w-100 md:w-1/2 border border-green-500 text-gray-6 00 text-sm md:text-lg p-6">
+          <div class="text-xl font-bold pb-4">No more joins joins, json, orms, just use GraphQL. Fetch all the data want in the structure you need.</div>
+          <pre>
+query  {
+  thread {
+    slug
+    title
+    published
+    createdAt : created_at
+    totalVotes : cached_votes_total
+    totalPosts : cached_posts_total
+    vote : thread_vote(where: { user_id: { eq: $user_id } }) {
+      created_at
+    }
+    topics {
+      slug
+      name
+    }
+    author : me {
+      slug
+    }
+    posts(first: 1, order_by: { score: desc }) {
+      slug
+      body
+      published
+      createdAt : created_at
+      totalVotes : cached_votes_total
+      totalComments : cached_comments_total
+      vote {
+        created_at
+      }
+      author : user {
+        slug 
+        firstName : first_name
+        lastName : last_name
+      }
+    }
+    posts_cursor
+  }
+}
+        </pre>
+        </div>
+
+        <div class="w-100 md:w-1/2 border border-l md:border-l-0 border-green-500 text-blue-900 text-sm md:text-lg p-6">
+          <div class="text-xl font-bold pb-4">Instant results using a single highly optimized SQL. It's just that simple.</div>
+          <pre>
+{
+  "data": {
+    "thread": {
+      "slug": "eveniet-ex-24",
+      "vote": null,
+      "posts": [
+        {
+          "body": "Dolor laborum harum sed sit est ducimus temporibus velit non nobis repudiandae nobis suscipit commodi voluptatem debitis sed voluptas sequi officia.",
+          "slug": "illum-in-voluptas-1418",
+          "vote": null,
+          "author": {
+            "slug": "sigurd-kemmer",
+            "lastName": "Effertz",
+            "firstName": "Brandt"
+          },
+          "createdAt": "2020-04-07T04:22:42.115874+00:00",
+          "published": true,
+          "totalVotes": 0,
+          "totalComments": 2
+        }
+      ],
+      "title": "In aut qui deleniti quia dolore quasi porro tenetur voluptatem ut adita alias fugit explicabo.",
+      "author": null,
+      "topics": [
+        {
+          "name": "CloudRun",
+          "slug": "cloud-run"
+        },
+        {
+          "name": "Postgres",
+          "slug": "postgres"
+        }
+      ],
+      "createdAt": "2020-04-07T04:22:38.099482+00:00",
+      "published": true,
+      "totalPosts": 24,
+      "totalVotes": 0,
+      "posts_cursor": "mpeBl6L+QfJHc3cmLkLDj9pOdEZYTt5KQtLsazG3TLITB3hJhg=="
+    }
+  }
+}
+          </pre>
+        </div>
+      </div>
+    </div>
+
+    <div class="pt-0 md:pt-20">
+      <div class="container mx-auto px-10 md:px-0 py-32">
+        <h1 class="uppercase font-semibold text-xl text-blue-800 mb-4">
+          Build Secure Apps
+        </h1>
+        <div class="flex flex-col text-2xl md:text-3xl">
+          <card className="mb-1 p-8">
+            <template #image><font-awesome-icon icon="portrait" class="text-red-500" /></template>
+            <template #title>Role Based Access Control</template>
+            <template #body>Dynamically assign roles like admin, manager or anon to specific users. Generate role specific queries at runtime. For example admins can get all users while others can only fetch their own user.</template>
+          </card>
+          <card className="mb-1 p-8">
+            <template #image><font-awesome-icon icon="shield-alt" class="text-blue-500" /></template>
+            <template #title>Prepared Statements</template>
+            <template #body>An additional layer of protection from a variety of security issues like SQL injection. In production mode all queries are precompiled into prepared statements so only those can be executed. This also significantly speeds up all queries.</template>
+          </card>
+          <card className="p-8">
+            <template #image><font-awesome-icon icon="lock" class="text-green-500"/></template>
+            <template #title>Fuzz Tested Code</template>
+            <template #body>Fuzzing is done by complex software that generates massives amounts of random input to detect if code is free of security bugs. Google uses fuzzing to protects everything from their cloud infrastructure to the Chrome browser.</template>
+          </card>         
+        </div>
+      </div>
+    </div>
+
+    <div class="pt-0 md:py  -20">
+      <div class="container mx-auto">
+        <h1 class="uppercase font-semibold text-xl text-blue-800 mb-4">
+          More Features
+        </h1>
+        <div class="flex flex-col md:flex-row text-2xl md:text-3xl">
+          <card className="mr-0 md:mr-1 mb-1 flex-col w-100 md:w-1/3 items-center">
+            <!-- <template #image><img src="/arch-remote-join.svg" class="h-64"></template> -->
+            <template #title>Remote Joins</template>
+            <template #body>A powerful feature that allows you to query your database and remote REST APIs at the same time. For example fetch a user from the DB, his tweets from Twitter and his payments from Stripe with a single GraphQL query.</template>
+          </card>
+          <card className="mr-0 md:mr-1 mb-1 flex-col w-100 md:w-1/3">
+            <!-- <template #image><img src="/arch-search.svg" class="h-64"></template> -->
+            <template #title>Full Text Search</template>
+            <template #body>Postgres has excellent full-text search built-in. You don't need another expensive service. Super Graph makes it super easy to use with keyword ranking and highlighting also supported.</template>
+          </card>
+          <card className="mb-1 flex-col w-100 md:w-1/3">
+            <!-- <template #image><img src="/arch-bulk.svg" class="h-64"></template> -->
+            <template #title>Bulk Inserts</template>
+            <template #body>Efficiently insert, update and delete multiple items with a single query. Upserts are also supported</template>
+          </card>         
+        </div>
+      </div>
+    </div>
+
+    <div
+      class="mx-auto text-center py-8"
+      v-if="data.footer"
+    >
+      {{ data.footer }}
+    </div>
+  </main>
+</div>
+</template>
+
+<script>
+import NavLink from '@theme/components/NavLink.vue'
+import Navbar from '@theme/components/Navbar.vue'
+import Card from './Card.vue'
+
+
+import { library } from '@fortawesome/fontawesome-svg-core'
+import { faPortrait, faShieldAlt, faLock } from '@fortawesome/free-solid-svg-icons'
+import { FontAwesomeIcon } from '@fortawesome/vue-fontawesome'
+
+library.add(faPortrait, faShieldAlt, faLock)
+
+export default {
+  components: { NavLink, Navbar, FontAwesomeIcon, Card },
+
+  computed: {
+    data () {
+      return this.$page.frontmatter
+    },
+
+    actionLink () {
+      return {
+        link: this.data.actionLink,
+        text: this.data.actionText
+      }
+    }
+  }
+}
+</script>

docs/guide/.vuepress/config.js

@@ -1,6 +1,6 @@
 let ogprefix = 'og: http://ogp.me/ns#'
 let title = 'Super Graph'
-let description = 'An instant GraphQL API for your app. No code needed.'
+let description = 'Fetch data without code'
 let color = '#f42525'
 
 module.exports = {
@@ -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