bump version to 10.0.0

BREAKING CHANGE: For the cases where one to one relationships are
detected, json objects will be returned instead of json arrays of length
1.

If you wish to override this behavior, you can use computed
relationships to return arrays again.

.circleci/config.yml

@@ -1,276 +0,0 @@
-version: 2
-
-jobs:
-  # Make sure that there are no outstanding linting hints and that
-  # auto-formatting does not result in any changes.
-  style-check:
-    docker:
-      - image: nixos/nix:2.3
-    steps:
-      - checkout
-      - run:
-          name: Install linting and styling scripts
-          command: nix-env -f default.nix -iA style
-      - run:
-          name: Run linter
-          command: |
-            # Note: For checking this locally, use `nix-shell --run postgrest-lint`
-            postgrest-lint
-      - run:
-          name: Run style check
-          command: |
-            # 'Note: For checking this locally, use `nix-shell --run postgrest-style`
-            postgrest-style-check
-
-  # Run tests based on stack and docker against the oldest PostgreSQL version
-  # that we support.
-  stack-test:
-    docker:
-      - image: cimg/base:2021.03
-        environment:
-          - PGHOST=localhost
-      - image: circleci/postgres:9.5
-        environment:
-          - POSTGRES_USER=circleci
-          - POSTGRES_DB=circleci
-          - POSTGRES_HOST_AUTH_METHOD=trust
-    steps:
-      - checkout
-      - restore_cache:
-          keys:
-          - v1-stack-dependencies-{{ checksum "postgrest.cabal" }}-{{ checksum "stack.yaml" }}
-      - run:
-          name: install stack & dependencies
-          command: |
-            curl -L https://github.com/commercialhaskell/stack/releases/download/v2.3.1/stack-2.3.1-linux-x86_64.tar.gz | tar zx -C /tmp
-            sudo mv /tmp/stack-2.3.1-linux-x86_64/stack /usr/bin
-            sudo apt-get update
-            sudo apt-get install -y libgmp-dev postgresql-client
-            sudo apt-get install -y --only-upgrade binutils
-            stack setup
-      - run:
-          name: build src and tests dependencies
-          command: |
-            stack build --fast -j1 --only-dependencies
-            stack build --fast --test --no-run-tests --only-dependencies
-      - save_cache:
-          paths:
-            - "~/.stack"
-            - ".stack-work"
-          key: v1-stack-dependencies-{{ checksum "postgrest.cabal" }}-{{ checksum "stack.yaml" }}
-      - run:
-          name: build src and tests
-          command: |
-            stack build --fast -j1
-            stack build --fast --test --no-run-tests
-      - run:
-          name: run spec tests
-          command: |
-            test/create_test_db "postgres://circleci@localhost" postgrest_test stack test
-      - store_artifacts:
-          path: /tmp/postgrest
-
-  # Publish a new release. This only runs when a release is tagged (see
-  # workflow below).
-  release:
-    machine: true
-    steps:
-      - checkout
-      - run:
-          name: Install Nix
-          command: |
-            curl -L https://nixos.org/nix/install | sh
-            echo "source $HOME/.nix-profile/etc/profile.d/nix.sh" >> $BASH_ENV
-      - run:
-          name: Change postgrest.cabal if nightly
-          command: |
-            if test "$CIRCLE_TAG" = "nightly"
-            then
-              cabal_nightly_version=$(git show -s --format='%cd' --date='format:%Y%m%d')
-              sed -i "s/^version:.*/version:$cabal_nightly_version/" postgrest.cabal
-            fi
-      - run:
-          name: Install and use the Cachix binary cache
-          command: |
-            nix-env -iA cachix -f https://cachix.org/api/v1/install
-            cachix use postgrest
-      - run:
-          name: Install release scripts
-          command: nix-env -f default.nix -iA release
-      - run:
-          name: Publish GitHub release
-          command: |
-            export GITHUB_USERNAME="$CIRCLE_PROJECT_USERNAME"
-            export GITHUB_REPONAME="$CIRCLE_PROJECT_REPONAME"
-            postgrest-release-github $CIRCLE_TAG
-      - run:
-          name: Publish Docker images
-          command: |
-            export DOCKER_REPO=postgrest
-            postgrest-release-docker-login
-            postgrest-release-dockerhub $CIRCLE_TAG
-            if test "$CIRCLE_TAG" != "nightly"
-            then
-              postgrest-release-dockerhub-description
-            fi
-      - store_artifacts:
-          path: /tmp/postgrest
-
-  # Build everything in default.nix and push to the Cachix binary cache if running on main
-  nix-build:
-    machine: true
-    steps:
-      - checkout
-      - run:
-          name: Install Nix
-          command: |
-            curl -L https://nixos.org/nix/install | sh
-            echo "source $HOME/.nix-profile/etc/profile.d/nix.sh" >> $BASH_ENV
-      - run:
-          name: Install and use the Cachix binary cache
-          command: |
-            nix-env -iA cachix -f https://cachix.org/api/v1/install
-            cachix use postgrest
-      - run:
-          name: Change postgrest.cabal if nightly
-          command: |
-            if test "$CIRCLE_TAG" = "nightly"
-            then
-              cabal_nightly_version=$(git show -s --format='%cd' --date='format:%Y%m%d')
-              sed -i "s/^version:.*/version:$cabal_nightly_version/" postgrest.cabal
-            fi
-      - run:
-          name: Build all derivations from default.nix and push results to Cachix
-          command: |
-            # Only push to the cache when CircleCI makes the CACHIX_SIGNING_KEY
-            # available (e.g. not for pull requests).
-            if [ -n "${CACHIX_AUTH_TOKEN:-""}" ]; then
-              echo "Building and caching all derivations..."
-              cachix authtoken "$CACHIX_AUTH_TOKEN"
-
-              # Push new builds as we go
-              nix-build | cachix push postgrest
-
-              # Make sure that everything, including .drv files, is pushed
-              nix-env -f default.nix -iA devTools
-              postgrest-push-cachix
-            else
-              echo "Building all derivations (caching skipped for outside pull requests)..."
-              nix-build
-            fi
-      - store_artifacts:
-          path: /tmp/postgrest
-
-  # Run tests
-  nix-test:
-    machine: true
-    steps:
-      - checkout
-      - run:
-          name: Install Nix
-          command: |
-            curl -L https://nixos.org/nix/install | sh
-            echo "source $HOME/.nix-profile/etc/profile.d/nix.sh" >> $BASH_ENV
-      - run:
-          name: Install and use the Cachix binary cache
-          command: |
-            nix-env -iA cachix -f https://cachix.org/api/v1/install
-            cachix use postgrest
-      - run:
-          name: Install testing scripts
-          command: nix-env -f default.nix -iA tests memory withTools
-      - run:
-          name: Run coverage (io tests and spec tests against PostgreSQL 13)
-          command: postgrest-coverage
-          when: always
-      - run:
-          name: Skip tests on build or primary test failure
-          command: circleci-agent step halt
-          when: on_fail
-      - run:
-          name: Upload coverage to codecov
-          command: |
-            # Modified from:
-            # https://docs.codecov.io/docs/about-the-codecov-bash-uploader#validating-the-bash-script
-            curl -s https://codecov.io/bash > codecov;
-            VERSION=$(grep 'VERSION=\".*\"' codecov | cut -d'"' -f2);
-            shasum -a 512 -c <(curl -s https://raw.githubusercontent.com/codecov/codecov-bash/${VERSION}/SHA512SUM | grep codecov)
-            bash codecov -f coverage/codecov.json
-      - run:
-          name: Run the spec tests against PostgreSQL 12
-          command: postgrest-with-postgresql-12 postgrest-test-spec
-          when: always
-      - run:
-          name: Run the spec tests against PostgreSQL 11
-          command: postgrest-with-postgresql-11 postgrest-test-spec
-          when: always
-      - run:
-          name: Run the spec tests against PostgreSQL 10
-          command: postgrest-with-postgresql-10 postgrest-test-spec
-          when: always
-      - run:
-          name: Run the spec tests against PostgreSQL 9.6
-          command: postgrest-with-postgresql-9.6 postgrest-test-spec
-          when: always
-      - run:
-          name: Run the spec tests against PostgreSQL 9.5
-          command: postgrest-with-postgresql-9.5 postgrest-test-spec
-          when: always
-      - run:
-          name: Check the spec tests for idempotence
-          command: postgrest-test-spec-idempotence
-          when: always
-      - run:
-          name: Run memory tests
-          command: postgrest-test-memory
-          when: always
-      - store_artifacts:
-          path: /tmp/postgrest
-
-workflows:
-  version: 2
-  build-test-release:
-    jobs:
-      - style-check:
-          # Make sure that this job also runs when releases are tagged.
-          filters:
-            tags:
-              only:
-                - /v[0-9]+(\.[0-9]+)*/
-                - nightly
-      - stack-test:
-          filters:
-            tags:
-              only:
-                - /v[0-9]+(\.[0-9]+)*/
-                - nightly
-      - nix-build:
-          filters:
-            tags:
-              only:
-                - /v[0-9]+(\.[0-9]+)*/
-                - nightly
-          context:
-            - cachix
-      - nix-test:
-          filters:
-            tags:
-              only:
-                - /v[0-9]+(\.[0-9]+)*/
-                - nightly
-      - release:
-          requires:
-            - style-check
-            - stack-test
-            - nix-build
-            - nix-test
-          filters:
-            tags:
-              only:
-                - /v[0-9]+(\.[0-9]+)*/
-                - nightly
-            branches:
-              ignore: /.*/
-          context:
-            - docker
-            - github

.cirrus.yml

@@ -1,71 +1,15 @@
 freebsd_instance:
-  image: freebsd-12-2-release-amd64
+  image_family: freebsd-13-1
 
 build_task:
-  env:
-    GITHUB_TOKEN: ENCRYPTED[!1ecc3020fe8c6463c06ebc22153533239e132ee56e4faad95ce336bd2ee2bde6aa89c0352e89faaa2c10f4a5bac9b7fc!]
-  # caches the freebsd package downloads
-  # saves probably just a couple of seconds, but hey...
-  pkg_cache:
-    folder: /var/cache/pkg
+  name: Build FreeBSD (Stack)
+  install_script: pkg install -y postgresql13-client hs-stack
 
-  install_script:
-  #  - pkg update
-    - pkg install -y postgresql12-client ghc hs-cabal-install jq git
-
-  # cache the hackage index file and downloads which are
-  # cabal v2-update downloads an incremental update, so we don't need to keep this up2date
-  packages_cache:
-    # warning: don't use ~/.cabal here, this will break the cache
-    folder: /.cabal/packages
+  stack_cache:
+    folders: /.stack
+    fingerprint_script: cat postgrest.cabal stack.yaml.lock
     reupload_on_changes: false
 
-  # cache the dependencies built by cabal
-  # they have to be uploaded on every change to make the next build fast
-  store_cache:
-    # warning: don't use ~/.cabal here, this will break the cache
-    folder: /.cabal/store
-    fingerprint_script: cat postgrest.cabal
-    reupload_on_changes: true
-
-  build_script:
-    - cabal v2-update
-    - |
-      if test "$CIRRUS_TAG" = "nightly"
-      then
-        cabal_nightly_version=$(git show -s --format='%cd' --date='format:%Y%m%d')
-        sed -i '' "s/^version:.*/version:$cabal_nightly_version/" postgrest.cabal
-      fi
-      ## compile for 30 minutes tops
-    - timeout 1800 cabal v2-build -j1 || test "$?" = "124"
-
-  publish_script:
-    - |
-      if test ! "$CIRRUS_TAG"
-      then
-        echo 'No tag pushed. Skip release.'
-      else
-        cabal v2-install
-
-        bin_name=""
-
-        if test $CIRRUS_TAG = "nightly"
-        then
-          suffix=$(git show -s --format="%cd-%h" --date="format:%Y-%m-%d-%H-%M")
-          bin_name=postgrest-nightly-$suffix-freebsd.tar.xz
-        else
-          bin_name=postgrest-$CIRRUS_TAG-freebsd.tar.xz
-        fi
-
-        release_id=$(curl -s https://api.github.com/repos/$CIRRUS_REPO_FULL_NAME/releases/tags/$CIRRUS_TAG | jq .id)
-
-        echo "Uploading $bin_name to gh release: $release_id"
-
-        tar cvJf $bin_name --dereference -C /.cabal/bin postgrest
-
-        ## We don't use ghr here because it doesn't provide freebsd binaries: https://github.com/tcnksm/ghr/issues/127
-        curl -X POST --data-binary @$bin_name \
-          -H "Authorization:token $GITHUB_TOKEN" \
-          -H "Content-Type:application/octet-stream" \
-          "https://uploads.github.com/repos/$CIRRUS_REPO_FULL_NAME/releases/$release_id/assets?name=$bin_name"
-      fi
+  build_script: stack build -j 1 --local-bin-path . --copy-bins
+  bin_artifacts:
+    path: postgrest

.github/actions/setup-nix/action.yaml

@@ -0,0 +1,21 @@
+name: Setup Nix
+
+description: Installs nix, sets up cachix and installs a subset of tooling.
+
+inputs:
+  authToken:
+    description: Token to pass to cachix
+  tools:
+    description: Tools to install with nix-env -iA <tools>
+
+runs:
+  using: composite
+  steps:
+    - uses: cachix/install-nix-action@v16
+    - uses: cachix/cachix-action@v10
+      with:
+        name: postgrest
+        authToken: ${{ inputs.authToken }}
+    - if: ${{ inputs.tools }}
+      run: nix-env -f default.nix -iA ${{ inputs.tools }}
+      shell: bash

.github/codecov.yml

@@ -9,10 +9,10 @@ coverage:
     project:
       default:
         target: auto
-        threshold: 0%
+        threshold: 1%
         only_pulls: false
     patch:
       default:
         target: auto
-        threshold: 0%
+        threshold: 1%
         only_pulls: true

.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+- package-ecosystem: github-actions
+  directory: /
+  schedule:
+    interval: weekly

.github/get_cirrusci_freebsd

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Get the FreeBSD PostgREST executable built by CirrusCI for the given GITHUB_COMMIT in GITHUB_REPOSITORY
+
+# We use the GitHub API for 'check suites' to find the corresponding CirrusCI job, see:
+# https://docs.github.com/en/rest/reference/checks#list-check-suites-for-a-git-reference
+
+cirrus_artifact_name=bin
+gh_accept_header="Accept: application/vnd.github.v3+json"
+
+get_gh_check_runs_url() {
+  gh_checks_list_url="https://api.github.com/repos/$GITHUB_REPOSITORY/commits/$GITHUB_COMMIT/check-suites"
+  >&2 echo "Getting list of check-suites from $gh_checks_list_url ..."
+  curl --fail -H "$gh_accept_header"  "$gh_checks_list_url" \
+    | jq -r '.check_suites[] | select(.app.slug == "cirrus-ci") | .check_runs_url'
+}
+
+wait_for_cirrusci() {
+  gh_check_runs_url="$(get_gh_check_runs_url)"
+  >&2 echo "Waiting to CirrusCI run to complete (two hours maximum)..."
+  for _ in $(seq 1 120); do
+    echo "Checking for CirrusCI task status at $gh_check_runs_url ..."
+    status=$(curl --fail "$gh_check_runs_url" | jq -r '.check_runs[] | .status')
+    if [ "$status" == "completed" ]; then
+      break
+    else
+      echo "CirrusCI task is still $status, waiting..."
+      sleep 60
+    fi
+  done
+}
+
+# The CirrusCI taskid can change if a new check run is started for the same commit,
+# e.g. when pushing both a branch and tag. We make sure that we have the very
+# latest taskid by re-loading the 'gh_check_runs_url' and the 'check run' itself.
+get_cirrus_taskid() {
+  gh_check_runs_url="$(get_gh_check_runs_url)"
+  >&2 echo "Getting the CirrusCI task id from $gh_check_runs_url ..."
+  curl --fail -H "$gh_accept_header" "$gh_check_runs_url" \
+    | jq -r '.check_runs[] | .external_id'
+}
+
+download_artifact() {
+  cirrus_task_id="$(get_cirrus_taskid)"
+  cirrus_artifact_url="https://api.cirrus-ci.com/v1/artifact/task/$cirrus_task_id/$cirrus_artifact_name.zip"
+  >&2 echo "Attemping to download the CirrusCI artifact from $cirrus_artifact_url ..."
+  curl --fail "$cirrus_artifact_url" -o freebsd.zip
+}
+
+wait_for_cirrusci
+download_artifact
+
+echo "Unpacking executable..."
+unzip freebsd.zip -d .
+rm -rf freebsd.zip

.github/release

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+# Tag a release that will be built with Github Actions. The version is
+# read from 'postgrest.cabal'.
+
+version="$(grep -oP '^version:\s*\K.*' postgrest.cabal)"
+
+echo "Tagging version v$version"
+git tag -f "v$version"
+
+echo "Pushing tag..."
+git push -f origin "refs/tags/v$version"

.github/scripts/arm/build.sh

@@ -0,0 +1,63 @@
+#!/bin/bash
+
+# This script builds PostgREST in a remote ARM server
+
+[ -z "$1" ] && { echo "Missing 1st argument: PostgREST github commit SHA"; exit 1; }
+[ -z "$2" ] && { echo "Missing 2nd argument: Build environment directory name"; exit 1; }
+
+PGRST_GITHUB_COMMIT="$1"
+SCRIPT_DIR="$2"
+
+DOCKER_BUILD_DIR="$SCRIPT_DIR/docker-env"
+
+install_packages() {
+  sudo apt-get update -y
+  sudo apt-get upgrade -y
+  sudo apt-get install -y git build-essential curl libffi-dev libffi7 libgmp-dev libgmp10 libncurses-dev libncurses5 libtinfo5 llvm libnuma-dev zlib1g-dev libpq-dev jq gcc
+  sudo apt-get clean
+}
+
+install_ghcup() {
+  export BOOTSTRAP_HASKELL_NONINTERACTIVE=1
+  export BOOTSTRAP_HASKELL_MINIMAL=1
+  curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh
+  source ~/.ghcup/env
+}
+
+install_cabal() {
+  ghcup upgrade
+  ghcup install cabal 3.6.0.0
+  ghcup set cabal 3.6.0.0
+}
+
+install_ghc() {
+  ghcup install ghc 8.10.7
+  ghcup set ghc 8.10.7
+}
+
+install_packages
+
+# Add ghcup to the PATH for this session
+[ -f ~/.ghcup/env ] && source ~/.ghcup/env
+
+ghcup --version || install_ghcup
+cabal --version || install_cabal
+ghc --version || install_ghc
+
+cd ~/$SCRIPT_DIR
+
+# Clone the repository and build the project
+git clone https://github.com/PostgREST/postgrest.git
+cd postgrest
+git checkout $PGRST_GITHUB_COMMIT
+cabal v2-update && cabal v2-build
+
+# Copy the built binary to the Dockerfile directory
+PGRST_BIN=$(cabal exec which postgrest | tail -1)
+cp $PGRST_BIN ~/$DOCKER_BUILD_DIR
+
+# Move and compress the built binary
+mkdir -p ~/$SCRIPT_DIR/result
+mv $PGRST_BIN ~/$SCRIPT_DIR/result
+cd ~/$SCRIPT_DIR
+tar -cJf result.tar.xz result

.github/scripts/arm/docker-env/Dockerfile

@@ -0,0 +1,16 @@
+# PostgREST docker hub image
+
+FROM ubuntu:focal AS postgrest
+
+RUN apt-get update -y \
+    && apt install -y --no-install-recommends libpq-dev zlib1g-dev jq gcc libnuma-dev \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY postgrest /usr/bin/postgrest
+
+EXPOSE 3000
+
+USER 1000
+
+CMD postgrest

.github/scripts/arm/docker-publish.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+
+# This script publishes the Docker ARM images to Docker Hub.
+
+[ -z "$1" ] && { echo "Missing 1st argument: PostgREST github commit SHA"; exit 1; }
+[ -z "$2" ] && { echo "Missing 2nd argument: Docker repo"; exit 1; }
+[ -z "$3" ] && { echo "Missing 3rd argument: Docker username"; exit 1; }
+[ -z "$4" ] && { echo "Missing 4th argument: Docker password"; exit 1; }
+[ -z "$5" ] && { echo "Missing 5th argument: Build environment directory name"; exit 1; }
+[ -z "$6" ] && { echo "Missing 6th argument: PostgREST version"; exit 1; }
+
+PGRST_GITHUB_COMMIT="$1"
+DOCKER_REPO="$2"
+DOCKER_USER="$3"
+DOCKER_PASS="$4"
+SCRIPT_DIR="$5"
+PGRST_VERSION="v$6"
+IS_PRERELEASE="$7"
+
+DOCKER_BUILD_DIR="$SCRIPT_DIR/docker-env"
+
+clean_env()
+{
+    sudo docker logout
+}
+
+# Login to Docker
+sudo docker logout
+{ echo $DOCKER_PASS | sudo docker login -u $DOCKER_USER --password-stdin; } || { echo "Couldn't login to docker"; exit 1; }
+
+trap clean_env sigint sigterm exit
+
+# Move to the docker build environment
+cd ~/$DOCKER_BUILD_DIR
+
+# Push final images to Docker hub
+# NOTE: This command publishes a separate ARM image because the builds cannot
+#       be added to the manifest if they are not in the registry beforehand.
+#       This image must be manually deleted from Docker Hub at the end of the process.
+sudo docker buildx build --build-arg PGRST_GITHUB_COMMIT=$PGRST_GITHUB_COMMIT \
+                         -t $DOCKER_REPO/postgrest:$PGRST_VERSION-arm \
+                         --push .
+
+# Add the arm images to the manifest
+# NOTE: This assumes that there already is a `postgrest:<version>` image
+#       for the amd64 architecture pushed to Docker Hub
+sudo docker buildx imagetools create --append -t $DOCKER_REPO/postgrest:$PGRST_VERSION $DOCKER_REPO/postgrest:$PGRST_VERSION-arm
+[ -z $IS_PRERELEASE ] && sudo docker buildx imagetools create --append -t $DOCKER_REPO/postgrest:latest $DOCKER_REPO/postgrest:$PGRST_VERSION-arm
+
+sudo docker logout

.github/workflows/ci.yaml

@@ -0,0 +1,476 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+      - rel-*
+    tags:
+      - v*
+  pull_request:
+    branches:
+      - main
+      - rel-*
+
+jobs:
+  Lint-Style:
+    name: Lint & check code style
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Nix Environment
+        uses: ./.github/actions/setup-nix
+        with:
+          tools: style
+      - name: Run linter (check locally with `nix-shell --run postgrest-lint`)
+        run: postgrest-lint
+      - name: Run style check (auto-format with `nix-shell --run postgrest-style`)
+        run: postgrest-style-check
+
+
+  Test-Nix:
+    name: Test (Nix)
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        # Hack for enabling color output, see:
+        # https://github.com/actions/runner/issues/241#issuecomment-842566950
+        shell: script -qec "bash --noprofile --norc -eo pipefail {0}"
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Nix Environment
+        uses: ./.github/actions/setup-nix
+        with:
+          tools: tests
+
+      - name: Run coverage (IO tests and Spec tests against PostgreSQL 14)
+        run: postgrest-coverage
+      - name: Upload coverage to codecov
+        uses: codecov/codecov-action@v3.1.0
+        with:
+          files: ./coverage/codecov.json
+
+      - name: Run doctests
+        if: always()
+        run: nix-shell --run postgrest-test-doctests
+
+      - name: Check the spec tests for idempotence
+        if: always()
+        run: postgrest-test-spec-idempotence
+
+
+  Test-Pg-Nix:
+    strategy:
+      fail-fast: false
+      matrix:
+        pgVersion: [9.6, 10, 11, 12, 13, 14]
+    name: Test PG ${{ matrix.pgVersion }} (Nix)
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        # Hack for enabling color output, see:
+        # https://github.com/actions/runner/issues/241#issuecomment-842566950
+        shell: script -qec "bash --noprofile --norc -eo pipefail {0}"
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Nix Environment
+        uses: ./.github/actions/setup-nix
+        with:
+          tools: tests withTools
+
+      - name: Run spec tests
+        if: always()
+        run: postgrest-with-postgresql-${{ matrix.pgVersion }} postgrest-test-spec
+
+      - name: Run IO tests
+        if: always()
+        run: postgrest-with-postgresql-${{ matrix.pgVersion }} -f test/io/fixtures.sql postgrest-test-io
+
+      - name: Run query cost tests
+        if: always()
+        run: postgrest-with-postgresql-${{ matrix.pgVersion }} postgrest-test-querycost
+
+
+  Test-Memory-Nix:
+    name: Test memory (Nix)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Nix Environment
+        uses: ./.github/actions/setup-nix
+        with:
+          tools: memory
+      - name: Run memory tests
+        run: postgrest-test-memory
+
+
+  Build-Static-Nix:
+    name: Build Linux static (Nix)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Nix Environment
+        uses: ./.github/actions/setup-nix
+        with:
+          authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
+          tools: tests
+
+      - name: Build static executable
+        run: nix-build -A postgrestStatic
+      - name: Check static executable
+        run: postgrest-check-static result/bin/postgrest
+      - name: Save built executable as artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: postgrest-linux-static-x64
+          path: result/bin/postgrest
+          if-no-files-found: error
+
+      - name: Build Docker image
+        run: nix-build -A docker.image --out-link postgrest-docker.tar.gz
+      - name: Save built Docker image as artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: postgrest-docker-x64
+          path: postgrest-docker.tar.gz
+          if-no-files-found: error
+
+      - name: Build and push everything to Cachix (main branch only)
+        if: ${{ github.ref == 'refs/heads/main' }}
+        run: |
+          nix-build
+          nix-env -f default.nix -iA devTools
+          postgrest-push-cachix
+
+
+  Build-Stack:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: Linux & test
+            runs-on: ubuntu-latest
+            cache: |
+              ~/.stack
+              .stack-work
+            artifact: postgrest-ubuntu-x64
+
+          - name: MacOS & test
+            runs-on: macos-latest
+            cache: |
+              ~/.stack
+              .stack-work
+            artifact: postgrest-macos-x64
+
+          - name: Windows
+            runs-on: windows-latest
+            cache: |
+              ~\AppData\Roaming\stack
+              ~\AppData\Local\Programs\stack
+              .stack-work
+            deps: Add-Content $env:GITHUB_PATH $env:PGBIN
+            artifact: postgrest-windows-x64
+
+    name: Build ${{ matrix.name }} (Stack)
+    runs-on: ${{ matrix.runs-on }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Stack working files cache
+        uses: actions/cache@v3
+        with:
+          path: ${{ matrix.cache }}
+          key: ${{ runner.os }}-${{ hashFiles('stack.yaml.lock') }}
+      - name: Install dependencies
+        if: ${{ matrix.deps }}
+        run: ${{ matrix.deps }}
+      - name: Build with Stack
+        run: stack build --local-bin-path result --copy-bins
+      - name: Save built executable as artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ matrix.artifact }}
+          path: |
+            result/postgrest
+            result/postgrest.exe
+          if-no-files-found: error
+
+  Get-FreeBSD-CirrusCI:
+    name: Get FreeBSD build from CirrusCI
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Get FreeBSD executable from CirrusCI
+        env:
+          # GITHUB_SHA does weird things for pull request, so we roll our own:
+          GITHUB_COMMIT: ${{github.event.pull_request.head.sha || github.sha}}
+        run: .github/get_cirrusci_freebsd
+      - name: Save executable as artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: postgrest-freebsd-x64
+          path: postgrest
+          if-no-files-found: error
+
+  Build-Cabal-Arm:
+    name: Build aarch64 (Cabal)
+    if: ${{ github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/v') || startsWith(github.ref, 'refs/heads/rel-') }}
+    runs-on: ubuntu-latest
+    outputs:
+      remotepath: ${{ steps.Remote-Dir.outputs.remotepath }}
+    env:
+      GITHUB_COMMIT: ${{ github.sha }}
+    steps:
+      - uses: actions/checkout@v2.4.0
+      - id: Remote-Dir
+        name: Unique directory name for the remote build
+        run: echo "::set-output name=remotepath::postgrest-build-$(uuidgen)"
+      - name: Copy script files to the remote server
+        uses: appleboy/scp-action@master
+        with:
+          host: ${{ secrets.SSH_ARM_HOST }}
+          username: ubuntu
+          key: ${{ secrets.SSH_ARM_PRIVATE_KEY }}
+          fingerprint: ${{ secrets.SSH_ARM_FINGERPRINT }}
+          source: ".github/scripts/arm/*"
+          target: ${{ steps.Remote-Dir.outputs.remotepath }}
+          strip_components: 3
+      - name: Build ARM
+        uses: appleboy/ssh-action@master
+        env:
+          REMOTE_DIR: ${{ steps.Remote-Dir.outputs.remotepath }}
+        with:
+          host: ${{ secrets.SSH_ARM_HOST }}
+          username: ubuntu
+          key: ${{ secrets.SSH_ARM_PRIVATE_KEY }}
+          fingerprint: ${{ secrets.SSH_ARM_FINGERPRINT }}
+          command_timeout: 120m
+          script_stop: true
+          envs: GITHUB_COMMIT,REMOTE_DIR
+          script: bash ~/$REMOTE_DIR/build.sh "$GITHUB_COMMIT" "$REMOTE_DIR"
+      - name: Download binaries from remote server
+        uses: nicklasfrahm/scp-action@main
+        with:
+          direction: download
+          host: ${{ secrets.SSH_ARM_HOST }}
+          username: ubuntu
+          key: ${{ secrets.SSH_ARM_PRIVATE_KEY }}
+          fingerprint: ${{ secrets.SSH_ARM_FINGERPRINT }}
+          source: "${{ steps.Remote-Dir.outputs.remotepath }}/result.tar.xz"
+          target: "result.tar.xz"
+      - name: Extract downloaded binaries
+        run: tar -xvf result.tar.xz && rm result.tar.xz
+      - name: Save aarch64 executable as artifact
+        uses: actions/upload-artifact@v2.3.1
+        with:
+          name: postgrest-ubuntu-aarch64
+          path: result/postgrest
+          if-no-files-found: error
+
+
+  Prepare-Release:
+    name: Prepare release
+    if: startsWith(github.ref, 'refs/tags/v')
+    runs-on: ubuntu-latest
+    needs:
+      - Lint-Style
+      - Test-Nix
+      - Test-Pg-Nix
+      - Test-Memory-Nix
+      - Build-Static-Nix
+      - Build-Stack
+      #- Get-FreeBSD-CirrusCI
+      - Build-Cabal-Arm
+    outputs:
+      version: ${{ steps.Identify-Version.outputs.version }}
+      isprerelease: ${{ steps.Identify-Version.outputs.isprerelease }}
+    steps:
+      - uses: actions/checkout@v3
+      - id: Identify-Version
+        name: Identify the version to be released
+        run: |
+          tag_version="${GITHUB_REF##*/}"
+          cabal_version="$(grep -oP '^version:\s*\K.*' postgrest.cabal)"
+
+          if [ "$tag_version" != "v$cabal_version" ]; then
+            echo "Tagged version ($tag_version) does not match the one in postgrest.cabal (v$cabal_version). Aborting release..."
+            exit 1
+          else
+            echo "Version to be released is $cabal_version"
+            echo "::set-output name=version::$cabal_version"
+          fi
+
+          if [[ "$cabal_version" != *.*.*.* ]]; then
+            echo "Version is for a full release (version does not have four components)"
+          else
+            echo "Version is for a pre-release (version has four components, e.g., 1.1.1.1)"
+            echo "::set-output name=isprerelease::1"
+          fi
+      - name: Identify changes from CHANGELOG.md
+        run: |
+          version="${{ steps.Identify-Version.outputs.version }}"
+          isprerelease="${{ steps.Identify-Version.outputs.isprerelease }}"
+
+          if [ -n "$isprerelease" ]; then
+            echo "Getting unreleased changes..."
+            sed -n "1,/## Unreleased/d;/## \[/q;p" CHANGELOG.md > CHANGES.md
+          else
+            echo "Full release (no '-' in version), getting changes for version $version ..."
+            sed -n "1,/## \[$version\]/d;/## \[/q;p" CHANGELOG.md > CHANGES.md
+          fi
+
+          echo "Relevant extract from CHANGELOG.md:"
+          cat CHANGES.md
+      - name: Save CHANGES.md as artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: release-changes
+          path: CHANGES.md
+          if-no-files-found: error
+
+
+  Release-GitHub:
+    name: Release on GitHub
+    permissions:
+      contents: write
+    runs-on: ubuntu-latest
+    needs: Prepare-Release
+    env:
+      VERSION: ${{ needs.Prepare-Release.outputs.version }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Download all artifacts
+        uses: actions/download-artifact@v3
+        with:
+          path: artifacts
+      - name: Create release bundle with archives for all builds
+        run: |
+          find artifacts -type f -iname postgrest -exec chmod +x {} \;
+
+          mkdir -p release-bundle
+
+          tar cJvf "release-bundle/postgrest-v$VERSION-linux-static-x64.tar.xz" \
+            -C artifacts/postgrest-linux-static-x64 postgrest
+
+          # No need to release Ubuntu, as the static Linux binary built with Nix
+          # covers all Linux use-cases
+          #tar cfJv "release-bundle/postgrest-v$VERSION-ubuntu-x64.tar.xz" \
+          #  -C artifacts/postgrest-ubuntu-x64 postgrest
+
+          tar cJvf "release-bundle/postgrest-v$VERSION-macos-x64.tar.xz" \
+            -C artifacts/postgrest-macos-x64 postgrest
+
+          # TODO: Fix timeouts for FreeBSD builds in Cirrus
+          #tar cJvf "release-bundle/postgrest-v$VERSION-freebsd-x64.tar.xz" \
+          #  -C artifacts/postgrest-freebsd-x64 postgrest
+
+          tar cJvf "release-bundle/postgrest-v$VERSION-ubuntu-aarch64.tar.xz" \
+            -C artifacts/postgrest-ubuntu-aarch64 postgrest
+
+          zip "release-bundle/postgrest-v$VERSION-windows-x64.zip" \
+            artifacts/postgrest-windows-x64/postgrest.exe
+
+      - name: Save release bundle
+        uses: actions/upload-artifact@v3
+        with:
+          name: release-bundle
+          path: release-bundle
+          if-no-files-found: error
+
+      - name: Publish release on GitHub
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          isprerelease="${{ needs.Prepare-Release.outputs.isprerelease }}"
+          echo "Releasing version v$VERSION on GitHub (isprerelease=$isprerelease)..."
+
+          gh release delete "v$VERSION" || true
+          gh release create "v$VERSION" \
+            -F artifacts/release-changes/CHANGES.md \
+            ${isprerelease:+"--prerelease"} \
+            release-bundle/*
+
+
+  Release-Docker:
+    name: Release on Docker Hub
+    runs-on: ubuntu-latest
+    needs:
+      - Build-Cabal-Arm
+      - Prepare-Release
+    env:
+      GITHUB_COMMIT: ${{ github.sha }}
+      DOCKER_REPO: postgrest
+      DOCKER_USER: stevechavez
+      DOCKER_PASS: ${{ secrets.DOCKER_PASS }}
+      VERSION: ${{ needs.Prepare-Release.outputs.version }}
+      ISPRERELEASE: ${{ needs.Prepare-Release.outputs.isprerelease }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Nix Environment
+        uses: ./.github/actions/setup-nix
+        with:
+          tools: release
+      - name: Download Docker image
+        uses: actions/download-artifact@v3
+        with:
+          name: postgrest-docker-x64
+      - name: Publish images on Docker Hub
+        run: |
+          docker login -u "$DOCKER_USER" -p "$DOCKER_PASS"
+          docker load -i postgrest-docker.tar.gz
+
+          docker tag postgrest:latest "$DOCKER_REPO/postgrest:v$VERSION"
+          docker push "$DOCKER_REPO/postgrest:v$VERSION"
+
+          # Only tag 'latest' for full releases
+          if [[ -z "$ISPRERELEASE" ]]; then
+            echo "Pushing to 'latest' tag for full release of v$VERSION ..."
+            docker tag postgrest:latest "$DOCKER_REPO"/postgrest:latest
+            docker push "$DOCKER_REPO"/postgrest:latest
+          else
+            echo "Skipping pushing to 'latest' tag for v$VERSION pre-release..."
+          fi
+      - name: Publish images for ARM builds on Docker Hub
+        uses: appleboy/ssh-action@master
+        env:
+          REMOTE_DIR: ${{ needs.Build-Cabal-Arm.outputs.remotepath }}
+        with:
+          host: ${{ secrets.SSH_ARM_HOST }}
+          username: ubuntu
+          key: ${{ secrets.SSH_ARM_PRIVATE_KEY }}
+          fingerprint: ${{ secrets.SSH_ARM_FINGERPRINT }}
+          script_stop: true
+          envs: GITHUB_COMMIT,DOCKER_REPO,DOCKER_USER,DOCKER_PASS,REMOTE_DIR,VERSION,ISPRERELEASE
+          script: bash ~/$REMOTE_DIR/docker-publish.sh "$GITHUB_COMMIT" "$DOCKER_REPO" "$DOCKER_USER" "$DOCKER_PASS" "$REMOTE_DIR" "$VERSION" "$ISPRERELEASE"
+# TODO: Enable dockerhub description update again, once a solution for the permission problem is found:
+# https://github.com/docker/hub-feedback/issues/1927
+#      - name: Update descriptions on Docker Hub
+#        env:
+#          DOCKER_PASS: ${{ secrets.DOCKER_PASS }}
+#        run: |
+#          if [[ -z "$ISPRERELEASE" ]]; then
+#            echo "Updating description on Docker Hub..."
+#            postgrest-release-dockerhub-description
+#          else
+#            echo "Skipping updating description for pre-release..."
+#          fi
+
+  Clean-Arm-Server:
+    name: Remove copied files from server
+    needs:
+      - Build-Cabal-Arm
+      - Release-Docker
+    if: ${{ always() && (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/v') || startsWith(github.ref, 'refs/heads/rel-')) }}
+    runs-on: ubuntu-latest
+    env:
+      REMOTE_DIR: ${{ needs.Build-Cabal-Arm.outputs.remotepath }}
+    steps:
+      - uses: actions/checkout@v2.4.0
+      - name: Remove uploaded files from server
+        uses: appleboy/ssh-action@master
+        with:
+          host: ${{ secrets.SSH_ARM_HOST }}
+          username: ubuntu
+          key: ${{ secrets.SSH_ARM_PRIVATE_KEY }}
+          fingerprint: ${{ secrets.SSH_ARM_FINGERPRINT }}
+          envs: REMOTE_DIR
+          script: rm -rf $REMOTE_DIR

.github/workflows/loadtest.yaml

@@ -0,0 +1,34 @@
+name: Loadtest
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - v*
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  Loadtest-Nix:
+    name: Loadtest (Nix)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: Setup Nix Environment
+        uses: ./.github/actions/setup-nix
+        with:
+          tools: loadtest
+      - name: Run loadtest
+        run: |
+          postgrest-loadtest-against main
+          postgrest-loadtest-report > loadtest/loadtest.md
+      - name: Upload report
+        uses: actions/upload-artifact@v3
+        with:
+          name: loadtest.md
+          path: loadtest/loadtest.md
+          if-no-files-found: error

.github/workflows/report.yaml

@@ -0,0 +1,33 @@
+name: Upload Reports
+
+on:
+  workflow_run:
+    workflows: ["Loadtest"]
+    types:
+      - completed
+
+jobs:
+  upload:
+    name: Loadtest
+    permissions:
+      checks: write
+    runs-on: ubuntu-latest
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+    steps:
+      - name: Download from Artifacts
+        uses: dawidd6/action-download-artifact@v2
+        with:
+          workflow: ${{ github.event.workflow.name }}
+          run_id: ${{github.event.workflow_run.id }}
+          name: loadtest.md
+          path: artifacts
+      - name: Upload to GitHub Checks
+        uses: LouisBrunner/checks-action@v1.2.0
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          sha: ${{ github.event.workflow_run.head_sha }}
+          name: Loadtest Results
+          conclusion: neutral
+          output: |
+            {"summary":""}
+          output_text_description_file: artifacts/loadtest.md

.gitignore

@@ -21,3 +21,5 @@ __pycache__
 *.tix
 coverage
 .hpc
+loadtest
+.history

.travis.yml

@@ -1,80 +0,0 @@
-language: generic
-
-sudo: false
-
-jobs:
-  include:
-    - name: Build OSX Binary
-      os: osx
-      cache:
-        timeout: 1000
-        directories:
-          - $HOME/.stack
-          - $HOME/.local/bin
-      before_install:
-        - mkdir -p "$HOME/.local/bin"
-        - export PATH="$PATH:$HOME/.local/bin"
-      install:
-        - |
-          if test -f "$HOME/.local/bin/stack"
-            then
-              echo 'Stack is already installed.'
-            else
-              echo "Installing Stack..."
-              travis_retry curl -L https://www.stackage.org/stack/osx-x86_64 > stack.tar.gz
-              gunzip stack.tar.gz
-              tar -x -f stack.tar --strip-components 1
-              mv stack "$HOME/.local/bin/"
-              rm stack.tar
-          fi
-        - |
-          if test -f "$HOME/.local/bin/ghr"
-          then
-            echo 'ghr is already installed.'
-          else
-            echo "Installing ghr..."
-            travis_retry curl -L https://github.com/tcnksm/ghr/releases/download/v0.5.4/ghr_v0.5.4_darwin_386.zip > ghr.zip
-            unzip ghr.zip -d "$HOME/.local/bin"
-            rm ghr.zip
-          fi
-      script:
-        - |
-          if test "$TRAVIS_TAG" = "nightly"
-          then
-            cabal_nightly_version=$(git show -s --format='%cd' --date='format:%Y%m%d')
-            sed -i '' "s/^version:.*/version:$cabal_nightly_version/" postgrest.cabal
-          fi
-        ## Building the whole project can take longer than 50 minutes. Since Travis has a global timeout of 50 minutes
-        ## we compile for 30 minutes tops(`gtimeout 1800`) and quit compiling with no error.
-        ## Since we CACHE the compile results we can continue compiling from where we left off
-        ## on the next commit.
-        - gtimeout 1800 stack build --no-terminal --only-snapshot --install-ghc || (($?==124))
-        - |
-          if test ! "$TRAVIS_TAG"
-          then
-            echo 'No tag pushed. Skip building binary.'
-          else
-            stack build --no-terminal --copy-bins --local-bin-path .
-          fi
-        - |
-          if test ! "$TRAVIS_TAG"
-          then
-            echo 'No tag pushed. Skipping release.'
-          else
-            owner="$(echo "$TRAVIS_REPO_SLUG" | cut -f1 -d/)"
-            repo="$(echo "$TRAVIS_REPO_SLUG" | cut -f2 -d/)"
-            if test $TRAVIS_TAG = "nightly"
-            then
-              suffix=$(git show -s --format="%cd-%h" --date="format:%Y-%m-%d-%H-%M")
-              strip postgrest
-              tar cJf postgrest-nightly-$suffix-osx.tar.xz postgrest
-              ghr -t $GITHUB_TOKEN -u $owner -r $repo --replace nightly postgrest-nightly-$suffix-osx.tar.xz
-            else
-              start=$TRAVIS_TAG
-              end='## \['
-              body=$(sed -n "1,/$start/d;/$end/q;p" CHANGELOG.md)
-              strip postgrest
-              tar cJf postgrest-$TRAVIS_TAG-osx.tar.xz postgrest
-              ghr -t $GITHUB_TOKEN -u $owner -r $repo -b "$body"--replace $TRAVIS_TAG postgrest-$TRAVIS_TAG-osx.tar.xz
-            fi
-          fi

CHANGELOG.md

@@ -5,10 +5,140 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Unreleased
 
+## [10.0.0] - 2022-08-18
+
 ### Added
 
+ - #1933, #2109, Add a minimal health check endpoint - @steve-chavez
+   + For enabling this, the `admin-server-port` config must be set explictly
+   + A `<host>:<admin_server_port>/live` endpoint is available for checking if postgrest is running on its port/socket. 200 OK = alive, 503 = dead.
+   + A `<host>:<admin_server_port>/ready` endpoint is available for checking a correct internal state(the database connection plus the schema cache). 200 OK = ready, 503 = not ready.
+ - #1988, Add the current user to the request log on stdout - @DavidLindbom, @wolfgangwalther
+ - #1823, Add the ability to run postgrest without any configuration. - @wolfgangwalther
+   + #1991, Add the ability to run without `db-uri` using libpq's PG environment variables to connect. - @wolfgangwalther
+   + #1769, Add the ability to run without `db-schemas`, defaulting to `db-schemas=public`. - @wolfgangwalther
+   + #1689, Add the ability to run without `db-anon-role` disabling anonymous access. - @wolfgangwalther
+ - #1543, Allow access to fields of composite types in select=, order= and filters through JSON operators -> and ->>. - @wolfgangwalther
+ - #2075, Allow access to array items in ?select=, ?order= and filters through JSON operators -> and ->>. - @wolfgangwalther
+ - #2156, #2211, Allow applying `limit/offset` to UPDATE/DELETE to only affect a subset of rows - @steve-chavez
+   + It requires an explicit `order` on a unique column(s)
+ - #1917, Add error codes with the `"PGRST"` prefix to the error response body to differentiate PostgREST errors from PostgreSQL errors - @laurenceisla
+ - #1917, Normalize the error response body by always having the `detail` and `hint` error fields with a `null` value if they are empty - @laurenceisla
+ - #2176, Errors raised with `SQLSTATE` now include the message and the code in the response body - @laurenceisla
+ - #2236, Support POSIX regular expression operators for row filtering - @enote-kane
+ - #2202, Allow returning XML from RPCs - @fjf2002
+ - #2268, Allow returning XML from single-column queries - @fjf2002
+ - #2300, RPC POST for function w/single unnamed XML param #2300 - @fjf2002
+ - #1564, Allow geojson output by specifying the `Accept: application/geo+json` media type - @steve-chavez
+   + Requires postgis >= 3.0
+   + Works for GET, RPC, POST/PATCH/DELETE with `Prefer: return=representation`.
+   + Resource embedding works and the embedded rows will go into the `properties` key
+   + In case of multiple geometries in the same table, you can choose which one will go into the `geometry` key with the usual `?select` query parameter.
+ - #1082, Add security definitions to the OpenAPI output - @laurenceisla
+ - #2378, Support http OPTIONS method on RPC and root path - @steve-chavez
+ - #2354, Allow getting the EXPLAIN plan of a request by using the `Accept: application/vnd.pgrst.plan` header - @steve-chavez
+   + Only allowed if the `db-plan-enabled` config is set to true
+   + Can generate the plan for different media types using the `for` parameter: `Accept: application/vnd.pgrst.plan; for="application/vnd.pgrst.object"`
+   + Different options for the plan can be used with the `options` parameter: `Accept: application/vnd.pgrst.plan; options=analyze|verbose|settings|buffers|wal`
+   + The plan can be obtained in text or json by using different media type suffixes: `Accept: application/vnd.pgrst.plan+text` and `Accept: application/vnd.pgrst.plan+json`.
+ - #2144, Support computed relationships which allow extending and overriding relationships for resource embedding - @steve-chavez, @wolfgangwalther
+ - #1984, Detect one-to-one relationships for resource embedding - @steve-chavez
+   + Detected when there's a foreign key with a unique constraint or when a foreign key is also a primary key
+
 ### Fixed
 
+ - #2058, Return 204 No Content without Content-Type for PUT - @wolfgangwalther
+ - #2107, Clarify error for failed schema cache load. - @steve-chavez
+   + From `Database connection lost. Retrying the connection` to `Could not query the database for the schema cache. Retrying.`
+ - #1771, Fix silently ignoring filter on a non-existent embedded resource - @steve-chavez
+ - #2152, Remove functions, which are uncallable because of unnamend arguments from schema cache and OpenAPI output. - @wolfgangwalther
+ - #2145, Fix accessing json array fields with -> and ->> in ?select= and ?order=. - @wolfgangwalther
+ - #2155, Ignore `max-rows` on POST, PATCH, PUT and DELETE - @steve-chavez
+ - #2254, Fix inferring a foreign key column as a primary key column on views - @steve-chavez
+ - #2070, Restrict generated many-to-many relationships - @steve-chavez
+   + Only adds many-to-many relationships when: a table has FKs to two other tables and these FK columns are part of the table's PK columns.
+ - #2278, Allow casting to types with underscores and numbers(e.g. `select=oid_array::_int4`) - @steve-chavez
+ - #2277, #2238, #1643, Prevent views from breaking one-to-many/many-to-one embeds when using column or FK as target - @steve-chavez
+    + When using a column or FK as target for embedding(`/tbl?select=*,col-or-fk(*)`), only tables are now detected and views are not.
+    + You can still use a column or an inferred FK on a view to embed a table(`/view?select=*,col-or-fk(*)`)
+ - #2317, Increase the `db-pool-timeout` to 1 hour to prevent frequent high connection latency - @steve-chavez
+ - #2341, The search path now correctly identifies schemas with uppercase and special characters in their names (regression) - @laurenceisla
+ - #2364, "404 Not Found" on nested routes and "405 Method Not Allowed" errors no longer start an empty database transaction - @steve-chavez
+ - #2342, Fix inaccurate result count when an inner embed was selected after a normal embed in the query string - @laurenceisla
+ - #2376, OPTIONS requests no longer start an empty database transaction - @steve-chavez
+ - #2395, Allow using columns with dollar sign($) without double quoting in filters and `select` - @steve-chavez
+ - #2410, Fix loop crash error on startup in Postgres 15 beta 3. Log: "UNION types \"char\" and text cannot be matched". - @yevon
+ - #2397, Fix race conditions managing database connection helper - @robx
+ - #2269, Allow `limit=0` in the request query to return an empty array - @gautam1168, @laurenceisla
+
+### Changed
+
+ - #2001, Return 204 No Content without Content-Type for RPCs returning VOID - @wolfgangwalther
+   + Previously, those RPCs would return "null" as a body with Content-Type: application/json.
+ - #2156, `limit/offset` now limits the affected rows on UPDATE/DELETE  - @steve-chavez
+   + Previously, `limit/offset` only limited the returned rows but not the actual updated rows
+ - #2155, `max-rows` is no longer applied on POST/PATCH/PUT/DELETE returned rows - @steve-chavez
+   + This was misleading because the affected rows were not really affected by `max-rows`, only the returned rows were limited
+ - #2070, Restrict generated many-to-many relationships - @steve-chavez
+   + A primary key that contains the foreign key columns is now needed for generating many-to-many relationships.
+ - #2277, Views now are not detected when embedding using the column or FK as target (`/view?select=*,column(*)`) - @steve-chavez
+   + This embedding form was easily made ambiguous whenever a new view was added.
+   + You can use computed relationships to keep this embedding form working
+ - #2312, Using `Prefer: return=representation` no longer returns a `Location` header - @laurenceisla
+ - #1984, For the cases where one to one relationships are detected, json objects will be returned instead of json arrays of length 1
+   + If you wish to override this behavior, you can use computed relationships to return arrays again
+
+## [9.0.1] - 2022-06-03
+
+### Fixed
+
+- #2165, Fix json/jsonb columns should not have type in OpenAPI spec - @clrnd
+- #2020, Execute deferred constraint triggers when using `Prefer: tx=rollback` - @wolfgangwalther
+- #2077, Fix `is` not working with upper or mixed case values like `NULL, TrUe, FaLsE` - @steve-chavez
+- #2024, Fix schema cache loading when views with XMLTABLE and DEFAULT are present - @wolfgangwalther
+- #1724, Fix wrong CORS header Authentication -> Authorization - @wolfgangwalther
+- #2120, Fix reading database configuration properly when `=` is present in value - @wolfgangwalther
+- #2135, Remove trigger functions from schema cache and OpenAPI output, because they can't be called directly anyway. - @wolfgangwalther
+- #2101, Remove aggregates, procedures and window functions from the schema cache and OpenAPI output. - @wolfgangwalther
+- #2153, Fix --dump-schema running with a wrong PG version. - @wolfgangwalther
+- #2042, Keep working when EMFILE(Too many open files) is reached. - @steve-chavez
+- #2147, Ignore `Content-Type` headers for `GET` requests when calling RPCs. - @laurenceisla
+    + Previously, `GET` without parameters, but with `Content-Type: text/plain` or `Content-Type: application/octet-stream` would fail with `404 Not Found`, even if a function without arguments was available.
+- #2239, Fix misleading disambiguation error where the content of the `relationship` key looks like valid syntax - @laurenceisla
+- #2294, Disable parallel GC for better performance on higher core CPUs - @steve-chavez
+- #1076, Fix using CPU while idle - @steve-chavez
+
+## [9.0.0] - 2021-11-25
+
+### Added
+
+ - #1783, Include partitioned tables into the schema cache. Allows embedding, UPSERT, INSERT with Location response, OPTIONS request and OpenAPI support for partitioned tables - @laurenceisla
+ - #1878, Add Retry-After hint header when in recovery mode - @gautam1168
+ - #1735, Allow calling function with single unnamed param through RPC POST. - @steve-chavez
+   + Enables calling a function with a single json parameter without using `Prefer: params=single-object`
+   + Enables uploading bytea to a function with `Content-Type: application/octet-stream`
+   + Enables uploading raw text to a function with `Content-Type: text/plain`
+ - #1938, Allow escaping inside double quotes with a backslash, e.g. `?col=in.("Double\"Quote")`, `?col=in.("Back\\slash")` - @steve-chavez
+ - #1075, Allow filtering top-level resource based on embedded resources filters. This is enabled by adding `!inner` to the embedded resource, e.g. `/projects?select=*,clients!inner(*)&clients.id=eq.12`- @steve-chavez, @Iced-Sun
+ - #1857, Make GUC names for headers, cookies and jwt claims compatible with PostgreSQL v14 - @laurenceisla, @robertsosinski
+   + Getting the value for a header GUC on PostgreSQL 14 is done using `current_setting('request.headers')::json->>'name-of-header'` and in a similar way for `request.cookies` and `request.jwt.claims`
+   + PostgreSQL versions below 14 can opt in to the new JSON GUCs by setting the `db-use-legacy-gucs` config option to false (true by default)
+ - #1988, Allow specifying `unknown` for the `is` operator - @steve-chavez
+ - #2031, Improve error message for ambiguous embedding and add a relevant hint that includes unambiguous embedding suggestions - @laurenceisla
+
+### Fixed
+
+ - #1871, Fix OpenAPI missing default values for String types and identify Array types as "array" instead of "string" - @laurenceisla
+ - #1930, Fix RPC return type handling for `RETURNS TABLE` with a single column. Regression of #1615. - @wolfgangwalther
+ - #1938, Fix using single double quotes(`"`) and backslashes(`/`) as values on the "in" operator - @steve-chavez
+ - #1992, Fix schema cache query failing with standard_conforming_strings = off - @wolfgangwalther
+
+### Changed
+
+ - #1949, Drop support for embedding hints used with '.'(`select=projects.client_id(*)`), '!' should be used instead(`select=projects!client_id(*)`) - @steve-chavez
+ - #1783, Partitions (created using `PARTITION OF`) are no longer included in the schema cache. - @laurenceisla
+ - #2038, Dropped support for PostgreSQL 9.5 - @wolfgangwalther
+
 ## [8.0.0] - 2021-07-25
 
 ### Added

README.md

@@ -2,13 +2,10 @@
 
 [![Donate](https://img.shields.io/badge/Donate-Patreon-orange.svg?colorB=F96854)](https://www.patreon.com/postgrest)
 [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/postgrest)
-<a href="https://heroku.com/deploy?template=https://github.com/PostgREST/postgrest">
-  <img src="https://img.shields.io/badge/%E2%86%91_Deploy_to-Heroku-7056bf.svg" alt="Deploy">
-</a>
 [![Join the chat at https://gitter.im/begriffs/postgrest](https://img.shields.io/badge/gitter-join%20chat%20%E2%86%92-brightgreen.svg)](https://gitter.im/begriffs/postgrest)
 [![Docs](https://img.shields.io/badge/docs-latest-brightgreen.svg?style=flat)](http://postgrest.org)
 [![Docker Stars](https://img.shields.io/docker/pulls/postgrest/postgrest.svg)](https://hub.docker.com/r/postgrest/postgrest/)
-[![Build Status](https://circleci.com/gh/PostgREST/postgrest/tree/main.svg?style=shield)](https://circleci.com/gh/PostgREST/postgrest/tree/main)
+[![Build Status](https://github.com/postgrest/postgrest/actions/workflows/ci.yaml/badge.svg?branch=main)](https://github.com/PostgREST/postgrest/actions?query=branch%3Amain)
 [![Coverage Status](https://img.shields.io/codecov/c/github/postgrest/postgrest/main)](https://app.codecov.io/gh/PostgREST/postgrest)
 [![Hackage docs](https://img.shields.io/hackage/v/postgrest.svg?label=hackage)](http://hackage.haskell.org/package/postgrest)
 
@@ -112,15 +109,6 @@ the connection cannot do anything the user themselves couldn't. Other
 forms of authentication can be built on top of the JWT primitive. See
 the docs for more information.
 
-Since PostgreSQL 9.5 supports true [row-level
-security](http://www.postgresql.org/docs/9.5/static/ddl-rowsecurity.html).
-In previous versions it can be simulated with triggers and
-security-barrier views. Because the possible queries to the database
-are limited to certain templates using
-[leakproof](http://blog.2ndquadrant.com/how-do-postgresql-security_barrier-views-work/)
-functions, the trigger workaround does not compromise row-level
-security.
-
 ## Versioning
 
 A robust long-lived API needs the freedom to exist in multiple

app.json

@@ -1,59 +0,0 @@
-{
-  "name": "PostgREST",
-  "description": "RESTful API for any PostgreSQL database.",
-  "logo": "https://avatars2.githubusercontent.com/u/15115011",
-  "repository": "https://github.com/PostgREST/postgrest",
-  "env": {
-    "BUILDPACK_URL": {
-      "description": "Heroku buildpack for deploying Haskell applications",
-      "value": "https://github.com/PostgREST/postgrest-heroku"
-    },
-    "POSTGREST_VER": {
-      "description": "Version of PostgREST to deploy",
-      "value": "8.0.0"
-    },
-    "DB_URI": {
-      "description": "Database connection string, e.g. postgres://user:pass@xxxxxxx.rds.amazonaws.com/mydb",
-      "required": true
-    },
-    "DB_SCHEMA": {
-      "description": "The database schema to expose to REST clients. Tables, views and stored procedures in this schema will get API endpoints",
-      "required": true,
-      "value": "public"
-    },
-    "DB_ANON_ROLE": {
-      "description": "The database role to use when executing commands on behalf of unauthenticated clients",
-      "required": true
-    },
-    "DB_POOL": {
-      "description": "Number of connections to keep open in PostgREST’s database pool",
-      "required": false,
-      "value": "10"
-    },
-    "SERVER_PROXY_URI": {
-      "description": "Overrides the base URL used within the OpenAPI self-documentation hosted at the API root path",
-      "required": false
-    },
-    "JWT_SECRET": {
-      "description": "The secret used to decode JWT tokens clients provide for authentication",
-      "required": false
-    },
-    "SECRET_IS_BASE64": {
-      "description": "When this is set to true, the value derived from jwt-secret will be treated as a base64 encoded secret",
-      "required": false,
-      "value": "false"
-    },
-    "JWT_AUD": {
-      "description": "The audience that should be validated if the JWT token contains an aud claim",
-      "required": false
-    },
-    "MAX_ROWS": {
-      "description": "A hard limit to the number of rows PostgREST will fetch from a view, table, or stored procedure",
-      "required": false
-    },
-    "PRE_REQUEST": {
-      "description": "A schema-qualified stored procedure name to call right after switching roles for a client request",
-      "required": false
-    }
-  }
-}

appveyor.yml

@@ -1,47 +0,0 @@
-## AppVeyor is only used for building a Windows binary, no tests are run here.
-platform: x64
-image: Visual Studio 2015
-
-cache:
-- "c:\\sr"
-- .stack-work
-- "c:\\Users\\appveyor\\AppData\\Local\\Programs\\stack"
-
-environment:
-  global:
-    STACK_ROOT: "c:\\sr"
-    GOPATH: c:\gopath
-    TMP: "c:\\tmp"
-
-test: off
-
-install:
-- set PATH=C:\Program Files\PostgreSQL\9.6\bin\;%PATH%
-- curl -sS -ostack.zip -L --insecure http://www.stackage.org/stack/windows-x86_64
-- 7z x stack.zip stack.exe
-- set PATH=%GOPATH%\bin;c:\go\bin;%PATH%
-- go get -u github.com/tcnksm/ghr
-
-build_script:
-- ps: $env:cabal_nightly_version=(git show -s --format='%cd' --date='format:%Y%m%d')
-- IF "%APPVEYOR_REPO_TAG_NAME%"=="nightly" bash -lc "sed -i -r \"s/^(version:\s+)\S+$/\1$cabal_nightly_version/\" postgrest.cabal"
-- stack setup --no-terminal > nul
-# Appveyor has a timeout of 60 mins, building can take longer, limit the time and make sure this succeeds,
-# previous work will get cached and finish on next commit
-- bash -lc "timeout 2700 'C:\projects\postgrest\stack.exe' build -j1 --copy-bins --local-bin-path . || (($?==124))"
-
-artifacts:
-- path: postgrest.exe
-
-deploy_script:
-## Use powershell(ps) for this because CMD commands having "%" don't work(even by escaping with "%%"). See https://github.com/appveyor/ci/issues/246.
-- ps: $env:suffix=(git show -s --format="%cd-%h" --date="format:%Y-%m-%d-%H-%M")
-- IF DEFINED APPVEYOR_REPO_TAG_NAME (
-    IF "%APPVEYOR_REPO_TAG_NAME%"=="nightly" (
-      7z a -tzip postgrest-nightly-%suffix%-windows-x64.zip postgrest.exe &&
-      bash -lc "exec 0</dev/null && cd $APPVEYOR_BUILD_FOLDER && ghr -t $GITHUB_TOKEN -u $APPVEYOR_ACCOUNT_NAME -r $APPVEYOR_PROJECT_NAME --replace nightly postgrest-nightly-$suffix-windows-x64.zip"
-    ) ELSE (
-      7z a -tzip postgrest-%APPVEYOR_REPO_TAG_NAME%-windows-x64.zip postgrest.exe &&
-      bash -lc "exec 0</dev/null && cd $APPVEYOR_BUILD_FOLDER && ghr -t $GITHUB_TOKEN -u $APPVEYOR_ACCOUNT_NAME -r $APPVEYOR_PROJECT_NAME -b \"`sed -n \"1,/$APPVEYOR_REPO_TAG_NAME/d;/## \[/q;p\" CHANGELOG.md`\" --replace $APPVEYOR_REPO_TAG_NAME postgrest-$APPVEYOR_REPO_TAG_NAME-windows-x64.zip"
-    )
-  )

default.nix

@@ -1,9 +1,11 @@
+{ system ? builtins.currentSystem }:
+
 let
   name =
     "postgrest";
 
   compiler =
-    "ghc8104";
+    "ghc924";
 
   # PostgREST source files, filtered based on the rules in the .gitignore files
   # and file extensions. We want to include as litte as possible, as the files
@@ -33,25 +35,25 @@ let
     [
       allOverlays.build-toolbox
       allOverlays.checked-shell-script
-      allOverlays.ghr
       allOverlays.gitignore
       allOverlays.postgresql-default
       allOverlays.postgresql-legacy
+      allOverlays.postgresql-future
       (allOverlays.haskell-packages { inherit compiler; })
     ];
 
   # Evaluated expression of the Nixpkgs repository.
   pkgs =
-    import nixpkgs { inherit overlays; };
+    import nixpkgs { inherit overlays system; };
 
   postgresqlVersions =
     [
-      { name = "postgresql-13"; postgresql = pkgs.postgresql_13; }
-      { name = "postgresql-12"; postgresql = pkgs.postgresql_12; }
-      { name = "postgresql-11"; postgresql = pkgs.postgresql_11; }
-      { name = "postgresql-10"; postgresql = pkgs.postgresql_10; }
-      { name = "postgresql-9.6"; postgresql = pkgs.postgresql_9_6; }
-      { name = "postgresql-9.5"; postgresql = pkgs.postgresql_9_5; }
+      { name = "postgresql-14"; postgresql = pkgs.postgresql_14.withPackages (p: [ p.postgis p.pg_safeupdate ]); }
+      { name = "postgresql-13"; postgresql = pkgs.postgresql_13.withPackages (p: [ p.postgis p.pg_safeupdate ]); }
+      { name = "postgresql-12"; postgresql = pkgs.postgresql_12.withPackages (p: [ p.postgis p.pg_safeupdate ]); }
+      { name = "postgresql-11"; postgresql = pkgs.postgresql_11.withPackages (p: [ p.postgis p.pg_safeupdate ]); }
+      { name = "postgresql-10"; postgresql = pkgs.postgresql_10.withPackages (p: [ p.postgis p.pg_safeupdate ]); }
+      { name = "postgresql-9.6"; postgresql = pkgs.postgresql_9_6.withPackages (p: [ p.postgis p.pg_safeupdate ]); }
     ];
 
   patches =
@@ -64,7 +66,7 @@ let
   # Function that derives a fully static Haskell package based on
   # nh2/static-haskell-nix
   staticHaskellPackage =
-    import nix/static-haskell-package.nix { inherit nixpkgs compiler patches allOverlays; };
+    import nix/static-haskell-package.nix { inherit nixpkgs system compiler patches allOverlays; };
 
   # Options passed to cabal in dev tools and tests
   devCabalOptions =
@@ -79,8 +81,7 @@ let
       }
     );
 
-  lib =
-    pkgs.haskell.lib;
+  inherit (pkgs.haskell) lib;
 in
 rec {
   inherit nixpkgs pkgs;
@@ -103,13 +104,12 @@ rec {
       )
     );
 
-  env =
-    postgrest.env;
+  inherit (postgrest) env;
 
   # Tooling for analyzing Haskell imports and exports.
   hsie =
     pkgs.callPackage nix/hsie {
-      ghcWithPackages = pkgs.haskell.packages.ghc884.ghcWithPackages;
+      inherit (pkgs.haskell.packages."${compiler}") ghcWithPackages;
     };
 
   ### Tools
@@ -119,12 +119,16 @@ rec {
 
   # Development tools.
   devTools =
-    pkgs.callPackage nix/tools/devTools.nix { inherit tests style devCabalOptions hsie; };
+    pkgs.callPackage nix/tools/devTools.nix { inherit tests style devCabalOptions hsie withTools; };
 
   # Docker images and loading script.
   docker =
     pkgs.callPackage nix/tools/docker { postgrest = postgrestStatic; };
 
+  # Load testing tools.
+  loadtest =
+    pkgs.callPackage nix/tools/loadtest.nix { inherit withTools; };
+
   # Script for running memory tests.
   memory =
     pkgs.callPackage nix/tools/memory.nix { inherit postgrestProfiled withTools; };
@@ -135,23 +139,21 @@ rec {
 
   # Scripts for publishing new releases.
   release =
-    pkgs.callPackage nix/tools/release {
-      inherit docker;
-      postgrest = postgrestStatic;
-    };
+    pkgs.callPackage nix/tools/release { };
 
   # Linting and styling tools.
   style =
-    pkgs.callPackage nix/tools/style.nix { };
+    pkgs.callPackage nix/tools/style.nix { inherit hsie; };
 
   # Scripts for running tests.
   tests =
     pkgs.callPackage nix/tools/tests.nix {
       inherit postgrest devCabalOptions withTools;
       ghc = pkgs.haskell.compiler."${compiler}";
-      hpc-codecov = pkgs.haskell.packages."${compiler}".hpc-codecov;
+      inherit (pkgs.haskell.packages."${compiler}") hpc-codecov;
+      inherit (pkgs.haskell.packages."${compiler}") weeder;
     };
 
   withTools =
-    pkgs.callPackage nix/tools/withTools.nix { inherit postgresqlVersions; };
+    pkgs.callPackage nix/tools/withTools.nix { inherit devCabalOptions postgresqlVersions postgrest; };
 }

main/Main.hs

@@ -2,15 +2,11 @@
 
 module Main (main) where
 
-import qualified Data.Map.Strict as M
-
 import System.IO (BufferMode (..), hSetBuffering)
 
 import qualified PostgREST.App as App
 import qualified PostgREST.CLI as CLI
 
-import PostgREST.Config (readPGRSTEnvironment)
-
 import Protolude
 
 #ifndef mingw32_HOST_OS
@@ -20,8 +16,7 @@ import qualified PostgREST.Unix as Unix
 main :: IO ()
 main = do
   setBuffering
-  hasPGRSTEnv <- not . M.null <$> readPGRSTEnvironment
-  opts <- CLI.readCLIShowHelp hasPGRSTEnv
+  opts <- CLI.readCLIShowHelp
   CLI.main installSignalHandlers runAppInSocket opts
 
 installSignalHandlers :: App.SignalHandlerInstaller

nix/README.md

@@ -80,8 +80,8 @@ postgrest-coverage                postgrest-with-postgresql-10
 postgrest-lint                    postgrest-with-postgresql-11
 postgrest-run                     postgrest-with-postgresql-12
 postgrest-style                   postgrest-with-postgresql-13
-postgrest-style-check             postgrest-with-postgresql-9.5
-postgrest-test-io                 postgrest-with-postgresql-9.6
+postgrest-style-check             postgrest-with-postgresql-9.6
+postgrest-test-io
 ...
 
 [nix-shell]$
@@ -104,8 +104,8 @@ postgrest-coverage                postgrest-with-postgresql-10
 postgrest-lint                    postgrest-with-postgresql-11
 postgrest-run                     postgrest-with-postgresql-12
 postgrest-style                   postgrest-with-postgresql-13
-postgrest-style-check             postgrest-with-postgresql-9.5
-postgrest-test-io                 postgrest-with-postgresql-9.6
+postgrest-style-check             postgrest-with-postgresql-9.6
+postgrest-test-io
 postgrest-test-memory
 ...
 
@@ -149,13 +149,13 @@ the PostgREST repo. Paths are resolved relative to the repo root:
 $ cd src
 # Even though the current directory is ./src, the config path must still start
 # from the repo root:
-$ postgrest-run test/io-tests/configs/simple.conf
+$ postgrest-run test/io/configs/simple.conf
 ```
 
 ## Testing
 
-In nix-shell, you'll find utility scripts that make it very easy to run the
-Haskell test suite, including setting up all required dependencies and
+In nix-shell, you'll find utility scripts that make it very easy to run our
+test suite, including setting up all required dependencies and
 temporary test databases:
 
 ```bash
@@ -182,7 +182,55 @@ postgrest-test-io -k config
 # Run tests in parallel using xdist, specifying the number of processes:
 postgrest-test-io -n auto
 postgrest-test-io -n 8
+```
 
+The memory tests check that we don't surpass a memory threshold for big request bodies.
+
+```bash
+# Build the dependencies needed for the memory test
+nix-shell --arg memory true
+
+# Run the memory test
+postgrest-test-memory
+```
+
+The loadtests ensure that performance doesn't drop on a change. Underlyingly they use
+[vegeta](https://github.com/tsenart/vegeta).
+
+```bash
+# Run the loadtests on the latest commit(HEAD)
+postgrest-loadtest
+
+# You can loadtest comparing to a different branch
+postgrest-loadtest-against master
+
+# Produce a markdown report to be used on CI
+postgrest-loadtest-report
+```
+
+Our query cost tests ensure that our generated queries don't surpass a threshold EXPLAIN cost.
+
+```bash
+postgrest-test-querycost
+```
+
+doctests for some of our modules are also available:
+
+```bash
+postgrest-test-doctest
+```
+
+## Code coverage
+
+Code coverage is available under the `postgrest-coverage` command. This will produce a `./coverage` directory that can be visualized with a simple http server.
+
+```bash
+# Will run all the tests and produce a coverage dir
+postgrest-coverage
+
+# Visualize the output
+cd coverage
+python -mSimpleHTTPServer 8080
 ```
 
 ## Linting and styling code

nix/hsie/Main.hs

@@ -17,12 +17,14 @@ module Main (main) where
 import qualified Data.Aeson                              as JSON
 import qualified Data.ByteString.Lazy.Char8              as LBS8
 import qualified Data.Csv                                as Csv
+import qualified Data.List                               as List
 import qualified Data.Map                                as Map
 import qualified Data.Set                                as Set
 import qualified Data.Text                               as T
 import qualified Data.Text.IO                            as T
 import qualified Dot
 import qualified GHC
+import qualified GHC.Paths
 import qualified Language.Haskell.GHC.ExactPrint.Parsers as ExactPrint
 import qualified Options.Applicative                     as O
 import qualified System.FilePath                         as FP
@@ -32,11 +34,12 @@ import Data.Function              ((&))
 import Data.List                  (intercalate)
 import Data.Maybe                 (catMaybes, mapMaybe)
 import Data.Text                  (Text)
+import GHC.Data.Bag               (bagToList)
 import GHC.Generics               (Generic)
-import HsExtension                (GhcPs)
-import Module                     (moduleNameString)
-import OccName                    (occNameString)
-import RdrName                    (rdrNameOcc)
+import GHC.Hs.Extension           (GhcPs)
+import GHC.Types.Name.Occurrence  (occNameString)
+import GHC.Types.Name.Reader      (rdrNameOcc)
+import GHC.Unit.Module.Name       (moduleNameString)
 import System.Directory.Recursive (getFilesRecursive)
 import System.Exit                (exitFailure)
 
@@ -195,21 +198,21 @@ sourceSymbols source = do
       return $ concatMap (importSymbols source filepath . GHC.unLoc) hsmodImports
 
 -- | Parse a Haskell module
-parseModule :: String -> IO (GHC.HsModule GhcPs)
+parseModule :: FilePath -> IO GHC.HsModule
 parseModule filepath = do
-  result <- ExactPrint.parseModule filepath
+  result <- ExactPrint.parseModule GHC.Paths.libdir filepath
   case result of
-    Right (_, hsmod) ->
+    Right hsmod ->
       return $ GHC.unLoc hsmod
-    Left (loc, err) ->
-      fail $ "Error with " <> show filepath <> " at " <> show loc <> ": " <> err
+    Left errs ->
+      fail $ "Errors with " <> show filepath <> ":\n    "
+        <> List.intercalate "\n    " (show <$> bagToList errs)
 
 -- | Symbols imported in an import declaration.
 --
 -- If the import is a wildcard, i.e. no symbols are selected for import, then
 -- only one item is returned.
 importSymbols :: FilePath -> FilePath -> GHC.ImportDecl GhcPs -> [ImportedSymbol]
-importSymbols _ _  (GHC.XImportDecl _) = mempty
 importSymbols source filepath GHC.ImportDecl{..} =
   case ideclHiding of
     Just (hiding, syms) ->
@@ -223,7 +226,7 @@ importSymbols source filepath GHC.ImportDecl{..} =
         , impSource = source
         , impFromModule = T.pack $ moduleFromPath filepath
         , impModule = T.pack . moduleNameString . GHC.unLoc $ ideclName
-        , impQualified = if ideclQualified then Qualified else NotQualified
+        , impQualified = if ideclQualified /= GHC.NotQualified then Qualified else NotQualified
         , impAlias = T.pack . moduleNameString . GHC.unLoc <$> ideclAs
         , impInternal = External
         , impType = hiding

nix/hsie/default.nix

@@ -16,15 +16,20 @@ let
   ghc = ghcWithPackages modules;
   hsie =
     runCommand "haskellimports" { inherit name src; }
-      "${ghc}/bin/ghc -O -Werror -Wall -package ghc $src -o $out";
+      ''
+        cd $TMP
+        cp $src $TMP/Main.hs
+        ${ghc}/bin/ghc -O -Werror -Wall -package ghc Main.hs -o Main
+        cp Main $out
+      '';
   bin =
     runCommand name { inherit hsie name; }
       ''
         mkdir -p $out/bin
         ln -s $hsie $out/bin/$name
       '';
-  bashCompletion =
+  bash-completion =
     runCommand "${name}-bash-completion" { inherit bin name; }
       "$bin/bin/$name --bash-completion-script $bin/bin/$name > $out";
 in
-hsie // { inherit bashCompletion bin; }
+hsie // { inherit bash-completion bin; }

nix/nixpkgs-version.nix

@@ -1,6 +1,6 @@
 # Pinned version of Nixpkgs, generated with postgrest-nixpkgs-upgrade.
 {
-  date = "2021-07-17";
-  rev = "d00b5a5fa6fe8bdf7005abb06c46ae0245aec8b5";
-  tarballHash = "08497wbpnf3w5dalcasqzymw3fmcn8qrnbkf8rxxwwvyjdnczxdv";
+  date = "2022-08-09";
+  rev = "9f15d6c3a74d2778c6e1af67947c95f100dc6fd2";
+  tarballHash = "14axdmi3kb6rlib39ik42yq907bm66x6vzswm5w1rsnw9vzgm31a";
 }

nix/overlays/build-toolbox/build-toolbox.nix

@@ -1,11 +1,11 @@
-# Creates an environment that exposes bashCompletion arguments from all checkedShellScripts
+# Creates an environment that exposes bash-completion arguments from all checkedShellScripts
 { buildEnv }:
 { name
 , tools
 , extra ? { }
 }:
 let
-  bashCompletion = builtins.map (tool: tool.bashCompletion) tools;
+  bash-completion = builtins.map (tool: tool.bash-completion) tools;
 
   env = buildEnv {
     inherit name;
@@ -13,4 +13,4 @@ let
   };
 
 in
-env // { inherit bashCompletion; } // extra
+env // { inherit bash-completion; } // extra

nix/overlays/checked-shell-script/checked-shell-script.nix

@@ -14,18 +14,18 @@
 { name
 , docs
 , args ? [ ]
-, addCommandCompletion ? false
+, positionalCompletion ? ""
 , inRootDir ? false
 , redirectTixFiles ? true
 , withEnv ? null
+, withPath ? [ ]
 , withTmpDir ? false
 }: text:
 let
+  # square brackets are a pain to escape - if even possible. just don't use them...
+  escape = builtins.replaceStrings [ "\n" ] [ " \\n" ];
+
   argsTemplate =
-    let
-      # square brackets are a pain to escape - if even possible. just don't use them...
-      escapedDocs = builtins.replaceStrings [ "\n" ] [ " \\n" ] docs;
-    in
     writeTextFile {
       inherit name;
       destination = "/${name}.m4"; # destination is needed to have the proper basename for completion
@@ -36,7 +36,7 @@ let
           # stripping the /nix/store/... path for nicer display
           BASH_ARGV0="$(basename "$0")"
 
-          # ARG_HELP([${name}], [${escapedDocs}])
+          # ARG_HELP([${name}], [${escape docs}])
           ${lib.strings.concatMapStrings (arg: "# " + arg) args}
           # ARG_POSITIONAL_DOUBLEDASH()
           # ARG_DEFAULTS_POS()
@@ -58,14 +58,14 @@ let
         sed '/_positionals_count + 1/a\\t\t\t\tset -- "''${@:1:1}" "--" "''${@:2}"' -i $out
       '';
 
-  bashCompletion =
+  bash-completion =
     runCommand "${name}-completion" { } (
       ''
         ${argbash}/bin/argbash --type completion --strip all ${argsTemplate}/${name}.m4 > $out
       ''
 
-      + lib.optionalString addCommandCompletion ''
-        sed 's/COMPREPLY.*compgen -o bashdefault .*$/_command/' -i $out
+      + lib.optionalString (positionalCompletion != "") ''
+        sed 's#COMPREPLY.*compgen -o bashdefault .*$#${escape positionalCompletion}#' -i $out
       ''
     );
 
@@ -114,6 +114,10 @@ let
           export PATH="$env/bin:$PATH"
         ''
 
+        + lib.optionalString (lib.length withPath > 0) ''
+          export PATH="${lib.concatMapStrings (p: p + "/bin:") withPath}$PATH"
+        ''
+
         + "(${text})"
 
         + lib.optionalString withTmpDir ''
@@ -134,4 +138,4 @@ let
   script =
     runCommand name { inherit bin name; } "ln -s $bin/bin/$name $out";
 in
-script // { inherit bin bashCompletion; }
+script // { inherit bin bash-completion; }

nix/overlays/default.nix

@@ -1,9 +1,9 @@
 {
   build-toolbox = import ./build-toolbox;
   checked-shell-script = import ./checked-shell-script;
-  ghr = import ./ghr;
   gitignore = import ./gitignore.nix;
   haskell-packages = import ./haskell-packages.nix;
   postgresql-default = import ./postgresql-default.nix;
   postgresql-legacy = import ./postgresql-legacy.nix;
+  postgresql-future = import ./postgresql-future.nix;
 }

nix/overlays/ghr/default.nix

@@ -1,7 +0,0 @@
-self: super:
-# Overlay that adds `ghr`: Upload multiple artifacts to GitHub Release in
-# parallel, http://tcnksm.github.io/ghr/
-
-{
-  ghr = super.callPackage ./ghr.nix { };
-}

nix/overlays/ghr/ghr.nix

@@ -1,18 +0,0 @@
-{ buildGoModule, fetchFromGitHub }:
-
-buildGoModule rec {
-  pname = "ghr";
-  version = "0.14.0";
-
-  src = fetchFromGitHub {
-    rev = "v${version}";
-    owner = "tcnksm";
-    repo = "ghr";
-    sha256 = "1jjc3bwmyw831r1ayic1f1ysh5ggm88aszbndm0swg8byhz56pd4";
-  };
-
-  vendorSha256 = "06cbhsnxv4gisnwrhw61af7rpv2a9slf9z2wbn79r91xzkh51vzr";
-
-  # Disabling tests, as they require a GitHub API token
-  doCheck = false;
-}

nix/overlays/gitignore.nix

@@ -12,8 +12,8 @@ self: super:
       gitignoreSrc = super.fetchFromGitHub {
         owner = "hercules-ci";
         repo = "gitignore";
-        rev = "211907489e9f198594c0eb0ca9256a1949c9d412";
-        sha256 = "06j7wpvj54khw0z10fjyi31kpafkr6hi1k0di13k1xp8kywvfyx8";
+        rev = "a20de23b925fd8264fd7fad6454652e142fd7f73";
+        sha256 = "sha256-8DFJjXG8zqoONA1vXtgeKXy68KdJL5UaXR8NtVMUbx8=";
       };
     in
     (super.callPackage gitignoreSrc { }).gitignoreSource;

nix/overlays/haskell-packages.nix

@@ -2,8 +2,7 @@
 
 self: super:
 let
-  lib =
-    self.haskell.lib;
+  inherit (self.haskell) lib;
 
   overrides =
     final: prev:
@@ -21,14 +20,17 @@ let
       # To get the sha256:
       #   nix-prefetch-url --unpack https://hackage.haskell.org/package/protolude-0.3.0/protolude-0.3.0.tar.gz
 
-      hasql-dynamic-statements =
-        lib.dontCheck (lib.unmarkBroken prev.hasql-dynamic-statements);
-
-      hasql-implicits =
-        lib.dontCheck (lib.unmarkBroken prev.hasql-implicits);
-
-      ptr =
-        lib.dontCheck (lib.unmarkBroken prev.ptr);
+      # To temporarily pin unreleased versions from GitHub:
+      #   <name> =
+      #     prev.callCabal2nixWithOptions "<name>" (super.fetchFromGitHub {
+      #       owner = "<owner>";
+      #       repo  = "<repo>";
+      #       rev = "<commit>";
+      #       sha256 = "<sha256>";
+      #    }) "--subpath=<subpath>" {};
+      #
+      # To get the sha256:
+      #   nix-prefetch-url --unpack https://github.com/<owner>/<repo>/archive/<commit>.tar.gz
     } // extraOverrides final prev;
 in
 {

nix/overlays/postgresql-default.nix

@@ -1,5 +1,5 @@
 self: super:
 # Overlay that sets the default version of PostgreSQL.
 {
-  postgresql = super.postgresql_13;
+  postgresql = super.postgresql_14;
 }

nix/overlays/postgresql-future.nix

@@ -0,0 +1,19 @@
+self: super:
+# Overlay that adds future versions of PostgreSQL that are supported by
+# PostgREST.
+{
+  ## Example for including a postgresql version from a specific nixpks commit:
+  ##
+  #  postgresql_14 =
+  #    let
+  #      rev = "76b1e16c6659ccef7187ca69b287525fea133244";
+  #      tarballHash = "1vsahpcx80k2bgslspb0sa6j4bmhdx77sw6la455drqcrqhdqj6a";
+  #
+  #      pinnedPkgs =
+  #        builtins.fetchTarball {
+  #          url = "https://github.com/nixos/nixpkgs/archive/${rev}.tar.gz";
+  #          sha256 = tarballHash;
+  #        };
+  #    in
+  #    (import pinnedPkgs { }).pkgs.postgresql_14;
+}

nix/overlays/postgresql-legacy.nix

@@ -2,19 +2,18 @@ self: super:
 # Overlay that adds legacy versions of PostgreSQL that are supported by
 # PostgREST.
 {
-  # PostgreSQL 9.5 was removed from Nixpkgs with
-  # https://github.com/NixOS/nixpkgs/commit/72ab382fb6b729b0d654f2c03f5eb25b39f11fbb
+  # PostgreSQL 9.6 was removed from Nixpkgs with
+  # https://github.com/NixOS/nixpkgs/commit/757dd008b2f2926fc0f7688fa8189f930ea47521
   # We pin its parent commit to get the last version that was available.
-  postgresql_9_5 =
+  postgresql_9_6 =
     let
-      rev = "55ac7d4580c9ab67848c98cb9519317a1cc399c8";
-      tarballHash = "02ffj9f8s1hwhmxj85nx04sv64qb6jm7w0122a1dz9n32fymgklj";
-
+      rev = "571cbf3d1db477058303cef8754fb85a14e90eb7";
+      tarballHash = "0q74wn418i1bn5sssacmw8ykpmqvzr0s93sj6pbs3rf6bf134fkz";
       pinnedPkgs =
         builtins.fetchTarball {
           url = "https://github.com/nixos/nixpkgs/archive/${rev}.tar.gz";
           sha256 = tarballHash;
         };
     in
-    (import pinnedPkgs { }).pkgs.postgresql_9_5;
+    (import pinnedPkgs { }).pkgs.postgresql_9_6;
 }

nix/patches/default.nix

@@ -18,7 +18,8 @@
         done
       '';
 
-  # See: https://github.com/NixOS/nixpkgs/pull/87879
-  nixpkgs-openssl-split-runtime-dependencies-of-static-builds =
-    ./nixpkgs-openssl-split-runtime-dependencies-of-static-builds.patch;
+  static-haskell-nix-ncurses =
+    ./static-haskell-nix-ncurses.patch;
+  static-haskell-nix-ghc-bignum =
+    ./static-haskell-nix-ghc-bignum.patch;
 }

nix/patches/nixpkgs-openssl-split-runtime-dependencies-of-static-builds.patch

@@ -1,76 +0,0 @@
-diff --git a/pkgs/development/libraries/openssl/default.nix b/pkgs/development/libraries/openssl/default.nix
-index d4be8cc2428..3979698711f 100644
---- a/pkgs/development/libraries/openssl/default.nix
-+++ b/pkgs/development/libraries/openssl/default.nix
-@@ -50,9 +50,21 @@ let
-       substituteInPlace crypto/async/arch/async_posix.h \
-         --replace '!defined(__ANDROID__) && !defined(__OpenBSD__)' \
-                   '!defined(__ANDROID__) && !defined(__OpenBSD__) && 0'
-+    '' + optionalString static
-+    # On static builds, the ENGINESDIR will be empty, but its path will be
-+    # compiled into the library. In order to minimize the runtime dependencies
-+    # of packages that statically link openssl, we move it into the OPENSSLDIR,
-+    # which will be separated into the 'etc' output.
-+    ''
-+      substituteInPlace Configurations/unix-Makefile.tmpl \
-+        --replace 'ENGINESDIR=$(libdir)/engines-{- $sover_dirname -}' \
-+                  'ENGINESDIR=$(OPENSSLDIR)/engines-{- $sover_dirname -}'
-     '';
- 
--    outputs = [ "bin" "dev" "out" "man" ] ++ optional withDocs "doc";
-+    outputs = [ "bin" "dev" "out" "man" ]
-+      ++ optional withDocs "doc"
-+      # Separate output for the runtime dependencies of the static build.
-+      ++ optional static "etc";
-     setOutputFlags = false;
-     separateDebugInfo =
-       !stdenv.hostPlatform.isDarwin &&
-@@ -101,7 +113,17 @@ let
-     configureFlags = [
-       "shared" # "shared" builds both shared and static libraries
-       "--libdir=lib"
--      "--openssldir=etc/ssl"
-+      (if !static then
-+         "--openssldir=etc/ssl"
-+       else
-+         # Separate the OPENSSLDIR into its own output, as its path will be
-+         # compiled into 'libcrypto.a'. This makes it a runtime dependency of
-+         # any package that statically links openssl, so we want to keep that
-+         # output minimal. We need to prepend '/.' to the path in order to make
-+         # it appear absolute before variable expansion, the 'prefix' would be
-+         # prepended to it otherwise.
-+         "--openssldir=/.$(etc)/etc/ssl"
-+      )
-     ] ++ lib.optionals withCryptodev [
-       "-DHAVE_CRYPTODEV"
-       "-DUSE_CRYPTODEV_DIGESTS"
-@@ -131,6 +153,9 @@ let
-       if [ -n "$(echo $out/lib/*.so $out/lib/*.dylib $out/lib/*.dll)" ]; then
-           rm "$out/lib/"*.a
-       fi
-+
-+      # 'etc' is a separate output on static builds only.
-+      etc=$out
-     '' + lib.optionalString (!stdenv.hostPlatform.isWindows)
-       # Fix bin/c_rehash's perl interpreter line
-       #
-@@ -152,14 +177,15 @@ let
-       mv $out/include $dev/
- 
-       # remove dependency on Perl at runtime
--      rm -r $out/etc/ssl/misc
-+      rm -r $etc/etc/ssl/misc
- 
--      rmdir $out/etc/ssl/{certs,private}
-+      rmdir $etc/etc/ssl/{certs,private}
-     '';
- 
-     postFixup = lib.optionalString (!stdenv.hostPlatform.isWindows) ''
--      # Check to make sure the main output doesn't depend on perl
--      if grep -r '${buildPackages.perl}' $out; then
-+      # Check to make sure the main output and the static runtime dependencies
-+      # don't depend on perl
-+      if grep -r '${buildPackages.perl}' $out $etc; then
-         echo "Found an erroneous dependency on perl ^^^" >&2
-         exit 1
-       fi

nix/patches/static-haskell-nix-ghc-bignum.patch

@@ -0,0 +1,12 @@
+diff --git a/survey/default.nix b/survey/default.nix
+index 70afbbc..28cb0e9 100644
+--- a/survey/default.nix
++++ b/survey/default.nix
+@@ -81,6 +81,7 @@ let
+   # `.override` and the likes).
+   isProperHaskellPackage = val:
+     lib.isDerivation val && # must pass lib.isDerivation
++    val.pname != "ghc-bignum" &&
+     val ? env; # must have an .env key
+ 
+   # Function that tells us if a given Haskell package has an executable.

nix/patches/static-haskell-nix-ncurses.patch

@@ -0,0 +1,13 @@
+diff --git a/survey/default.nix b/survey/default.nix
+index 46d8066..a47f214 100644
+--- a/survey/default.nix
++++ b/survey/default.nix
+@@ -1519,7 +1519,7 @@ let
+                   [
+                     "--enable-executable-static" # requires `useFixedCabal`
+                     # `enableShared` seems to be required to avoid `recompile with -fPIC` errors on some packages.
+-                    "--extra-lib-dirs=${final.ncurses.override { enableStatic = true; enableShared = true; }}/lib"
++                    "--extra-lib-dirs=${final.ncurses.override { enableStatic = true; }}/lib"
+                   ]
+                   # TODO Figure out why this and the below libffi are necessary.
+                   #      `working` and `workingStackageExecutables` don't seem to need that,

nix/static-haskell-package.nix

@@ -1,5 +1,5 @@
 # Derive a fully static Haskell package based on musl instead of glibc.
-{ nixpkgs, compiler, patches, allOverlays }:
+{ nixpkgs, system, compiler, patches, allOverlays }:
 
 name: src:
 let
@@ -17,14 +17,8 @@ let
     patches.applyPatches "patched-static-haskell-nix"
       static-haskell-nix
       [
-        # No patches currently required.
-      ];
-
-  patchedNixpkgs =
-    patches.applyPatches "patched-nixpkgs"
-      nixpkgs
-      [
-        patches.nixpkgs-openssl-split-runtime-dependencies-of-static-builds
+        patches.static-haskell-nix-ncurses
+        patches.static-haskell-nix-ghc-bignum
       ];
 
   extraOverrides =
@@ -39,16 +33,29 @@ let
 
   overlays =
     [
+      allOverlays.postgresql-future
+      allOverlays.postgresql-default
       (allOverlays.haskell-packages { inherit compiler extraOverrides; })
+      # Disable failing tests for postgresql on musl that should have no impact
+      # on the libpq that we need (collate.icu.utf8 and foreign regression
+      # tests)
+      (self: super:
+        { postgresql = super.postgresql.overrideAttrs (_: { doCheck = false; }); }
+      )
     ];
 
-  # Apply our overlay to the given pkgs.
+  # Apply our overlay to nixpkgs.
   normalPkgs =
-    import patchedNixpkgs { inherit overlays; };
+    import nixpkgs { inherit overlays system; };
+
+  defaultCabalPackageVersionComingWithGhc =
+    {
+      ghc924 = "Cabal_3_6_3_0";
+    }."${compiler}";
 
   # The static-haskell-nix 'survey' derives a full static set of Haskell
   # packages, applying fixes where necessary.
   survey =
-    import "${patched-static-haskell-nix}/survey" { inherit normalPkgs compiler; };
+    import "${patched-static-haskell-nix}/survey" { inherit normalPkgs compiler defaultCabalPackageVersionComingWithGhc; };
 in
 survey.haskellPackages."${name}"

nix/tools/cabalTools.nix

@@ -28,6 +28,8 @@ let
       ''
         # clean old coverage data, too
         rm -rf .hpc coverage
+        # clean old hie files
+        find . -name "*.hie" -type f -delete
         exec ${cabal-install}/bin/cabal v2-clean
       '';
 

nix/tools/devTools.nix

@@ -4,12 +4,16 @@
 , checkedShellScript
 , devCabalOptions
 , entr
+, git
+, gnugrep
 , graphviz
+, haskellPackages
 , hsie
 , nix
 , silver-searcher
 , style
 , tests
+, withTools
 }:
 let
   watch =
@@ -28,7 +32,7 @@ let
             "ARG_POSITIONAL_SINGLE([command], [Command to run])"
             "ARG_LEFTOVERS([command arguments])"
           ];
-        addCommandCompletion = true;
+        positionalCompletion = "_command";
         redirectTixFiles = false; # will be done by sub-command
         inRootDir = true;
       }
@@ -63,21 +67,172 @@ let
         name = "postgrest-check";
         docs =
           ''
-            Run most checks that will also run on CI.
+            Run most checks that will also run on CI, but only against the
+            latest PostgreSQL version.
 
-            This currently excludes the memory tests, as those are particularly
-            expensive.
+            This currently excludes the memory and spec-idempotence tests,
+            as those are particularly expensive.
           '';
         inRootDir = true;
       }
       ''
-        ${tests}/bin/postgrest-with-all ${tests}/bin/postgrest-test-spec
-        ${tests}/bin/postgrest-test-spec-idempotence
+        ${tests}/bin/postgrest-test-spec
+        ${tests}/bin/postgrest-test-querycost
+        ${tests}/bin/postgrest-test-doctests
         ${tests}/bin/postgrest-test-io
         ${style}/bin/postgrest-lint
         ${style}/bin/postgrest-style-check
       '';
 
+  gitHooks =
+    let
+      name = "postgrest-git-hooks";
+    in
+    checkedShellScript
+      {
+        inherit name;
+        docs =
+          ''
+            Enable or disable git pre-commit and pre-push hooks.
+
+            Basic is faster and will only run:
+              - pre-commit: postgrest-style
+              - pre-push: postgrest-lint
+
+            Full takes a lot more time and will run:
+              - pre-commit: postgrest-style && postgrest-lint
+              - pre-push: postgrest-check
+
+            Changes made by postgrest-style will be staged automatically.
+
+            Example usage:
+              postgrest-git-hooks disable
+              postgrest-git-hooks enable basic
+              postgrest-git-hooks enable full
+
+            The "run" operation and "--hook" argument are only used internally.
+          '';
+        args =
+          [
+            "ARG_POSITIONAL_SINGLE([operation], [Operation])"
+            "ARG_TYPE_GROUP_SET([OPERATION], [OPERATION], [operation], [disable,enable,run])"
+            "ARG_POSITIONAL_SINGLE([mode], [Mode], [basic])"
+            "ARG_TYPE_GROUP_SET([MODE], [MODE], [mode], [basic,full])"
+            "ARG_OPTIONAL_SINGLE([hook], , [Hook], [pre-commit])"
+            "ARG_TYPE_GROUP_SET([HOOK], [HOOK], [hook], [pre-commit,pre-push])"
+          ];
+        positionalCompletion =
+          ''
+            if test "$prev" == "${name}"; then
+              COMPREPLY=( $(compgen -W "enable disable" -- "$cur") )
+            elif test "$prev" == "enable" || test "$prev" == "disable"; then
+              COMPREPLY=( $(compgen -W "basic full" -- "$cur") )
+            fi
+          '';
+        inRootDir = true;
+      }
+      ''
+        if [ run != "$_arg_operation" ]; then
+          # Remove all hooks first and ignore failures because the file might be missing.
+          # This assumes that we're only adding lines that include "postgrest-git-hooks"
+          # to the hook file.
+          sed -i -e '/postgrest-git-hooks/d' .git/hooks/pre-{commit,push} 2> /dev/null || true
+
+          if [ disable != "$_arg_operation" ]; then
+            # The nix-shell && + nix-shell || pattern makes sure we can run the hook
+            # in a pure nix-shell, where nix-shell itself is not available, too.
+
+            # The $(nix-shell --run "command -v ...") pattern ensures we only need to enable
+            # the hooks once and still run the latest of our hook scripts, even when we
+            # update them in the repo.
+
+            echo 'command -v nix-shell > /dev/null || postgrest-git-hooks --hook=pre-commit run' "$_arg_mode" \
+              >> .git/hooks/pre-commit
+            # shellcheck disable=SC2016
+            echo 'command -v nix-shell > /dev/null && $(nix-shell --quiet -Q --run "command -v postgrest-git-hooks") --hook=pre-commit run' "$_arg_mode" \
+             >> .git/hooks/pre-commit
+            chmod +x .git/hooks/pre-commit
+
+            echo 'command -v nix-shell > /dev/null || postgrest-git-hooks --hook=pre-push run' "$_arg_mode" \
+              >> .git/hooks/pre-push
+            # shellcheck disable=SC2016
+            echo 'command -v nix-shell > /dev/null && $(nix-shell --quiet -Q --run "command -v postgrest-git-hooks") --hook=pre-push run' "$_arg_mode" \
+             >> .git/hooks/pre-push
+            chmod +x .git/hooks/pre-push
+          fi
+        else
+          # When run from a git hook, the GIT_ environment variables conflict with our withGit helper.
+          # The following unsets all GIT_ variables.
+          unset "''${!GIT_@}"
+
+          function restore () {
+            ref="$(git stash list --format=format:%gD --grep "$1" -n1)"
+            # this will avoid merge conflicts when applying the stash
+            ${git}/bin/git restore --source="$ref" .
+            # restore untracked files, too. could fail with no files
+            if [ "$(git show --numstat --format=oneline "$ref^3" | wc -l)" -gt 1 ]; then
+              ${git}/bin/git restore --overlay --source="$ref^3" .
+            fi
+            ${git}/bin/git stash drop "$ref"
+          }
+
+          case "$_arg_mode" in
+            basic)
+              case "$_arg_hook" in
+                pre-commit)
+                  # To be able to automatically add only changes from postgrest-style to the staging area,
+                  # we need to run postgrest-style twice. Otherwise we'd risk merge conflicts when popping
+                  # the stash afterwards.
+                  ${style}/bin/postgrest-style
+
+                  stash="postgrest-git-hooks-$RANDOM"
+                  ${git}/bin/git stash push --include-untracked --keep-index -m "$stash"
+                  if [ "$(git stash list --grep $stash)" ]; then
+                    # Only create the stash pop trap, if we actually created a stash.
+                    # Otherwise stash pop will cause havoc.
+                    trap 'restore "$stash"' EXIT
+                  fi
+
+                  ${style}/bin/postgrest-style
+                  ${git}/bin/git add .
+                  ;;
+                pre-push)
+                  # Create a clean working tree without any uncomitted changes.
+                  ${withTools.withGit} HEAD ${style}/bin/postgrest-lint
+                  ;;
+              esac
+              ;;
+            full)
+              case "$_arg_hook" in
+                pre-commit)
+                  # To be able to automatically add only changes from postgrest-style to the staging area,
+                  # we need to run postgrest-style twice. Otherwise we'd risk merge conflicts when popping
+                  # the stash afterwards.
+                  ${style}/bin/postgrest-style
+
+                  stash="postgrest-git-hooks-$RANDOM"
+                  ${git}/bin/git stash push --include-untracked --keep-index -m "$stash"
+                  if [ "$(git stash list --grep $stash)" ]; then
+                    # Only create the stash pop trap, if we actually created a stash.
+                    # Otherwise stash pop will cause havoc.
+                    trap 'restore "$stash"' EXIT
+                  fi
+
+                  ${style}/bin/postgrest-style
+                  ${git}/bin/git add .
+
+                  ${style}/bin/postgrest-lint
+                  ;;
+                pre-push)
+                  # Create a clean working tree without any uncomitted changes.
+                  ${withTools.withGit} HEAD ${check}
+                  ;;
+              esac
+              ;;
+          esac
+        fi
+      '';
+
   dumpMinimalImports =
     checkedShellScript
       {
@@ -143,6 +298,7 @@ buildToolbox
     watch
     pushCachix
     check
+    gitHooks
     dumpMinimalImports
     hsieMinimalImports
     hsieGraphModules

nix/tools/loadtest.nix

@@ -0,0 +1,178 @@
+{ buildToolbox
+, checkedShellScript
+, jq
+, python3Packages
+, vegeta
+, withTools
+, writers
+}:
+let
+  runner =
+    checkedShellScript
+      {
+        name = "postgrest-loadtest-runner";
+        docs = "Run vegeta. Assume PostgREST to be running.";
+        args = [
+          "ARG_LEFTOVERS([additional vegeta arguments])"
+          "ARG_USE_ENV([PGRST_SERVER_UNIX_SOCKET], [], [Unix socket to connect to running PostgREST instance])"
+        ];
+      }
+      ''
+        # ARG_USE_ENV only adds defaults or docs for environment variables
+        # We manually implement a required check here
+        # See also: https://github.com/matejak/argbash/issues/80
+        : "''${PGRST_SERVER_UNIX_SOCKET:?PGRST_SERVER_UNIX_SOCKET is required}"
+
+        ${vegeta}/bin/vegeta -cpus 1 attack \
+                                     -unix-socket "$PGRST_SERVER_UNIX_SOCKET" \
+                                     -max-workers 1 \
+                                     -workers 1 \
+                                     -rate 0 \
+                                     -duration 60s \
+                                     "''${_arg_leftovers[@]}"
+      '';
+
+  loadtest =
+    checkedShellScript
+      {
+        name = "postgrest-loadtest";
+        docs = "Run the vegeta loadtests with PostgREST.";
+        args = [
+          "ARG_OPTIONAL_SINGLE([output], [o], [Filename to dump json output to], [./loadtest/result.bin])"
+          "ARG_OPTIONAL_SINGLE([testdir], [t], [Directory to load tests and fixtures from], [./test/load])"
+          "ARG_LEFTOVERS([additional vegeta arguments])"
+        ];
+        inRootDir = true;
+      }
+      ''
+        # previously required settings to make this work with older branches
+        export PGRST_DB_ANON_ROLE="postgrest_test_anonymous"
+        export PGRST_DB_URI="postgresql://"
+        export PGRST_DB_SCHEMAS="test"
+
+        export PGRST_DB_CONFIG="false"
+        export PGRST_DB_POOL="1"
+        export PGRST_DB_TX_END="rollback-allow-override"
+        export PGRST_LOG_LEVEL="crit"
+
+        mkdir -p "$(dirname "$_arg_output")"
+
+        # shellcheck disable=SC2145
+        ${withTools.withPg} --fixtures "$_arg_testdir"/fixtures.sql \
+        ${withTools.withPgrst} \
+        sh -c "cd \"$_arg_testdir\" && ${runner} -targets targets.http -output \"$_arg_output\" \"''${_arg_leftovers[@]}\""
+        ${vegeta}/bin/vegeta report -type=text "$_arg_output"
+      '';
+
+  loadtestAgainst =
+    let
+      name = "postgrest-loadtest-against";
+    in
+    checkedShellScript
+      {
+        inherit name;
+        docs =
+          ''
+            Run the vegeta loadtest twice:
+            - once on the <target> branch
+            - once in the current worktree
+          '';
+        args = [
+          "ARG_POSITIONAL_SINGLE([target], [Commit-ish reference to compare with])"
+          "ARG_LEFTOVERS([additional vegeta arguments])"
+        ];
+        positionalCompletion =
+          ''
+            if test "$prev" == "${name}"; then
+              __gitcomp_nl "$(__git_refs)"
+            fi
+          '';
+        inRootDir = true;
+      }
+      ''
+        cat << EOF
+
+        Running loadtest on "$_arg_target"...
+
+        EOF
+
+        # Runs the test files from the current working tree
+        # to make sure both tests are run with the same files.
+        # Save the results in the current working tree, too,
+        # otherwise they'd be lost in the temporary working tree
+        # created by withTools.withGit.
+        ${withTools.withGit} "$_arg_target" ${loadtest} --output "$PWD/loadtest/$_arg_target.bin" --testdir "$PWD/test/load" "''${_arg_leftovers[@]}"
+
+        cat << EOF
+
+        Done running on "$_arg_target".
+
+        EOF
+
+        cat << EOF
+
+        Running loadtest on HEAD...
+
+        EOF
+
+        ${loadtest} --output "$PWD/loadtest/head.bin" --testdir "$PWD/test/load" "''${_arg_leftovers[@]}"
+
+        cat << EOF
+
+        Done running on HEAD.
+
+        EOF
+      '';
+
+  reporter =
+    checkedShellScript
+      {
+        name = "postgrest-loadtest-reporter";
+        docs = "Create a named json report for a single result file.";
+        args = [
+          "ARG_POSITIONAL_SINGLE([file], [Filename of result to create report for])"
+          "ARG_LEFTOVERS([additional vegeta arguments])"
+        ];
+        inRootDir = true;
+      }
+      ''
+        ${vegeta}/bin/vegeta report -type=json "$_arg_file" \
+          | ${jq}/bin/jq --arg branch "$(basename "$_arg_file" .bin)" '. + {branch: $branch}'
+      '';
+
+  toMarkdown =
+    writers.writePython3 "postgrest-loadtest-to-markdown"
+      {
+        libraries = [ python3Packages.pandas python3Packages.tabulate ];
+      }
+      ''
+        import sys
+        import pandas as pd
+
+        pd.read_json(sys.stdin) \
+          .set_index('param') \
+          .drop(['branch', 'earliest', 'end', 'latest']) \
+          .convert_dtypes() \
+          .to_markdown(sys.stdout, floatfmt='.0f')
+      '';
+
+
+  report =
+    checkedShellScript
+      {
+        name = "postgrest-loadtest-report";
+        docs = "Create a report of all loadtest reports as markdown.";
+        inRootDir = true;
+      }
+      ''
+        find loadtest -type f -iname '*.bin' -exec ${reporter} {} \; \
+          | ${jq}/bin/jq '[leaf_paths as $path | {param: $path | join("."), (.branch): getpath($path)}]' \
+          | ${jq}/bin/jq --slurp 'flatten | group_by(.param) | map(add)' \
+          | ${toMarkdown}
+      '';
+
+in
+buildToolbox {
+  name = "postgrest-loadtest";
+  tools = [ loadtest loadtestAgainst report ];
+}

nix/tools/memory.nix

@@ -14,11 +14,10 @@ let
         name = "postgrest-test-memory";
         docs = "Run the memory tests.";
         inRootDir = true;
+        withPath = [ postgrestProfiled curl ];
       }
       ''
-        export PATH="${postgrestProfiled}/bin:${curl}/bin:$PATH"
-
-        ${withTools.latest} test/memory-tests.sh
+        ${withTools.withPg} test/memory/memory-tests.sh
       '';
 
 in

nix/tools/nixpkgsTools.nix

@@ -14,13 +14,13 @@ let
     "postgrest-nixpkgs-upgrade";
 
   refUrl =
-    https://api.github.com/repos/nixos/nixpkgs/git/ref/heads/nixpkgs-unstable;
+    "https://api.github.com/repos/nixos/nixpkgs/git/ref/heads/nixpkgs-unstable";
 
   githubV3Header =
     "Accept: application/vnd.github.v3+json";
 
   tarballUrlBase =
-    https://github.com/nixos/nixpkgs/archive/;
+    "https://github.com/nixos/nixpkgs/archive/";
 
   upgrade =
     checkedShellScript

nix/tools/release/default.nix

@@ -1,124 +1,9 @@
 { buildToolbox
 , checkedShellScript
 , curl
-, docker
-, envsubst
-, ghr
-, git
 , jq
-, postgrest
-, runCommand
 }:
 let
-  github =
-    checkedShellScript
-      {
-        name = "postgrest-release-github";
-        docs = "Push a new release to GitHub.";
-        args = [
-          "ARG_POSITIONAL_SINGLE([version], [git version tag to make release for])"
-          "ARG_USE_ENV([GITHUB_TOKEN], [], [GitHub token])"
-          "ARG_USE_ENV([GITHUB_USERNAME], [], [GitHub user name])"
-          "ARG_USE_ENV([GITHUB_REPONAME], [], [GitHub repository name])"
-        ];
-        inRootDir = true;
-      }
-      ''
-        # ARG_USE_ENV only adds defaults or docs for environment variables
-        # We manually implement a required check here
-        # See also: https://github.com/matejak/argbash/issues/80
-        GITHUB_TOKEN="''${GITHUB_TOKEN:?GITHUB_TOKEN is required}"
-        GITHUB_USERNAME="''${GITHUB_USERNAME:?GITHUB_USERNAME is required}"
-        GITHUB_REPONAME="''${GITHUB_REPONAME:?GITHUB_REPONAME is required}"
-
-        if test "$_arg_version" = "nightly"
-        then
-          suffix=$(${git}/bin/git show -s --format="%cd-%h" --date="format:%Y-%m-%d-%H-%M")
-          tar cvJf "postgrest-nightly-$suffix-linux-x64-static.tar.xz" \
-            -C ${postgrest}/bin postgrest
-
-          ${ghr}/bin/ghr \
-            -t "$GITHUB_TOKEN" \
-            -u "$GITHUB_USERNAME" \
-            -r "$GITHUB_REPONAME" \
-            --replace nightly \
-            "postgrest-nightly-$suffix-linux-x64-static.tar.xz"
-        else
-          changes="$(sed -n "1,/$_arg_version/d;/## \[/q;p" ${../../../CHANGELOG.md})"
-
-          tar cvJf "postgrest-$_arg_version-linux-x64-static.tar.xz" \
-            -C ${postgrest}/bin postgrest
-
-          ${ghr}/bin/ghr \
-            -t "$GITHUB_TOKEN" \
-            -u "$GITHUB_USERNAME" \
-            -r "$GITHUB_REPONAME" \
-            -b "$changes" \
-            --replace "$_arg_version" \
-            "postgrest-$_arg_version-linux-x64-static.tar.xz"
-        fi
-      '';
-
-  dockerLogin =
-    checkedShellScript
-      {
-        name = "postgrest-release-docker-login";
-        docs =
-          ''
-            Log in to Docker Hub using the DOCKER_USER and DOCKER_PASS env vars.
-
-            Those env vars are usually provided by CircleCI. The DOCKER_USER is
-            not the same as DOCKER_REPO because we use the
-            https://hub.docker.com/u/postgrestbot account for uploading to dockerhub.
-          '';
-        args = [
-          "ARG_USE_ENV([DOCKER_USER], [], [DockerHub user name])"
-          "ARG_USE_ENV([DOCKER_PASS], [], [DockerHub password])"
-        ];
-      }
-      ''
-        # ARG_USE_ENV only adds defaults or docs for environment variables
-        # We manually implement a required check here
-        # See also: https://github.com/matejak/argbash/issues/80
-        DOCKER_USER="''${DOCKER_USER:?DOCKER_USER is required}"
-        DOCKER_PASS="''${DOCKER_PASS:?DOCKER_PASS is required}"
-
-        docker login -u "$DOCKER_USER" -p "$DOCKER_PASS"
-      '';
-
-  dockerHub =
-    checkedShellScript
-      {
-        name = "postgrest-release-dockerhub";
-        docs = "Push a new release to Docker Hub";
-        args = [
-          "ARG_POSITIONAL_SINGLE([version], [git version tag to tag image with])"
-          "ARG_USE_ENV([DOCKER_REPO], [], [DockerHub repository])"
-        ];
-      }
-      ''
-        # ARG_USE_ENV only adds defaults or docs for environment variables
-        # We manually implement a required check here
-        # See also: https://github.com/matejak/argbash/issues/80
-        DOCKER_REPO="''${DOCKER_REPO:?DOCKER_REPO is required}"
-
-        docker load -i ${docker.image}
-
-        if test "$_arg_version" = "nightly"
-        then
-          suffix=$(${git}/bin/git show -s --format="%cd-%h" --date="format:%Y-%m-%d-%H-%M")
-
-          docker tag postgrest:latest "$DOCKER_REPO/postgrest:nightly-$suffix"
-          docker push "$DOCKER_REPO/postgrest:nightly-$suffix"
-        else
-          docker tag postgrest:latest "$DOCKER_REPO"/postgrest:latest
-          docker tag postgrest:latest "$DOCKER_REPO/postgrest:$_arg_version"
-
-          docker push "$DOCKER_REPO"/postgrest:latest
-          docker push "$DOCKER_REPO/postgrest:$_arg_version"
-        fi
-      '';
-
   dockerHubDescription =
     let
       description =
@@ -141,34 +26,102 @@ let
         # ARG_USE_ENV only adds defaults or docs for environment variables
         # We manually implement a required check here
         # See also: https://github.com/matejak/argbash/issues/80
-        DOCKER_USER="''${DOCKER_USER:?DOCKER_USER is required}"
-        DOCKER_PASS="''${DOCKER_PASS:?DOCKER_PASS is required}"
-        DOCKER_REPO="''${DOCKER_REPO:?DOCKER_REPO is required}"
+        : "''${DOCKER_USER:?DOCKER_USER is required}"
+        : "''${DOCKER_PASS:?DOCKER_PASS is required}"
+        : "''${DOCKER_REPO:?DOCKER_REPO is required}"
 
-        # Login to Docker Hub and get a token.
+        echo "Logging in to Docker Hub to get an auth token..."
         token="$(
-          ${curl}/bin/curl -s \
+          ${curl}/bin/curl --fail -s \
             --data-urlencode "username=$DOCKER_USER" \
             --data-urlencode "password=$DOCKER_PASS" \
             "https://hub.docker.com/v2/users/login/" \
-            | ${jq}/bin/jq -r .token
+           | ${jq}/bin/jq -r .token
         )"
 
-        # Patch both descriptions.
-        responseCode="$(
-          ${curl}/bin/curl -s --write-out "%{response_code}" \
-            --output /dev/null -H "Authorization: JWT $token" -X PATCH \
-            --data-urlencode description@${description} \
-            --data-urlencode full_description@${fullDescription} \
-            "https://hub.docker.com/v2/repositories/$DOCKER_REPO/postgrest/"
-        )"
+        repo_url="https://hub.docker.com/v2/repositories/$DOCKER_REPO/postgrest/"
+        echo "Patching both descriptions at $repo_url ..." 
+        ${curl}/bin/curl --fail -X PATCH "$repo_url" \
+          -H "Authorization: JWT $token" \
+          --data-urlencode description@${description} \
+          --data-urlencode full_description@${fullDescription}
+      '';
 
-        [ "$responseCode" -eq 200 ]
+  release =
+    checkedShellScript
+      {
+        name = "postgrest-release";
+        docs = "Patch postgrest.cabal, tag and push all in one go.";
+        args = [ "ARG_POSITIONAL_SINGLE([version], [Version to release], [pre])" ];
+        inRootDir = true;
+      }
+      ''
+        trap "echo You need to be on the main branch to proceed. Exiting ..." ERR
+        [ "$(git rev-parse --abbrev-ref HEAD)" == "main" ]
+        trap "" ERR
+
+        trap "echo You have uncommitted changes in postgrest.cabal. Exiting ..." ERR
+        git diff --exit-code HEAD postgrest.cabal > /dev/null
+        trap "" ERR
+
+        current_version="$(grep -oP '^version:\s*\K.*' postgrest.cabal)"
+        # shellcheck disable=SC2034
+        IFS=. read -r major minor patch pre <<< "$current_version"
+        echo "Current version is $current_version"
+
+        bump_pre="$major.$minor.$patch.$(date '+%Y%m%d')"
+        bump_patch="$major.$minor.$((patch+1))"
+        bump_minor="$major.$((minor+1)).0"
+        bump_major="$((major+1)).0.0"
+
+        PS3="Please select the new version: "
+        select new_version in "$bump_pre" "$bump_patch" "$bump_minor" "$bump_major"; do
+          case "$REPLY" in
+            1|2|3|4)
+              echo "Selected $new_version"
+              break
+              ;;
+            *)
+            echo "Invalid option $REPLY"
+            ;;
+          esac
+        done
+
+        echo "Updating postgrest.cabal ..."
+        sed -i -E "s/^(version:\s+).*$/\1$new_version/" postgrest.cabal > /dev/null
+
+        echo "Committing ..."
+        git add postgrest.cabal > /dev/null
+        git commit -m "bump version to $new_version" > /dev/null
+
+        echo "Tagging ..."
+        git tag "v$new_version" > /dev/null
+
+        trap "Couldn't find remote. Please push manually ..." ERR
+        remote="$(git remote -v | grep PostgREST/postgrest | grep push | cut -f1)"
+        trap "" ERR
+
+        push="git push --atomic $remote main v$new_version"
+
+        echo "To push both the branch and the new tag, the following will be run:"
+        echo
+        echo "$push"
+        echo
+        
+        read -r -p 'Proceed? (y/N) ' REPLY
+        case "$REPLY" in 
+          y|Y)
+            $push
+            ;;
+          *)
+            echo "Aborting ..."
+            ;;
+        esac
       '';
 
 in
 buildToolbox
 {
   name = "postgrest-release";
-  tools = [ github dockerLogin dockerHub dockerHubDescription ];
+  tools = [ dockerHubDescription release ];
 }

nix/tools/release/docker-hub-full-description.md

@@ -4,7 +4,7 @@
 [![Donate](https://img.shields.io/badge/Donate-Patreon-orange.svg?colorB=F96854)](https://www.patreon.com/postgrest)
 [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/postgrest)
 [![Docs](https://img.shields.io/badge/docs-latest-brightgreen.svg?style=flat)](http://postgrest.org)
-[![Build Status](https://circleci.com/gh/PostgREST/postgrest/tree/main.svg?style=shield)](https://circleci.com/gh/PostgREST/postgrest/tree/main)
+[![Build Status](https://github.com/postgrest/postgrest/actions/workflows/ci.yaml/badge.svg?branch=main)](https://github.com/PostgREST/postgrest/actions?query=branch%3Amain)
 
 PostgREST serves a fully RESTful API from any existing PostgreSQL database. It
 provides a cleaner, more standards-compliant, faster API than you are likely to
@@ -55,7 +55,7 @@ write from scratch.
 # Usage
 
 To learn how to use this container, see the [PostgREST Docker
-documentation](https://postgrest.com/en/stable/install.html#docker).
+documentation](https://postgrest.org/en/stable/install.html#docker).
 
 You can configure the PostgREST image by setting
 [enviroment variables](https://postgrest.org/en/stable/configuration.html).
@@ -66,5 +66,5 @@ The image is built from scratch using
 [Nix](https://nixos.org/nixpkgs/manual/#sec-pkgs-dockerTools) instead of a
 `Dockerfile`, which yields a higly secure and optimized image. This is also why
 no commands are listed in the image history. See the [PostgREST
-respository](https://github.com/PostgREST/postgrest/tree/main/nix/docker) for
+respository](https://github.com/PostgREST/postgrest/tree/main/nix/tools/docker) for
 details on the build process and how to inspect the image.

nix/tools/style.nix

@@ -1,11 +1,14 @@
-{ black
+{ actionlint
+, black
 , buildToolbox
 , checkedShellScript
 , git
 , hlint
+, hsie
 , nixpkgs-fmt
 , shellcheck
 , silver-searcher
+, statix
 , stylish-haskell
 }:
 let
@@ -18,6 +21,7 @@ let
       }
       ''
         # Format Nix files
+        ${statix}/bin/statix fix
         ${nixpkgs-fmt}/bin/nixpkgs-fmt . > /dev/null 2> /dev/null
 
         # Format Haskell files
@@ -40,24 +44,35 @@ let
       ''
         ${style}
 
-        ${git}/bin/git diff-index --exit-code HEAD -- '*.hs' '*.lhs' '*.nix'
+        trap "echo postgrest-style-check failed. Run postgrest-style to fix issues automatically." ERR
+
+        ${git}/bin/git diff-index --exit-code HEAD -- '*.hs' '*.lhs' '*.nix' '*.py'
       '';
 
   lint =
     checkedShellScript
       {
         name = "postgrest-lint";
-        docs = "Lint all Haskell files and bash scripts.";
+        docs = "Lint all Haskell files, bash scripts and github workflows.";
         inRootDir = true;
       }
       ''
-        # Lint Haskell files
+        echo "Checking consistency of import aliases in Haskell code..."
+        ${hsie} check-aliases main src
+
+
+        echo "Linting Haskell files..."
         # --vimgrep fixes a bug in ag: https://github.com/ggreer/the_silver_searcher/issues/753
         ${silver-searcher}/bin/ag -l --vimgrep -g '\.l?hs$' . \
           | xargs ${hlint}/bin/hlint -X QuasiQuotes -X NoPatternSynonyms
 
-        # Lint bash scripts
-        ${shellcheck}/bin/shellcheck test/create_test_db test/memory-tests.sh
+        echo "Linting bash scripts..."
+        ${shellcheck}/bin/shellcheck \
+          .github/get_cirrusci_freebsd \
+          .github/release
+
+        echo "Linting workflows..."
+        ${actionlint}/bin/actionlint
       '';
 
 in

nix/tools/tests.nix

@@ -3,14 +3,17 @@
 , checkedShellScript
 , devCabalOptions
 , ghc
-, glibcLocales
+, glibcLocales ? null
 , gnugrep
-, haskell
 , hpc-codecov
+, hostPlatform
 , jq
+, lib
 , postgrest
 , python3
 , runtimeShell
+, stdenv
+, weeder
 , withTools
 , yq
 }:
@@ -19,12 +22,44 @@ let
     checkedShellScript
       {
         name = "postgrest-test-spec";
-        docs = "Run the Haskell test suite";
+        docs = "Run the Haskell test suite. Use --match PATTERN for running individual specs";
+        args = [ "ARG_LEFTOVERS([hspec arguments])" ];
         inRootDir = true;
         withEnv = postgrest.env;
       }
       ''
-        ${withTools.latest} ${cabal-install}/bin/cabal v2-test ${devCabalOptions}
+        ${withTools.withPg} ${cabal-install}/bin/cabal v2-run ${devCabalOptions} \
+          test:spec -- "''${_arg_leftovers[@]}"
+      '';
+
+  testQuerycost =
+    checkedShellScript
+      {
+        name = "postgrest-test-querycost";
+        docs = "Run the Haskell test suite for query costs";
+        inRootDir = true;
+        withEnv = postgrest.env;
+      }
+      ''
+        ${withTools.withPg} ${cabal-install}/bin/cabal v2-run ${devCabalOptions} test:querycost
+      '';
+
+  testDoctests =
+    checkedShellScript
+      {
+        name = "postgrest-test-doctests";
+        docs = "Run the Haskell doctest test suite";
+        inRootDir = true;
+        withEnv = postgrest.env;
+      }
+      ''
+        # For unknown reasons, doctests uses the wrong GHC package database outside
+        # nix-shell and fails, so we set the package path explicitly
+        #ghcWithPackages="$(cat ${postgrest.env})"
+        #ghcVersion="$(ls "$ghcWithPackages/lib")"
+        #export GHC_PACKAGE_PATH="$ghcWithPackages/lib/$ghcVersion/package.conf.d/"
+
+        ${cabal-install}/bin/cabal v2-run ${devCabalOptions} test:doctests
       '';
 
   testSpecIdempotence =
@@ -36,9 +71,9 @@ let
         withEnv = postgrest.env;
       }
       ''
-        ${withTools.latest} ${runtimeShell} -c " \
-          ${cabal-install}/bin/cabal v2-test ${devCabalOptions} && \
-          ${cabal-install}/bin/cabal v2-test ${devCabalOptions}"
+        ${withTools.withPg} ${runtimeShell} -c " \
+          ${cabal-install}/bin/cabal v2-run ${devCabalOptions} test:spec && \
+          ${cabal-install}/bin/cabal v2-run ${devCabalOptions} test:spec"
       '';
 
   ioTestPython =
@@ -55,15 +90,15 @@ let
     checkedShellScript
       {
         name = "postgrest-test-io";
-        docs = "Run the pytest-based IO tests.";
+        docs = "Run the pytest-based IO tests. Add -k to run tests that match a given expression.";
         args = [ "ARG_LEFTOVERS([pytest arguments])" ];
         inRootDir = true;
         withEnv = postgrest.env;
       }
       ''
         ${cabal-install}/bin/cabal v2-build ${devCabalOptions}
-        ${cabal-install}/bin/cabal v2-exec ${withTools.latest} \
-          ${ioTestPython}/bin/pytest -- -v test/io-tests "''${_arg_leftovers[@]}"
+        ${cabal-install}/bin/cabal v2-exec -- ${withTools.withPg} -f test/io/fixtures.sql \
+          ${ioTestPython}/bin/pytest -v test/io "''${_arg_leftovers[@]}"
       '';
 
   dumpSchema =
@@ -73,11 +108,10 @@ let
         docs = "Dump the loaded schema's DbStructure as a yaml file.";
         inRootDir = true;
         withEnv = postgrest.env;
+        withPath = [ jq ];
       }
       ''
-        export PATH="${jq}/bin:$PATH"
-        
-        ${withTools.latest} \
+        ${withTools.withPg} \
             ${cabal-install}/bin/cabal v2-run ${devCabalOptions} --verbose=0 -- \
             postgrest --dump-schema \
             | ${yq}/bin/yq -y .
@@ -87,63 +121,79 @@ let
     checkedShellScript
       {
         name = "postgrest-coverage";
-        docs = "Run spec and io tests while collecting hpc coverage data.";
+        docs = "Run spec and io tests while collecting hpc coverage data. First runs weeder to detect dead code.";
         args = [ "ARG_LEFTOVERS([hpc report arguments])" ];
         inRootDir = true;
         redirectTixFiles = false;
         withEnv = postgrest.env;
         withTmpDir = true;
       }
-      ''
-        export LOCALE_ARCHIVE="${glibcLocales}/lib/locale/locale-archive"
+      (
+        # required for `hpc markup` in CI; glibcLocales is not available e.g. on Darwin
+        lib.optionalString (stdenv.isLinux && hostPlatform.libc == "glibc") ''
+          export LOCALE_ARCHIVE="${glibcLocales}/lib/locale/locale-archive"
+        '' +
 
-        # clean up previous coverage reports
-        mkdir -p coverage
-        rm -rf coverage/*
+        ''
+          # clean up previous coverage reports
+          mkdir -p coverage
+          rm -rf coverage/*
 
-        # build once before running all the tests
-        ${cabal-install}/bin/cabal v2-build ${devCabalOptions} exe:postgrest lib:postgrest test:spec test:spec-querycost
+          # build once before running all the tests
+          ${cabal-install}/bin/cabal v2-build ${devCabalOptions} exe:postgrest lib:postgrest test:spec test:querycost
 
-        # collect all tests
-        HPCTIXFILE="$tmpdir"/io.tix \
-        ${withTools.latest} ${cabal-install}/bin/cabal v2-exec ${devCabalOptions} \
-          ${ioTestPython}/bin/pytest -- -v test/io-tests
-          
-        HPCTIXFILE="$tmpdir"/spec.tix \
-        ${withTools.latest} ${cabal-install}/bin/cabal v2-test ${devCabalOptions}
+          (
+            trap 'echo Found dead code: Check file list above.' ERR ;
+            ${weeder}/bin/weeder --config=./test/weeder.dhall
+          )
 
-        # collect all the tix files
-        ${ghc}/bin/hpc sum  --union --exclude=Paths_postgrest --output="$tmpdir"/tests.tix "$tmpdir"/io*.tix "$tmpdir"/spec.tix
+          # collect all tests
+          HPCTIXFILE="$tmpdir"/io.tix \
+            ${withTools.withPg} -f test/io/fixtures.sql ${cabal-install}/bin/cabal v2-exec ${devCabalOptions} -- \
+            ${ioTestPython}/bin/pytest -v test/io
 
-        # prepare the overlay
-        ${ghc}/bin/hpc overlay --output="$tmpdir"/overlay.tix test/coverage.overlay
-        ${ghc}/bin/hpc sum --union --output="$tmpdir"/tests-overlay.tix "$tmpdir"/tests.tix "$tmpdir"/overlay.tix
+          HPCTIXFILE="$tmpdir"/spec.tix \
+            ${withTools.withPg} ${cabal-install}/bin/cabal v2-run ${devCabalOptions} test:spec
 
-        # check nothing in the overlay is actually tested
-        ${ghc}/bin/hpc map --function=inv --output="$tmpdir"/inverted.tix "$tmpdir"/tests.tix
-        ${ghc}/bin/hpc combine --function=sub \
-          --output="$tmpdir"/check.tix "$tmpdir"/overlay.tix "$tmpdir"/inverted.tix
-        # returns zero exit code if any count="<non-zero>" lines are found, i.e.
-        # something is covered by both the overlay and the tests
-        if ${ghc}/bin/hpc report --xml "$tmpdir"/check.tix | ${gnugrep}/bin/grep -qP 'count="[^0]'
-        then
-          ${ghc}/bin/hpc markup --highlight-covered --destdir=coverage/overlay "$tmpdir"/overlay.tix || true
-          ${ghc}/bin/hpc markup --highlight-covered --destdir=coverage/check "$tmpdir"/check.tix || true
-          echo "ERROR: Something is covered by both the tests and the overlay:"
-          echo "file://$(pwd)/coverage/check/hpc_index.html"
-          exit 1
-        else
-          # copy the result .tix file to the coverage/ dir to make it available to postgrest-coverage-draft-overlay, too
-          cp "$tmpdir"/tests-overlay.tix coverage/postgrest.tix
-          # prepare codecov json report
-          ${hpc-codecov}/bin/hpc-codecov --mix=.hpc --out=coverage/codecov.json coverage/postgrest.tix
+          HPCTIXFILE="$tmpdir"/querycost.tix \
+            ${withTools.withPg} ${cabal-install}/bin/cabal v2-run ${devCabalOptions} test:querycost
 
-          # create html and stdout reports
-          ${ghc}/bin/hpc markup --destdir=coverage coverage/postgrest.tix
-          echo "file://$(pwd)/coverage/hpc_index.html"
-          ${ghc}/bin/hpc report coverage/postgrest.tix "''${_arg_leftovers[@]}"
-        fi
-      '';
+          # Note: No coverage for doctests, as doctests leverage GHCi and GHCi does not support hpc
+
+          # collect all the tix files
+          ${ghc}/bin/hpc sum  --union --exclude=Paths_postgrest --output="$tmpdir"/tests.tix \
+            "$tmpdir"/io*.tix "$tmpdir"/spec.tix "$tmpdir"/querycost.tix
+
+          # prepare the overlay
+          ${ghc}/bin/hpc overlay --output="$tmpdir"/overlay.tix test/coverage.overlay
+          ${ghc}/bin/hpc sum --union --output="$tmpdir"/tests-overlay.tix "$tmpdir"/tests.tix "$tmpdir"/overlay.tix
+
+          # check nothing in the overlay is actually tested
+          ${ghc}/bin/hpc map --function=inv --output="$tmpdir"/inverted.tix "$tmpdir"/tests.tix
+          ${ghc}/bin/hpc combine --function=sub \
+            --output="$tmpdir"/check.tix "$tmpdir"/overlay.tix "$tmpdir"/inverted.tix
+          # returns zero exit code if any count="<non-zero>" lines are found, i.e.
+          # something is covered by both the overlay and the tests
+          if ${ghc}/bin/hpc report --xml "$tmpdir"/check.tix | ${gnugrep}/bin/grep -qP 'count="[^0]'
+          then
+            ${ghc}/bin/hpc markup --highlight-covered --destdir=coverage/overlay "$tmpdir"/overlay.tix || true
+            ${ghc}/bin/hpc markup --highlight-covered --destdir=coverage/check "$tmpdir"/check.tix || true
+            echo "ERROR: Something is covered by both the tests and the overlay:"
+            echo "file://$(pwd)/coverage/check/hpc_index.html"
+            exit 1
+          else
+            # copy the result .tix file to the coverage/ dir to make it available to postgrest-coverage-draft-overlay, too
+            cp "$tmpdir"/tests-overlay.tix coverage/postgrest.tix
+            # prepare codecov json report
+            ${hpc-codecov}/bin/hpc-codecov --mix=.hpc --out=coverage/codecov.json coverage/postgrest.tix
+
+            # create html and stdout reports
+            ${ghc}/bin/hpc markup --destdir=coverage coverage/postgrest.tix
+            echo "file://$(pwd)/coverage/hpc_index.html"
+            ${ghc}/bin/hpc report coverage/postgrest.tix "''${_arg_leftovers[@]}"
+          fi
+        ''
+      );
 
   coverageDraftOverlay =
     checkedShellScript
@@ -157,6 +207,26 @@ let
         sed -i 's|^module \(.*\):|module \1/|g' test/coverage.overlay
       '';
 
+  checkStatic =
+    checkedShellScript
+      {
+        name = "postgrest-check-static";
+        docs = "Verify that the argument is a static executable.";
+        args = [ "ARG_POSITIONAL_SINGLE([executable], [Executable])" ];
+        inRootDir = true;
+        withEnv = postgrest.env;
+      }
+      ''
+        exe="$_arg_executable"
+        ldd_output=$(ldd "$exe" 2>&1 || true)
+        if ! grep -q "not a dynamic executable" <<< "$ldd_output"; then
+          echo "not a static executable, ldd output:"
+          echo "$ldd_output"
+          exit 1
+        fi
+        "$exe" --help
+      '';
+
 in
 buildToolbox
 {
@@ -164,10 +234,13 @@ buildToolbox
   tools =
     [
       testSpec
+      testQuerycost
+      testDoctests
       testSpecIdempotence
       testIO
       dumpSchema
       coverage
       coverageDraftOverlay
+      checkStatic
     ];
 }

nix/tools/withTools.nix

@@ -1,9 +1,14 @@
-{ bashCompletion
+{ bash-completion
 , buildToolbox
+, cabal-install
 , checkedShellScript
+, curl
+, devCabalOptions
+, git
 , lib
 , postgresqlVersions
-, writeTextFile
+, postgrest
+, writeText
 }:
 let
   withTmpDb =
@@ -14,26 +19,25 @@ let
         docs = "Run the given command in a temporary database with ${name}";
         args =
           [
-            "ARG_OPTIONAL_SINGLE([fixtures], [f], [SQL file to load fixtures from], [test/fixtures/load.sql])"
+            "ARG_OPTIONAL_SINGLE([fixtures], [f], [SQL file to load fixtures from], [test/spec/fixtures/load.sql])"
             "ARG_POSITIONAL_SINGLE([command], [Command to run])"
             "ARG_LEFTOVERS([command arguments])"
             "ARG_USE_ENV([PGUSER], [postgrest_test_authenticator], [Authenticator PG role])"
             "ARG_USE_ENV([PGDATABASE], [postgres], [PG database name])"
             "ARG_USE_ENV([PGRST_DB_SCHEMAS], [test], [Schema to expose])"
-            "ARG_USE_ENV([PGRST_DB_ANON_ROLE], [postgrest_test_anonymous], [Anonymous PG role])"
           ];
-        addCommandCompletion = true;
+        positionalCompletion = "_command";
         inRootDir = true;
         redirectTixFiles = false;
+        withPath = [ postgresql ];
         withTmpDir = true;
       }
       ''
         # avoid starting multiple layers of withTmpDb
-        if test -v PGRST_DB_URI; then
-          exec "$@"
+        if test -v PGHOST; then
+          exec "$_arg_command" "''${_arg_leftovers[@]}"
         fi
-        
-        export PATH=${postgresql}/bin:"$PATH"
+
         setuplog="$tmpdir/setup.log"
 
         log () {
@@ -48,9 +52,7 @@ let
         export PGHOST="$tmpdir/socket"
         export PGUSER
         export PGDATABASE
-        export PGRST_DB_URI="postgresql:///$PGDATABASE?host=$PGHOST&user=$PGUSER"
         export PGRST_DB_SCHEMAS
-        export PGRST_DB_ANON_ROLE
 
         log "Initializing database cluster..."
         # We try to make the database cluster as independent as possible from the host
@@ -60,18 +62,13 @@ let
 
         log "Starting the database cluster..."
         # Instead of listening on a local port, we will listen on a unix domain socket.
-        pg_ctl -l "$tmpdir/db.log" start -o "-F -c listen_addresses=\"\" -k $PGHOST" \
+        pg_ctl -l "$tmpdir/db.log" -w start -o "-F -c listen_addresses=\"\" -k $PGHOST -c log_statement=\"all\"" \
           >> "$setuplog"
 
-        log "Waiting for the database cluster to be ready..."
-        # Waiting is required for older versions of Postgres (< 10).
-        until pg_isready >> "$setuplog"; do
-          sleep 0.1
-        done
-
         stop () {
           log "Stopping the database cluster..."
           pg_ctl stop -m i >> "$setuplog"
+          rm -rf "$tmpdir/db"
         }
         trap stop EXIT
 
@@ -83,27 +80,27 @@ let
       '';
 
   # Helper script for running a command against all PostgreSQL versions.
-  withAll =
+  withPgAll =
     let
       runners =
         builtins.map
-          (pg:
+          (version:
             ''
               cat << EOF
 
-              Running against ${pg.name}...
+              Running against ${version.name}...
 
               EOF
 
-              trap 'echo "Failed on ${pg.name}"' exit
+              trap 'echo "Failed on ${version.name}"' exit
 
-              (${withTmpDb pg} "$_arg_command" "''${_arg_leftovers[@]}")
+              (${withTmpDb version} "$_arg_command" "''${_arg_leftovers[@]}")
 
               trap "" exit
 
               cat << EOF
 
-              Done running against ${pg.name}.
+              Done running against ${version.name}.
 
               EOF
             '')
@@ -118,21 +115,167 @@ let
             "ARG_POSITIONAL_SINGLE([command], [Command to run])"
             "ARG_LEFTOVERS([command arguments])"
           ];
-        addCommandCompletion = true;
+        positionalCompletion = "_command";
         inRootDir = true;
       }
       (lib.concatStringsSep "\n\n" runners);
 
   # Create a `postgrest-with-postgresql-` for each PostgreSQL version
-  withVersions = builtins.map withTmpDb postgresqlVersions;
+  withPgVersions = builtins.map withTmpDb postgresqlVersions;
+
+  withPg = builtins.head withPgVersions;
+
+  withGit =
+    let
+      name = "postgrest-with-git";
+    in
+    checkedShellScript
+      {
+        inherit name;
+        docs =
+          ''
+            Create a new worktree of the postgrest repo in a temporary directory and
+            check out <commit>, then run <command> with arguments inside the temporary folder.
+          '';
+        args =
+          [
+            "ARG_POSITIONAL_SINGLE([commit], [Commit-ish reference to run command with])"
+            "ARG_POSITIONAL_SINGLE([command], [Command to run])"
+            "ARG_LEFTOVERS([command arguments])"
+          ];
+        positionalCompletion =
+          ''
+            if test "$prev" == "${name}"; then
+              __gitcomp_nl "$(__git_refs)"
+            else
+              _command_offset 2
+            fi
+          '';
+        inRootDir = true;
+      }
+      ''
+        # not using withTmpDir here, because we don't want to keep the directory on error
+        tmpdir="$(mktemp -d)"
+        trap 'rm -rf "$tmpdir"' EXIT
+
+        ${git}/bin/git worktree add -f "$tmpdir" "$_arg_commit" > /dev/null
+
+        cd "$tmpdir"
+        ("$_arg_command" "''${_arg_leftovers[@]}")
+
+        ${git}/bin/git worktree remove -f "$tmpdir" > /dev/null
+      '';
+
+  legacyConfig =
+    writeText "legacy.conf"
+      ''
+        # Using this config file to support older postgrest versions for `postgrest-loadtest-against`
+        db-uri="$(PGRST_DB_URI)"
+        db-schema="$(PGRST_DB_SCHEMAS)"
+        db-anon-role="$(PGRST_DB_ANON_ROLE)"
+        db-pool="$(PGRST_DB_POOL)"
+        server-unix-socket="$(PGRST_SERVER_UNIX_SOCKET)"
+        log-level="$(PGRST_LOG_LEVEL)"
+      '';
+
+  waitForPgrstPid =
+    checkedShellScript
+      {
+        name = "postgrest-wait-for-pgrst-pid";
+        docs = "Wait for PostgREST to be running. Needs to be a separate command for timeout to work below.";
+        args = [
+          "ARG_USE_ENV([PGRST_SERVER_UNIX_SOCKET], [], [Unix socket to check for running PostgREST instance])"
+        ];
+      }
+      ''
+        # ARG_USE_ENV only adds defaults or docs for environment variables
+        # We manually implement a required check here
+        # See also: https://github.com/matejak/argbash/issues/80
+        : "''${PGRST_SERVER_UNIX_SOCKET:?PGRST_SERVER_UNIX_SOCKET is required}"
+
+        until [ -S "$PGRST_SERVER_UNIX_SOCKET" ]
+        do
+          sleep 0.1
+        done
+
+        # return pid of postgrest process
+        lsof -t -c '/^postgrest$/' "$PGRST_SERVER_UNIX_SOCKET"
+      '';
+
+  waitForPgrstReady =
+    checkedShellScript
+      {
+        name = "postgrest-wait-for-pgrst-ready";
+        docs = "Wait for PostgREST to be ready to serve requests. Needs to be a separate command for timeout to work below.";
+        args = [
+          "ARG_USE_ENV([PGRST_SERVER_UNIX_SOCKET], [], [Unix socket to check for running PostgREST instance])"
+        ];
+      }
+      ''
+        # ARG_USE_ENV only adds defaults or docs for environment variables
+        # We manually implement a required check here
+        # See also: https://github.com/matejak/argbash/issues/80
+        : "''${PGRST_SERVER_UNIX_SOCKET:?PGRST_SERVER_UNIX_SOCKET is required}"
+
+        function check_status () {
+          ${curl}/bin/curl -s -o /dev/null -w "%{http_code}" --unix-socket "$PGRST_SERVER_UNIX_SOCKET" http://localhost/
+        }
+
+        while [[ "$(check_status)" != "200" ]];
+           do sleep 0.1;
+        done
+      '';
+
+  withPgrst =
+    checkedShellScript
+      {
+        name = "postgrest-with-pgrst";
+        docs = "Build and run PostgREST and run <command> with PGRST_SERVER_UNIX_SOCKET set.";
+        args =
+          [
+            "ARG_POSITIONAL_SINGLE([command], [Command to run])"
+            "ARG_LEFTOVERS([command arguments])"
+          ];
+        positionalCompletion = "_command";
+        inRootDir = true;
+        withEnv = postgrest.env;
+        withTmpDir = true;
+      }
+      ''
+        export PGRST_SERVER_UNIX_SOCKET="$tmpdir"/postgrest.socket
+
+        rm -f result
+        echo -n "Building postgrest... "
+        nix-build -A postgrestPackage > "$tmpdir"/build.log 2>&1 || {
+          echo "failed, output:"
+          cat "$tmpdir"/build.log
+          exit 1
+        }
+        echo "done."
+
+        echo -n "Starting postgrest... "
+        ./result/bin/postgrest ${legacyConfig} > "$tmpdir"/run.log 2>&1 &
+        pid=$!
+        cleanup() {
+          kill "$pid" || true
+        }
+        trap cleanup EXIT
+
+        timeout -s TERM 5 ${waitForPgrstReady} || {
+          echo "timed out, output:"
+          cat "$tmpdir"/run.log
+          exit 1
+        }
+        echo "done."
+
+        ("$_arg_command" "''${_arg_leftovers[@]}")
+      '';
 
 in
 buildToolbox
 {
   name = "postgrest-with";
-  tools = [ withAll ] ++ withVersions;
-  extra = {
-    # make withTools.latest available for other nix files
-    latest = withTmpDb (builtins.head postgresqlVersions);
-  };
+  tools = [ withPgAll withGit withPgrst ] ++ withPgVersions;
+  # make withTools available for other nix files
+  extra = { inherit withGit withPg withPgAll withPgrst; };
 }

postgrest.cabal

@@ -1,8 +1,8 @@
 name:               postgrest
-version:            8.0.0
+version:            10.0.0
 synopsis:           REST API for any Postgres database
 description:        Reads the schema of a PostgreSQL database and creates RESTful routes
-                    for the tables and views, supporting all HTTP verbs that security
+                    for tables, views, and functions, supporting all HTTP methods that security
                     permits.
 license:            MIT
 license-file:       LICENSE
@@ -35,6 +35,7 @@ library
                       NoImplicitPrelude
   hs-source-dirs:     src
   exposed-modules:    PostgREST.App
+                      PostgREST.Admin
                       PostgREST.AppState
                       PostgREST.Auth
                       PostgREST.CLI
@@ -43,7 +44,7 @@ library
                       PostgREST.Config.JSPath
                       PostgREST.Config.PgVersion
                       PostgREST.Config.Proxy
-                      PostgREST.ContentType
+                      PostgREST.Cors
                       PostgREST.DbStructure
                       PostgREST.DbStructure.Identifiers
                       PostgREST.DbStructure.Proc
@@ -51,7 +52,9 @@ library
                       PostgREST.DbStructure.Table
                       PostgREST.Error
                       PostgREST.GucHeader
+                      PostgREST.Logger
                       PostgREST.Middleware
+                      PostgREST.MediaType
                       PostgREST.OpenAPI
                       PostgREST.Query.QueryBuilder
                       PostgREST.Query.SqlFragment
@@ -59,32 +62,31 @@ library
                       PostgREST.RangeQuery
                       PostgREST.Request.ApiRequest
                       PostgREST.Request.DbRequestBuilder
-                      PostgREST.Request.Parsers
+                      PostgREST.Request.MutateQuery
                       PostgREST.Request.Preferences
+                      PostgREST.Request.QueryParams
+                      PostgREST.Request.ReadQuery
                       PostgREST.Request.Types
                       PostgREST.Version
                       PostgREST.Workers
   other-modules:      Paths_postgrest
-  build-depends:      base                      >= 4.9 && < 4.15
+  build-depends:      base                      >= 4.9 && < 4.17
                     , HTTP                      >= 4000.3.7 && < 4000.4
                     , Ranged-sets               >= 0.3 && < 0.5
-                    , aeson                     >= 1.4.7 && < 1.6
-                    , ansi-wl-pprint            >= 0.6.7 && < 0.7
+                    , aeson                     >= 2.0.3 && < 2.1
                     , auto-update               >= 0.1.4 && < 0.2
                     , base64-bytestring         >= 1 && < 1.3
-                    , bytestring                >= 0.10.8 && < 0.11
+                    , bytestring                >= 0.10.8 && < 0.12
                     , case-insensitive          >= 1.2 && < 1.3
                     , cassava                   >= 0.4.5 && < 0.6
                     , configurator-pg           >= 0.2 && < 0.3
                     , containers                >= 0.5.7 && < 0.7
-                    , contravariant             >= 1.4 && < 1.6
                     , contravariant-extras      >= 0.3.3 && < 0.4
                     , cookie                    >= 0.4.2 && < 0.5
                     , either                    >= 4.4.1 && < 5.1
-                    , fast-logger               >= 2.4.5
                     , gitrev                    >= 1.2 && < 1.4
-                    , hasql                     >= 1.4 && < 1.5
-                    , hasql-dynamic-statements  == 0.3.1
+                    , hasql                     >= 1.4 && < 1.6
+                    , hasql-dynamic-statements  >= 0.3.1 && < 0.4
                     , hasql-notifications       >= 0.1 && < 0.3
                     , hasql-pool                >= 0.5 && < 0.6
                     , hasql-transaction         >= 1.0.1 && < 1.1
@@ -92,28 +94,33 @@ library
                     , http-types                >= 0.12.2 && < 0.13
                     , insert-ordered-containers >= 0.2.2 && < 0.3
                     , interpolatedstring-perl6  >= 1 && < 1.1
-                    , jose                      >= 0.8.1 && < 0.9
-                    , lens                      >= 4.14 && < 5.1
+                    , jose                      >= 0.8.5.1 && < 0.10
+                    , lens                      >= 4.14 && < 5.2
                     , lens-aeson                >= 1.0.1 && < 1.2
                     , mtl                       >= 2.2.2 && < 2.3
+                    , network                   >= 2.6 && < 3.2
                     , network-uri               >= 2.6.1 && < 2.8
                     , optparse-applicative      >= 0.13 && < 0.17
                     , parsec                    >= 3.1.11 && < 3.2
-                    , protolude                 >= 0.3 && < 0.4
+                    , protolude                 >= 0.3.1 && < 0.4
                     , regex-tdfa                >= 1.2.2 && < 1.4
-                    , retry                     >= 0.7.4 && < 0.9
+                    , retry                     >= 0.7.4 && < 0.10
                     , scientific                >= 0.3.4 && < 0.4
-                    , swagger2                  >= 2.4 && < 2.7
+                    , swagger2                  >= 2.4 && < 2.9
                     , text                      >= 1.2.2 && < 1.3
-                    , time                      >= 1.6 && < 1.11
+                    , time                      >= 1.6 && < 1.12
                     , unordered-containers      >= 0.2.8 && < 0.3
+                    , vault                     >= 0.3.1.5 && < 0.4
                     , vector                    >= 0.11 && < 0.13
                     , wai                       >= 3.2.1 && < 3.3
                     , wai-cors                  >= 0.2.5 && < 0.3
-                    , wai-extra                 >= 3.0.19 && < 3.2
-                    , wai-logger                >= 2.3.2
-                    , wai-middleware-static     >= 0.8.1 && < 0.10
-                    , warp                      >= 3.2.12 && < 3.4
+                    , wai-extra                 >= 3.1.8 && < 3.2
+                    -- We already depend on wai-logger >= 2.3.7 indirectly via wai-extra,
+                    -- but we want to depend on 2.4.0 which fixes 'unknownSocket' log output
+                    -- for unix sockets; this is tested in test/io/test_io.py. See
+                    -- https://github.com/kazu-yamamoto/logger/commit/3a71ca70afdbb93d4ecf0083eeba1fbbbcab3fc3
+                    , wai-logger                >= 2.4.0
+                    , warp                      >= 3.3.19 && < 3.4
                       -- -fno-spec-constr may help keep compile time memory use in check,
                       --   see https://gitlab.haskell.org/ghc/ghc/issues/16017#note_219304
                       -- -optP-Wno-nonportable-include-path
@@ -123,7 +130,7 @@ library
                       -fno-spec-constr -optP-Wno-nonportable-include-path
 
   if flag(dev)
-    ghc-options: -O0
+    ghc-options: -O0 -fwrite-ide-info
     if flag(hpc)
       ghc-options: -fhpc -hpcdir .hpc
   else
@@ -133,7 +140,6 @@ library
     build-depends:
       unix
       , directory >= 1.2.6 && < 1.4
-      , network   >= 2.6 && < 3.2
     exposed-modules:
       PostgREST.Unix
 
@@ -143,16 +149,18 @@ executable postgrest
                       NoImplicitPrelude
   hs-source-dirs:     main
   main-is:            Main.hs
-  build-depends:      base                >= 4.9 && < 4.15
+  build-depends:      base                >= 4.9 && < 4.17
                     , containers          >= 0.5.7 && < 0.7
                     , postgrest
-                    , protolude           >= 0.3 && < 0.4
-  ghc-options:        -threaded -rtsopts "-with-rtsopts=-N -I2"
+                    , protolude           >= 0.3.1 && < 0.4
+  ghc-options:        -threaded -rtsopts "-with-rtsopts=-N -I0 -qg"
                       -O2 -Werror -Wall -fwarn-identities
                       -fno-spec-constr -optP-Wno-nonportable-include-path
 
   if flag(dev)
-    ghc-options: -O0
+    ghc-options: -O0 -fwrite-ide-info
+                 -- https://github.com/PostgREST/postgrest/issues/387
+                 -with-rtsopts=-K1K
     if flag(hpc)
       ghc-options: -fhpc -hpcdir .hpc
   else
@@ -164,118 +172,134 @@ test-suite spec
   default-extensions: OverloadedStrings
                       QuasiQuotes
                       NoImplicitPrelude
-  hs-source-dirs:     test
+  hs-source-dirs:     test/spec
   main-is:            Main.hs
-  other-modules:      Feature.AndOrParamsSpec
-                      Feature.AsymmetricJwtSpec
-                      Feature.AudienceJwtSecretSpec
-                      Feature.AuthSpec
-                      Feature.BinaryJwtSecretSpec
+  other-modules:      Feature.Auth.AsymmetricJwtSpec
+                      Feature.Auth.AudienceJwtSecretSpec
+                      Feature.Auth.AuthSpec
+                      Feature.Auth.BinaryJwtSecretSpec
+                      Feature.Auth.NoAnonSpec
+                      Feature.Auth.NoJwtSpec
                       Feature.ConcurrentSpec
                       Feature.CorsSpec
-                      Feature.DeleteSpec
-                      Feature.DisabledOpenApiSpec
-                      Feature.EmbedDisambiguationSpec
                       Feature.ExtraSearchPathSpec
-                      Feature.HtmlRawOutputSpec
-                      Feature.InsertSpec
-                      Feature.IgnorePrivOpenApiSpec
-                      Feature.JsonOperatorSpec
-                      Feature.MultipleSchemaSpec
-                      Feature.NoJwtSpec
-                      Feature.NonexistentSchemaSpec
-                      Feature.OpenApiSpec
+                      Feature.LegacyGucsSpec
+                      Feature.OpenApi.DisabledOpenApiSpec
+                      Feature.OpenApi.IgnorePrivOpenApiSpec
+                      Feature.OpenApi.OpenApiSpec
+                      Feature.OpenApi.ProxySpec
+                      Feature.OpenApi.RootSpec
+                      Feature.OpenApi.SecurityOpenApiSpec
                       Feature.OptionsSpec
-                      Feature.ProxySpec
-                      Feature.QueryLimitedSpec
-                      Feature.QuerySpec
-                      Feature.RangeSpec
-                      Feature.RawOutputTypesSpec
+                      Feature.Query.AndOrParamsSpec
+                      Feature.Query.ComputedRelsSpec
+                      Feature.Query.DeleteSpec
+                      Feature.Query.EmbedDisambiguationSpec
+                      Feature.Query.EmbedInnerJoinSpec
+                      Feature.Query.PlanSpec
+                      Feature.Query.HtmlRawOutputSpec
+                      Feature.Query.InsertSpec
+                      Feature.Query.JsonOperatorSpec
+                      Feature.Query.MultipleSchemaSpec
+                      Feature.Query.ErrorSpec
+                      Feature.Query.PgSafeUpdateSpec
+                      Feature.Query.PostGISSpec
+                      Feature.Query.QueryLimitedSpec
+                      Feature.Query.QuerySpec
+                      Feature.Query.RangeSpec
+                      Feature.Query.RawOutputTypesSpec
+                      Feature.Query.RpcSpec
+                      Feature.Query.SingularSpec
+                      Feature.Query.UnicodeSpec
+                      Feature.Query.UpdateSpec
+                      Feature.Query.UpsertSpec
                       Feature.RollbackSpec
-                      Feature.RootSpec
                       Feature.RpcPreRequestGucsSpec
-                      Feature.RpcSpec
-                      Feature.SingularSpec
-                      Feature.UnicodeSpec
-                      Feature.UpdateSpec
-                      Feature.UpsertSpec
                       SpecHelper
                       TestTypes
-  build-depends:      base              >= 4.9 && < 4.15
-                    , aeson             >= 1.4.7 && < 1.6
+  build-depends:      base              >= 4.9 && < 4.17
+                    , aeson             >= 2.0.3 && < 2.1
                     , aeson-qq          >= 0.8.1 && < 0.9
                     , async             >= 2.1.1 && < 2.3
                     , auto-update       >= 0.1.4 && < 0.2
                     , base64-bytestring >= 1 && < 1.3
-                    , bytestring        >= 0.10.8 && < 0.11
+                    , bytestring        >= 0.10.8 && < 0.12
                     , case-insensitive  >= 1.2 && < 1.3
-                    , cassava           >= 0.4.5 && < 0.6
                     , containers        >= 0.5.7 && < 0.7
-                    , contravariant     >= 1.4 && < 1.6
-                    , hasql             >= 1.4 && < 1.5
                     , hasql-pool        >= 0.5 && < 0.6
                     , hasql-transaction >= 1.0.1 && < 1.1
                     , heredoc           >= 0.2 && < 0.3
-                    , hspec             >= 2.3 && < 2.8
+                    , hspec             >= 2.3 && < 2.9
                     , hspec-wai         >= 0.10 && < 0.12
                     , hspec-wai-json    >= 0.10 && < 0.12
                     , http-types        >= 0.12.3 && < 0.13
-                    , lens              >= 4.14 && < 5.1
+                    , lens              >= 4.14 && < 5.2
                     , lens-aeson        >= 1.0.1 && < 1.2
                     , monad-control     >= 1.0.1 && < 1.1
                     , postgrest
                     , process           >= 1.4.2 && < 1.7
-                    , protolude         >= 0.3 && < 0.4
+                    , protolude         >= 0.3.1 && < 0.4
                     , regex-tdfa        >= 1.2.2 && < 1.4
                     , text              >= 1.2.2 && < 1.3
-                    , time              >= 1.6 && < 1.11
                     , transformers-base >= 0.4.4 && < 0.5
                     , wai               >= 3.2.1 && < 3.3
                     , wai-extra         >= 3.0.19 && < 3.2
   ghc-options:        -O0 -Werror -Wall -fwarn-identities
                       -fno-spec-constr -optP-Wno-nonportable-include-path
                       -fno-warn-missing-signatures
+                      -fwrite-ide-info
+                      -- https://github.com/PostgREST/postgrest/issues/387
+                      -with-rtsopts=-K33K
 
-test-suite spec-querycost
-  type:                exitcode-stdio-1.0
-  default-language:    Haskell2010
-  default-extensions:  OverloadedStrings
-                       QuasiQuotes
-                       NoImplicitPrelude
-  hs-source-dirs:      test
-  main-is:             QueryCost.hs
-  other-modules:       SpecHelper
-  build-depends:       base              >= 4.9 && < 4.15
-                     , aeson             >= 1.4.7 && < 1.6
-                     , aeson-qq          >= 0.8.1 && < 0.9
-                     , async             >= 2.1.1 && < 2.3
-                     , auto-update       >= 0.1.4 && < 0.2
-                     , base64-bytestring >= 1 && < 1.3
-                     , bytestring        >= 0.10.8 && < 0.11
-                     , case-insensitive  >= 1.2 && < 1.3
-                     , cassava           >= 0.4.5 && < 0.6
-                     , containers        >= 0.5.7 && < 0.7
-                     , contravariant     >= 1.4 && < 1.6
-                     , hasql             >= 1.4 && < 1.5
-                     , hasql-dynamic-statements  == 0.3.1
-                     , hasql-pool        >= 0.5 && < 0.6
-                     , hasql-transaction >= 1.0.1 && < 1.1
-                     , heredoc           >= 0.2 && < 0.3
-                     , hspec             >= 2.3 && < 2.8
-                     , hspec-wai         >= 0.10 && < 0.12
-                     , hspec-wai-json    >= 0.10 && < 0.12
-                     , http-types        >= 0.12.3 && < 0.13
-                     , lens              >= 4.14 && < 5.1
-                     , lens-aeson        >= 1.0.1 && < 1.2
-                     , monad-control     >= 1.0.1 && < 1.1
-                     , postgrest
-                     , process           >= 1.4.2 && < 1.7
-                     , protolude         >= 0.3 && < 0.4
-                     , regex-tdfa        >= 1.2.2 && < 1.4
-                     , text              >= 1.2.2 && < 1.3
-                     , time              >= 1.6 && < 1.11
-                     , transformers-base >= 0.4.4 && < 0.5
-                     , wai               >= 3.2.1 && < 3.3
-                     , wai-extra         >= 3.0.19 && < 3.2
-  ghc-options:         -O0 -Werror -Wall -fwarn-identities
-                       -fno-spec-constr -optP-Wno-nonportable-include-path
+test-suite querycost
+  type:               exitcode-stdio-1.0
+  default-language:   Haskell2010
+  default-extensions: OverloadedStrings
+                      QuasiQuotes
+                      NoImplicitPrelude
+  hs-source-dirs:     test/spec
+  main-is:            QueryCost.hs
+  other-modules:      SpecHelper
+  build-depends:      base              >= 4.9 && < 4.17
+                    , aeson             >= 2.0.3 && < 2.1
+                    , base64-bytestring >= 1 && < 1.3
+                    , bytestring        >= 0.10.8 && < 0.12
+                    , case-insensitive  >= 1.2 && < 1.3
+                    , containers        >= 0.5.7 && < 0.7
+                    , contravariant     >= 1.4 && < 1.6
+                    , hasql             >= 1.4 && < 1.6
+                    , hasql-dynamic-statements >= 0.3.1 && < 0.4
+                    , hasql-pool        >= 0.5 && < 0.6
+                    , hasql-transaction >= 1.0.1 && < 1.1
+                    , heredoc           >= 0.2 && < 0.3
+                    , hspec             >= 2.3 && < 2.9
+                    , hspec-wai         >= 0.10 && < 0.12
+                    , hspec-wai-json    >= 0.10 && < 0.12
+                    , http-types        >= 0.12.3 && < 0.13
+                    , lens              >= 4.14 && < 5.2
+                    , lens-aeson        >= 1.0.1 && < 1.2
+                    , postgrest
+                    , process           >= 1.4.2 && < 1.7
+                    , protolude         >= 0.3.1 && < 0.4
+                    , regex-tdfa        >= 1.2.2 && < 1.4
+                    , wai-extra         >= 3.0.19 && < 3.2
+  ghc-options:        -O0 -Werror -Wall -fwarn-identities
+                      -fno-spec-constr -optP-Wno-nonportable-include-path
+                      -fwrite-ide-info
+                      -- https://github.com/PostgREST/postgrest/issues/387
+                      -with-rtsopts=-K1K
+
+test-suite doctests
+  type:               exitcode-stdio-1.0
+  default-language:   Haskell2010
+  default-extensions: OverloadedStrings
+                      NoImplicitPrelude
+  hs-source-dirs:     test/doc
+  main-is:            Main.hs
+  build-depends:      base              >= 4.9 && < 4.17
+                    , doctest           >= 0.8
+                    , postgrest
+                    , pretty-simple
+                    , protolude         >= 0.3.1 && < 0.4
+  ghc-options:        -threaded -O0 -Werror -Wall -fwarn-identities
+                      -fno-spec-constr -optP-Wno-nonportable-include-path

shell.nix

@@ -2,39 +2,34 @@
 # disabled by default. You can activate them by passing arguments to nix-shell,
 # e.g.:
 #
-#    nix-shell --arg release true
-#
-# This will provide you with a shell where the `postgrest-release-*` scripts
-# are available.
+#    nix-shell --arg docker true
 #
 # We highly recommend that use the PostgREST binary cache by installing cachix
 # (https://app.cachix.org/) and running `cachix use postgrest`.
 { docker ? false
 , memory ? false
-, release ? false
 }:
 let
   postgrest =
-    import ./default.nix;
+    import ./default.nix { };
 
-  pkgs =
-    postgrest.pkgs;
+  inherit (postgrest) pkgs;
 
-  lib =
-    pkgs.lib;
+  inherit (pkgs) lib;
 
   toolboxes =
     [
       postgrest.cabalTools
       postgrest.devTools
+      postgrest.loadtest
       postgrest.nixpkgsTools
       postgrest.style
       postgrest.tests
       postgrest.withTools
+      postgrest.release
     ]
     ++ lib.optional docker postgrest.docker
-    ++ lib.optional memory postgrest.memory
-    ++ lib.optional release postgrest.release;
+    ++ lib.optional memory postgrest.memory;
 
 in
 lib.overrideDerivation postgrest.env (
@@ -43,6 +38,7 @@ lib.overrideDerivation postgrest.env (
       base.buildInputs ++ [
         pkgs.cabal-install
         pkgs.cabal2nix
+        pkgs.git
         pkgs.postgresql
         postgrest.hsie.bin
       ]
@@ -50,13 +46,16 @@ lib.overrideDerivation postgrest.env (
 
     shellHook =
       ''
-        source ${pkgs.bashCompletion}/etc/profile.d/bash_completion.sh
-        source ${postgrest.hsie.bashCompletion}
+        export HISTFILE=.history
+
+        source ${pkgs.bash-completion}/etc/profile.d/bash_completion.sh
+        source ${pkgs.git}/share/git/contrib/completion/git-completion.bash
+        source ${postgrest.hsie.bash-completion}
 
       ''
       + builtins.concatStringsSep "\n" (
-        builtins.map (bashCompletion: "source ${bashCompletion}") (
-          builtins.concatLists (builtins.map (toolbox: toolbox.bashCompletion) toolboxes)
+        builtins.map (bash-completion: "source ${bash-completion}") (
+          builtins.concatLists (builtins.map (toolbox: toolbox.bash-completion) toolboxes)
         )
       );
   }

src/PostgREST/Admin.hs

@@ -0,0 +1,74 @@
+{-# LANGUAGE RecordWildCards #-}
+module PostgREST.Admin
+  ( postgrestAdmin
+  ) where
+
+import qualified Data.Text as T
+
+import Network.Socket
+import Network.Socket.ByteString
+
+import qualified Network.HTTP.Types.Status as HTTP
+import qualified Network.Wai               as Wai
+
+import qualified Hasql.Session as SQL
+
+import qualified PostgREST.AppState as AppState
+import           PostgREST.Config   (AppConfig (..))
+
+import Protolude
+
+-- | PostgREST admin application
+postgrestAdmin :: AppState.AppState -> AppConfig -> Wai.Application
+postgrestAdmin appState appConfig req respond  = do
+  isMainAppReachable  <- any isRight <$> reachMainApp appConfig
+  isSchemaCacheLoaded <- isJust <$> AppState.getDbStructure appState
+  isConnectionUp      <-
+    if configDbChannelEnabled appConfig
+      then AppState.getIsListenerOn appState
+      else isRight <$> AppState.usePool appState (SQL.sql "SELECT 1")
+
+  case Wai.pathInfo req of
+    ["ready"] ->
+      respond $ Wai.responseLBS (if isMainAppReachable && isConnectionUp && isSchemaCacheLoaded then HTTP.status200 else HTTP.status503) [] mempty
+    ["live"] ->
+      respond $ Wai.responseLBS (if isMainAppReachable then HTTP.status200 else HTTP.status503) [] mempty
+    _ ->
+      respond $ Wai.responseLBS HTTP.status404 [] mempty
+
+-- Try to connect to the main app socket
+-- Note that it doesn't even send a valid HTTP request, we just want to check that the main app is accepting connections
+-- The code for resolving the "*4", "!4", "*6", "!6", "*" special values is taken from
+-- https://hackage.haskell.org/package/streaming-commons-0.2.2.4/docs/src/Data.Streaming.Network.html#bindPortGenEx
+reachMainApp :: AppConfig -> IO [Either IOException ()]
+reachMainApp AppConfig{..} =
+  case configServerUnixSocket of
+    Just path ->  do
+      sock <- socket AF_UNIX Stream 0
+      (:[]) <$> try (do
+        connect sock $ SockAddrUnix path
+        withSocketsDo $ bracket (pure sock) close sendEmpty)
+    Nothing -> do
+      let
+        host | configServerHost `elem` ["*4", "!4", "*6", "!6", "*"] = Nothing
+             | otherwise                                             = Just configServerHost
+        filterAddrs xs =
+          case configServerHost of
+              "*4" -> ipv4Addrs xs ++ ipv6Addrs xs
+              "!4" -> ipv4Addrs xs
+              "*6" -> ipv6Addrs xs ++ ipv4Addrs xs
+              "!6" -> ipv6Addrs xs
+              _    -> xs
+        ipv4Addrs = filter ((/=) AF_INET6 . addrFamily)
+        ipv6Addrs = filter ((==) AF_INET6 . addrFamily)
+
+      addrs <- getAddrInfo (Just $ defaultHints { addrSocketType = Stream }) (T.unpack <$> host) (Just . show $ configServerPort)
+      tryAddr `traverse` filterAddrs addrs
+  where
+    sendEmpty sock = void $ send sock mempty
+    tryAddr :: AddrInfo -> IO (Either IOException ())
+    tryAddr addr = do
+      sock <- socket (addrFamily addr) (addrSocketType addr) (addrProtocol addr)
+      try $ do
+        connect sock $ addrAddress addr
+        withSocketsDo $ bracket (pure sock) close sendEmpty

src/PostgREST/App.hs

@@ -20,18 +20,17 @@ module PostgREST.App
 import Control.Monad.Except     (liftEither)
 import Data.Either.Combinators  (mapLeft)
 import Data.List                (union)
+import Data.Maybe               (fromJust)
 import Data.String              (IsString (..))
-import Data.Time.Clock          (UTCTime)
 import Network.Wai.Handler.Warp (defaultSettings, setHost, setPort,
                                  setServerName)
 import System.Posix.Types       (FileMode)
 
-import qualified Data.ByteString.Char8           as BS8
+import qualified Data.ByteString.Char8           as BS
 import qualified Data.ByteString.Lazy            as LBS
-import qualified Data.HashMap.Strict             as Map
-import qualified Data.Set                        as Set
-import qualified Hasql.DynamicStatements.Snippet as SQL
-import qualified Hasql.Pool                      as SQL
+import qualified Data.HashMap.Strict             as HM
+import qualified Data.Set                        as S
+import qualified Hasql.DynamicStatements.Snippet as SQL (Snippet)
 import qualified Hasql.Transaction               as SQL
 import qualified Hasql.Transaction.Sessions      as SQL
 import qualified Network.HTTP.Types.Header       as HTTP
@@ -40,10 +39,13 @@ import qualified Network.HTTP.Types.URI          as HTTP
 import qualified Network.Wai                     as Wai
 import qualified Network.Wai.Handler.Warp        as Warp
 
+import qualified PostgREST.Admin                    as Admin
 import qualified PostgREST.AppState                 as AppState
 import qualified PostgREST.Auth                     as Auth
+import qualified PostgREST.Cors                     as Cors
 import qualified PostgREST.DbStructure              as DbStructure
 import qualified PostgREST.Error                    as Error
+import qualified PostgREST.Logger                   as Logger
 import qualified PostgREST.Middleware               as Middleware
 import qualified PostgREST.OpenAPI                  as OpenAPI
 import qualified PostgREST.Query.QueryBuilder       as QueryBuilder
@@ -51,15 +53,15 @@ import qualified PostgREST.Query.Statements         as Statements
 import qualified PostgREST.RangeQuery               as RangeQuery
 import qualified PostgREST.Request.ApiRequest       as ApiRequest
 import qualified PostgREST.Request.DbRequestBuilder as ReqBuilder
+import qualified PostgREST.Request.Types            as ApiRequestTypes
 
 import PostgREST.AppState                (AppState)
+import PostgREST.Auth                    (AuthResult (..))
 import PostgREST.Config                  (AppConfig (..),
                                           LogLevel (..),
                                           OpenAPIMode (..))
 import PostgREST.Config.PgVersion        (PgVersion (..))
-import PostgREST.ContentType             (ContentType (..))
-import PostgREST.DbStructure             (DbStructure (..),
-                                          tablePKCols)
+import PostgREST.DbStructure             (DbStructure (..))
 import PostgREST.DbStructure.Identifiers (FieldName,
                                           QualifiedIdentifier (..),
                                           Schema)
@@ -70,23 +72,26 @@ import PostgREST.Error                   (Error)
 import PostgREST.GucHeader               (GucHeader,
                                           addHeadersIfNotIncluded,
                                           unwrapGucHeader)
+import PostgREST.MediaType               (MTPlanAttrs (..),
+                                          MediaType (..))
+import PostgREST.Query.Statements        (ResultSet (..))
 import PostgREST.Request.ApiRequest      (Action (..),
                                           ApiRequest (..),
                                           InvokeMethod (..),
-                                          Target (..))
+                                          Mutation (..), Target (..))
 import PostgREST.Request.Preferences     (PreferCount (..),
                                           PreferParameters (..),
-                                          PreferRepresentation (..))
-import PostgREST.Request.Types           (ReadRequest, fstFieldNames)
+                                          PreferRepresentation (..),
+                                          toAppliedHeader)
+import PostgREST.Request.QueryParams     (QueryParams (..))
+import PostgREST.Request.ReadQuery       (ReadRequest, fstFieldNames)
 import PostgREST.Version                 (prettyVersion)
 import PostgREST.Workers                 (connectionWorker, listener)
 
-import qualified PostgREST.ContentType      as ContentType
 import qualified PostgREST.DbStructure.Proc as Proc
+import qualified PostgREST.MediaType        as MediaType
 
-import Protolude      hiding (Handler, toS)
-import Protolude.Conv (toS)
-
+import Protolude hiding (Handler)
 
 data RequestContext = RequestContext
   { ctxConfig      :: AppConfig
@@ -113,6 +118,11 @@ run installHandlers maybeRunWithSocket appState = do
   when configDbChannelEnabled $ listener appState
 
   let app = postgrest configLogLevel appState (connectionWorker appState)
+      adminApp = Admin.postgrestAdmin appState conf
+
+  whenJust configAdminServerPort $ \adminPort -> do
+    AppState.logWithZTime appState $ "Admin server listening on port " <> show adminPort
+    void . forkIO $ Warp.runSettings (serverSettings conf & setPort adminPort) adminApp
 
   case configServerUnixSocket of
     Just socket ->
@@ -122,54 +132,68 @@ run installHandlers maybeRunWithSocket appState = do
           AppState.logWithZTime appState $ "Listening on unix socket " <> show socket
           runWithSocket (serverSettings conf) app configServerUnixSocketMode socket
         Nothing ->
-          panic "Cannot run with socket on non-unix plattforms."
+          panic "Cannot run with unix socket on non-unix platforms."
     Nothing ->
       do
         AppState.logWithZTime appState $ "Listening on port " <> show configServerPort
         Warp.runSettings (serverSettings conf) app
+  where
+    whenJust :: Applicative m => Maybe a -> (a -> m ()) -> m ()
+    whenJust mg f = maybe (pure ()) f mg
 
 serverSettings :: AppConfig -> Warp.Settings
 serverSettings AppConfig{..} =
   defaultSettings
     & setHost (fromString $ toS configServerHost)
     & setPort configServerPort
-    & setServerName (toS $ "postgrest/" <> prettyVersion)
+    & setServerName ("postgrest/" <> prettyVersion)
 
 -- | PostgREST application
 postgrest :: LogLevel -> AppState.AppState -> IO () -> Wai.Application
-postgrest logLev appState connWorker =
-  Middleware.pgrstMiddleware logLev $
-    \req respond -> do
-      time <- AppState.getTime appState
-      conf <- AppState.getConfig appState
-      maybeDbStructure <- AppState.getDbStructure appState
-      pgVer <- AppState.getPgVersion appState
-      jsonDbS <- AppState.getJsonDbS appState
+postgrest logLevel appState connWorker =
+  Cors.middleware .
+  Auth.middleware appState .
+  Logger.middleware logLevel $
+    -- fromJust can be used, because the auth middleware will **always** add
+    -- some AuthResult to the vault.
+    \req respond -> case fromJust $ Auth.getResult req of
+      Left err -> respond $ Error.errorResponseFor err
+      Right authResult -> do
+        conf <- AppState.getConfig appState
+        maybeDbStructure <- AppState.getDbStructure appState
+        pgVer <- AppState.getPgVersion appState
+        jsonDbS <- AppState.getJsonDbS appState
 
-      let
-        eitherResponse :: IO (Either Error Wai.Response)
-        eitherResponse =
-          runExceptT $ postgrestResponse conf maybeDbStructure jsonDbS pgVer (AppState.getPool appState) time req
+        let
+          eitherResponse :: IO (Either Error Wai.Response)
+          eitherResponse =
+            runExceptT $ postgrestResponse appState conf maybeDbStructure jsonDbS pgVer authResult req
 
-      response <- either Error.errorResponseFor identity <$> eitherResponse
+        response <- either Error.errorResponseFor identity <$> eitherResponse
+        -- Launch the connWorker when the connection is down.  The postgrest
+        -- function can respond successfully (with a stale schema cache) before
+        -- the connWorker is done.
+        let isPGAway = Wai.responseStatus response == HTTP.status503
+        when isPGAway connWorker
+        resp <- addRetryHint isPGAway appState response
+        respond resp
 
-      -- Launch the connWorker when the connection is down.  The postgrest
-      -- function can respond successfully (with a stale schema cache) before
-      -- the connWorker is done.
-      when (Wai.responseStatus response == HTTP.status503) connWorker
-
-      respond response
+addRetryHint :: Bool -> AppState -> Wai.Response -> IO Wai.Response
+addRetryHint shouldAdd appState response = do
+  delay <- AppState.getRetryNextIn appState
+  let h = ("Retry-After", BS.pack $ show delay)
+  return $ Wai.mapResponseHeaders (\hs -> if shouldAdd then h:hs else hs) response
 
 postgrestResponse
-  :: AppConfig
+  :: AppState.AppState
+  -> AppConfig
   -> Maybe DbStructure
   -> ByteString
   -> PgVersion
-  -> SQL.Pool
-  -> UTCTime
+  -> AuthResult
   -> Wai.Request
   -> Handler IO Wai.Response
-postgrestResponse conf maybeDbStructure jsonDbS pgVer pool time req = do
+postgrestResponse appState conf@AppConfig{..} maybeDbStructure jsonDbS pgVer AuthResult{..} req = do
   body <- lift $ Wai.strictRequestBody req
 
   dbStructure <-
@@ -177,32 +201,30 @@ postgrestResponse conf maybeDbStructure jsonDbS pgVer pool time req = do
       Just dbStructure ->
         return dbStructure
       Nothing ->
-        throwError Error.ConnectionLostError
+        throwError Error.NoSchemaCacheError
 
-  apiRequest@ApiRequest{..} <-
+  apiRequest <-
     liftEither . mapLeft Error.ApiRequestError $
       ApiRequest.userApiRequest conf dbStructure req body
 
-  -- The JWT must be checked before touching the db
-  jwtClaims <- Auth.jwtClaims conf (toS iJWT) time
+  let ctx apiReq = RequestContext conf dbStructure apiReq pgVer
 
-  let
-    handleReq apiReq =
-      handleRequest $ RequestContext conf dbStructure apiReq pgVer
+  if iAction apiRequest == ActionInfo then
+    handleInfo (iTarget apiRequest) (ctx apiRequest)
+  else
+    runDbHandler appState (txMode apiRequest) (Just authRole /= configDbAnonRole) configDbPreparedStatements .
+      Middleware.optionalRollback conf apiRequest $
+        Middleware.runPgLocals conf authClaims authRole (handleRequest . ctx) apiRequest jsonDbS pgVer
 
-  runDbHandler pool (txMode apiRequest) jwtClaims (configDbPreparedStatements conf) .
-    Middleware.optionalRollback conf apiRequest $
-      Middleware.runPgLocals conf jwtClaims handleReq apiRequest jsonDbS
-
-runDbHandler :: SQL.Pool -> SQL.Mode -> Auth.JWTClaims -> Bool -> DbHandler a -> Handler IO a
-runDbHandler pool mode jwtClaims prepared handler = do
+runDbHandler :: AppState.AppState -> SQL.Mode -> Bool -> Bool -> DbHandler b -> Handler IO b
+runDbHandler appState mode authenticated prepared handler = do
   dbResp <-
     let transaction = if prepared then SQL.transaction else SQL.unpreparedTransaction in
-    lift . SQL.use pool . transaction SQL.ReadCommitted mode $ runExceptT handler
+    lift . AppState.usePool appState . transaction SQL.ReadCommitted mode $ runExceptT handler
 
   resp <-
     liftEither . mapLeft Error.PgErr $
-      mapLeft (Error.PgError $ Auth.containsRole jwtClaims) dbResp
+      mapLeft (Error.PgError authenticated) dbResp
 
   liftEither resp
 
@@ -211,22 +233,22 @@ handleRequest context@(RequestContext _ _ ApiRequest{..} _) =
   case (iAction, iTarget) of
     (ActionRead headersOnly, TargetIdent identifier) ->
       handleRead headersOnly identifier context
-    (ActionCreate, TargetIdent identifier) ->
+    (ActionMutate MutationCreate, TargetIdent identifier) ->
       handleCreate identifier context
-    (ActionUpdate, TargetIdent identifier) ->
+    (ActionMutate MutationUpdate, TargetIdent identifier) ->
       handleUpdate identifier context
-    (ActionSingleUpsert, TargetIdent identifier) ->
+    (ActionMutate MutationSingleUpsert, TargetIdent identifier) ->
       handleSingleUpsert identifier context
-    (ActionDelete, TargetIdent identifier) ->
+    (ActionMutate MutationDelete, TargetIdent identifier) ->
       handleDelete identifier context
-    (ActionInfo, TargetIdent identifier) ->
-      handleInfo identifier context
     (ActionInvoke invMethod, TargetProc proc _) ->
       handleInvoke invMethod proc context
     (ActionInspect headersOnly, TargetDefaultSpec tSchema) ->
       handleOpenApi headersOnly tSchema context
     _ ->
-      throwError Error.NotFound
+      -- This is unreachable as the ApiRequest.hs rejects it before
+      -- TODO Refactor the Action/Target types to remove this line
+      throwError $ Error.ApiRequestError ApiRequestTypes.NotFound
 
 handleRead :: Bool -> QualifiedIdentifier -> RequestContext -> DbHandler Wai.Response
 handleRead headersOnly identifier context@RequestContext{..} = do
@@ -238,9 +260,9 @@ handleRead headersOnly identifier context@RequestContext{..} = do
     AppConfig{..} = ctxConfig
     countQuery = QueryBuilder.readRequestToCountQuery req
 
-  (tableTotal, queryTotal, _ , body, gucHeaders, gucStatus) <-
-    lift . SQL.statement mempty $
-      Statements.createReadStatement
+  resultSet <-
+     lift . SQL.statement mempty $
+      Statements.prepareRead
         (QueryBuilder.readRequestToQuery req)
         (if iPreferCount == Just EstimatedCount then
            -- LIMIT maxRows + 1 so we can determine below that maxRows was surpassed
@@ -248,30 +270,33 @@ handleRead headersOnly identifier context@RequestContext{..} = do
          else
            countQuery
         )
-        (iAcceptContentType == CTSingularJSON)
         (shouldCount iPreferCount)
-        (iAcceptContentType == CTTextCSV)
+        iAcceptMediaType
         bField
-        ctxPgVersion
         configDbPreparedStatements
 
-  total <- readTotal ctxConfig ctxApiRequest tableTotal countQuery
-  response <- liftEither $ gucResponse <$> gucStatus <*> gucHeaders
+  case resultSet of
+    RSStandard{..} -> do
+      total <- readTotal ctxConfig ctxApiRequest rsTableTotal countQuery
+      response <- liftEither $ gucResponse <$> rsGucStatus <*> rsGucHeaders
 
-  let
-    (status, contentRange) = RangeQuery.rangeStatusHeader iTopLevelRange queryTotal total
-    headers =
-      [ contentRange
-      , ( "Content-Location"
-        , "/"
-            <> toS (qiName identifier)
-            <> if BS8.null iCanonicalQS then mempty else "?" <> toS iCanonicalQS
-        )
-      ]
-      ++ contentTypeHeaders context
+      let
+        (status, contentRange) = RangeQuery.rangeStatusHeader iTopLevelRange rsQueryTotal total
+        headers =
+          [ contentRange
+          , ( "Content-Location"
+            , "/"
+                <> toUtf8 (qiName identifier)
+                <> if BS.null (qsCanonical iQueryParams) then mempty else "?" <> qsCanonical iQueryParams
+            )
+          ]
+          ++ contentTypeHeaders context
 
-  failNotSingular iAcceptContentType queryTotal . response status headers $
-    if headersOnly then mempty else toS body
+      failNotSingular iAcceptMediaType rsQueryTotal . response status headers $
+        if headersOnly then mempty else LBS.fromStrict rsBody
+
+    RSPlan plan ->
+      pure $ Wai.responseLBS HTTP.status200 (contentTypeHeaders context) $ LBS.fromStrict plan
 
 readTotal :: AppConfig -> ApiRequest -> Maybe Int64 -> SQL.Snippet -> DbHandler (Maybe Int64)
 readTotal AppConfig{..} ApiRequest{..} tableTotal countQuery =
@@ -287,131 +312,159 @@ readTotal AppConfig{..} ApiRequest{..} tableTotal countQuery =
       return tableTotal
   where
     explain =
-      lift . SQL.statement mempty . Statements.createExplainStatement countQuery $
+      lift . SQL.statement mempty . Statements.preparePlanRows countQuery $
         configDbPreparedStatements
 
 handleCreate :: QualifiedIdentifier -> RequestContext -> DbHandler Wai.Response
 handleCreate identifier@QualifiedIdentifier{..} context@RequestContext{..} = do
   let
     ApiRequest{..} = ctxApiRequest
-    pkCols = tablePKCols ctxDbStructure qiSchema qiName
+    pkCols = if iPreferRepresentation /= None || isJust iPreferResolution
+      then maybe mempty tablePKCols $ HM.lookup identifier $ dbTables ctxDbStructure
+      else mempty
 
-  WriteQueryResult{..} <- writeQuery identifier True pkCols context
+  resultSet <- writeQuery MutationCreate identifier True pkCols context
 
-  let
-    response = gucResponse resGucStatus resGucHeaders
-    headers =
-      catMaybes
-        [ if null resFields then
-            Nothing
-          else
-            Just
-              ( HTTP.hLocation
-              , "/"
-                  <> toS qiName
-                  <> HTTP.renderSimpleQuery True (splitKeyValue <$> resFields)
-              )
-        , Just . RangeQuery.contentRangeH 1 0 $
-            if shouldCount iPreferCount then Just resQueryTotal else Nothing
-        , if null pkCols && isNothing iOnConflict then
-            Nothing
-          else
-            (\x -> ("Preference-Applied", BS8.pack $ show x)) <$> iPreferResolution
-        ]
+  case resultSet of
+    RSStandard{..} -> do
 
-  failNotSingular iAcceptContentType resQueryTotal $
-    if iPreferRepresentation == Full then
-      response HTTP.status201 (headers ++ contentTypeHeaders context) (toS resBody)
-    else
-      response HTTP.status201 headers mempty
+      response <- liftEither $ gucResponse <$> rsGucStatus <*> rsGucHeaders
+
+      let
+        headers =
+          catMaybes
+            [ if null rsLocation then
+                Nothing
+              else
+                Just
+                  ( HTTP.hLocation
+                  , "/"
+                      <> toUtf8 qiName
+                      <> HTTP.renderSimpleQuery True rsLocation
+                  )
+            , Just . RangeQuery.contentRangeH 1 0 $
+                if shouldCount iPreferCount then Just rsQueryTotal else Nothing
+            , if null pkCols && isNothing (qsOnConflict iQueryParams) then
+                Nothing
+              else
+                toAppliedHeader <$> iPreferResolution
+            ]
+
+      failNotSingular iAcceptMediaType rsQueryTotal $
+        if iPreferRepresentation == Full then
+          response HTTP.status201 (headers ++ contentTypeHeaders context) (LBS.fromStrict rsBody)
+        else
+          response HTTP.status201 headers mempty
+
+    RSPlan plan ->
+      pure $ Wai.responseLBS HTTP.status200 (contentTypeHeaders context) $ LBS.fromStrict plan
 
 handleUpdate :: QualifiedIdentifier -> RequestContext -> DbHandler Wai.Response
 handleUpdate identifier context@(RequestContext _ _ ApiRequest{..} _) = do
-  WriteQueryResult{..} <- writeQuery identifier False mempty context
+  resultSet <- writeQuery MutationUpdate identifier False mempty context
 
-  let
-    response = gucResponse resGucStatus resGucHeaders
-    fullRepr = iPreferRepresentation == Full
-    updateIsNoOp = Set.null iColumns
-    status
-      | resQueryTotal == 0 && not updateIsNoOp = HTTP.status404
-      | fullRepr = HTTP.status200
-      | otherwise = HTTP.status204
-    contentRangeHeader =
-      RangeQuery.contentRangeH 0 (resQueryTotal - 1) $
-        if shouldCount iPreferCount then Just resQueryTotal else Nothing
+  case resultSet of
+    RSStandard{..} -> do
+      response <- liftEither $ gucResponse <$> rsGucStatus <*> rsGucHeaders
 
-  failNotSingular iAcceptContentType resQueryTotal $
-    if fullRepr then
-      response status (contentTypeHeaders context ++ [contentRangeHeader]) (toS resBody)
-    else
-      response status [contentRangeHeader] mempty
+      let
+        fullRepr = iPreferRepresentation == Full
+        updateIsNoOp = S.null iColumns
+        status
+          | rsQueryTotal == 0 && not updateIsNoOp = HTTP.status404
+          | fullRepr = HTTP.status200
+          | otherwise = HTTP.status204
+        contentRangeHeader =
+          RangeQuery.contentRangeH 0 (rsQueryTotal - 1) $
+            if shouldCount iPreferCount then Just rsQueryTotal else Nothing
+
+      failChangesOffLimits (RangeQuery.rangeLimit iTopLevelRange) rsQueryTotal =<<
+        failNotSingular iAcceptMediaType rsQueryTotal (
+          if fullRepr then
+            response status (contentTypeHeaders context ++ [contentRangeHeader]) (LBS.fromStrict rsBody)
+          else
+            response status [contentRangeHeader] mempty)
+
+    RSPlan plan ->
+      pure $ Wai.responseLBS HTTP.status200 (contentTypeHeaders context) $ LBS.fromStrict plan
 
 handleSingleUpsert :: QualifiedIdentifier -> RequestContext-> DbHandler Wai.Response
-handleSingleUpsert identifier context@(RequestContext _ _ ApiRequest{..} _) = do
-  when (iTopLevelRange /= RangeQuery.allRange) $
-    throwError Error.PutRangeNotAllowedError
+handleSingleUpsert identifier context@(RequestContext _ ctxDbStructure ApiRequest{..} _) = do
+  let pkCols = maybe mempty tablePKCols $ HM.lookup identifier $ dbTables ctxDbStructure
 
-  WriteQueryResult{..} <- writeQuery identifier False mempty context
+  resultSet <- writeQuery MutationSingleUpsert identifier False pkCols context
 
-  let response = gucResponse resGucStatus resGucHeaders
+  case resultSet of
+    RSStandard {..} -> do
 
-  -- Makes sure the querystring pk matches the payload pk
-  -- e.g. PUT /items?id=eq.1 { "id" : 1, .. } is accepted,
-  -- PUT /items?id=eq.14 { "id" : 2, .. } is rejected.
-  -- If this condition is not satisfied then nothing is inserted,
-  -- check the WHERE for INSERT in QueryBuilder.hs to see how it's done
-  when (resQueryTotal /= 1) $ do
-    lift SQL.condemn
-    throwError Error.PutMatchingPkError
+      response <- liftEither $ gucResponse <$> rsGucStatus <*> rsGucHeaders
 
-  return $
-    if iPreferRepresentation == Full then
-      response HTTP.status200 (contentTypeHeaders context) (toS resBody)
-    else
-      response HTTP.status204 (contentTypeHeaders context) mempty
+      -- Makes sure the querystring pk matches the payload pk
+      -- e.g. PUT /items?id=eq.1 { "id" : 1, .. } is accepted,
+      -- PUT /items?id=eq.14 { "id" : 2, .. } is rejected.
+      -- If this condition is not satisfied then nothing is inserted,
+      -- check the WHERE for INSERT in QueryBuilder.hs to see how it's done
+      when (rsQueryTotal /= 1) $ do
+        lift SQL.condemn
+        throwError Error.PutMatchingPkError
+
+      return $
+        if iPreferRepresentation == Full then
+          response HTTP.status200 (contentTypeHeaders context) (LBS.fromStrict rsBody)
+        else
+          response HTTP.status204 [] mempty
+
+    RSPlan plan ->
+      pure $ Wai.responseLBS HTTP.status200 (contentTypeHeaders context) $ LBS.fromStrict plan
 
 handleDelete :: QualifiedIdentifier -> RequestContext -> DbHandler Wai.Response
 handleDelete identifier context@(RequestContext _ _ ApiRequest{..} _) = do
-  WriteQueryResult{..} <- writeQuery identifier False mempty context
+  resultSet <- writeQuery MutationDelete identifier False mempty context
 
-  let
-    response = gucResponse resGucStatus resGucHeaders
-    contentRangeHeader =
-      RangeQuery.contentRangeH 1 0 $
-        if shouldCount iPreferCount then Just resQueryTotal else Nothing
+  case resultSet of
+    RSStandard {..} -> do
 
-  failNotSingular iAcceptContentType resQueryTotal $
-    if iPreferRepresentation == Full then
-      response HTTP.status200
-        (contentTypeHeaders context ++ [contentRangeHeader])
-        (toS resBody)
-    else
-      response HTTP.status204 [contentRangeHeader] mempty
+      response <- liftEither $ gucResponse <$> rsGucStatus <*> rsGucHeaders
 
-handleInfo :: Monad m => QualifiedIdentifier -> RequestContext -> Handler m Wai.Response
-handleInfo identifier RequestContext{..} =
-  case find tableMatches $ dbTables ctxDbStructure of
-    Just table ->
-      return $ Wai.responseLBS HTTP.status200 [allOrigins, allowH table] mempty
-    Nothing ->
-      throwError Error.NotFound
+      let
+        contentRangeHeader =
+          RangeQuery.contentRangeH 1 0 $
+            if shouldCount iPreferCount then Just rsQueryTotal else Nothing
+
+      failChangesOffLimits (RangeQuery.rangeLimit iTopLevelRange) rsQueryTotal =<<
+        failNotSingular iAcceptMediaType rsQueryTotal (
+          if iPreferRepresentation == Full then
+            response HTTP.status200
+              (contentTypeHeaders context ++ [contentRangeHeader])
+              (LBS.fromStrict rsBody)
+          else
+            response HTTP.status204 [contentRangeHeader] mempty)
+
+    RSPlan plan ->
+      pure $ Wai.responseLBS HTTP.status200 (contentTypeHeaders context) $ LBS.fromStrict plan
+
+handleInfo :: Monad m => Target -> RequestContext -> Handler m Wai.Response
+handleInfo target RequestContext{..} =
+  case target of
+    TargetIdent identifier ->
+      case HM.lookup identifier (dbTables ctxDbStructure) of
+        Just tbl -> infoResponse $ allowH tbl
+        Nothing  -> throwError $ Error.ApiRequestError ApiRequestTypes.NotFound
+    TargetProc pd _
+      | pdVolatility pd == Volatile -> infoResponse "OPTIONS,POST"
+      | otherwise                   -> infoResponse "OPTIONS,GET,HEAD,POST"
+    TargetDefaultSpec _             -> infoResponse "OPTIONS,GET,HEAD"
   where
+    infoResponse allowHeader = return $ Wai.responseLBS HTTP.status200 [allOrigins, (HTTP.hAllow, allowHeader)] mempty
     allOrigins = ("Access-Control-Allow-Origin", "*")
     allowH table =
-      ( HTTP.hAllow
-      , BS8.intercalate "," $
-          ["OPTIONS,GET,HEAD"]
-          ++ ["POST" | tableInsertable table]
-          ++ ["PUT" | tableInsertable table && tableUpdatable table && hasPK]
-          ++ ["PATCH" | tableUpdatable table]
-          ++ ["DELETE" | tableDeletable table]
-      )
-    tableMatches table =
-      tableName table == qiName identifier
-      && tableSchema table == qiSchema identifier
-    hasPK =
-      not $ null $ tablePKCols ctxDbStructure (qiSchema identifier) (qiName identifier)
+      let hasPK = not . null $ tablePKCols table in
+      BS.intercalate "," $
+          ["OPTIONS,GET,HEAD"] ++
+          ["POST" | tableInsertable table] ++
+          ["PUT" | tableInsertable table && tableUpdatable table && hasPK] ++
+          ["PATCH" | tableUpdatable table] ++
+          ["DELETE" | tableDeletable table]
 
 handleInvoke :: InvokeMethod -> ProcDescription -> RequestContext -> DbHandler Wai.Response
 handleInvoke invMethod proc context@RequestContext{..} = do
@@ -423,67 +476,64 @@ handleInvoke invMethod proc context@RequestContext{..} = do
         (pdSchema proc)
         (fromMaybe (pdName proc) $ Proc.procTableName proc)
 
-    returnsSingle (ApiRequest.TargetProc target _) = Proc.procReturnsSingle target
-    returnsSingle _                                = False
-
   req <- readRequest identifier context
   bField <- binaryField context req
 
-  (tableTotal, queryTotal, body, gucHeaders, gucStatus) <-
+  let callReq = ReqBuilder.callRequest proc ctxApiRequest req
+
+  resultSet <-
     lift . SQL.statement mempty $
-      Statements.callProcStatement
-        (returnsScalar iTarget)
-        (returnsSingle iTarget)
-        (QueryBuilder.requestToCallProcQuery
-          (QualifiedIdentifier (pdSchema proc) (pdName proc))
-          (Proc.specifiedProcArgs iColumns proc)
-          iPayload
-          (returnsScalar iTarget)
-          iPreferParameters
-          (ReqBuilder.returningCols req [])
-        )
+      Statements.prepareCall
+        (Proc.procReturnsScalar proc)
+        (Proc.procReturnsSingle proc)
+        (QueryBuilder.requestToCallProcQuery callReq)
         (QueryBuilder.readRequestToQuery req)
         (QueryBuilder.readRequestToCountQuery req)
         (shouldCount iPreferCount)
-        (iAcceptContentType == CTSingularJSON)
-        (iAcceptContentType == CTTextCSV)
+        iAcceptMediaType
         (iPreferParameters == Just MultipleObjects)
         bField
-        ctxPgVersion
         (configDbPreparedStatements ctxConfig)
 
-  response <- liftEither $ gucResponse <$> gucStatus <*> gucHeaders
+  case resultSet of
+    RSStandard {..} -> do
+      response <- liftEither $ gucResponse <$> rsGucStatus <*> rsGucHeaders
+      let
+        (status, contentRange) =
+          RangeQuery.rangeStatusHeader iTopLevelRange rsQueryTotal rsTableTotal
 
-  let
-    (status, contentRange) =
-      RangeQuery.rangeStatusHeader iTopLevelRange queryTotal tableTotal
+      failNotSingular iAcceptMediaType rsQueryTotal $
+        if Proc.procReturnsVoid proc then
+          response HTTP.status204 [contentRange] mempty
+        else
+          response status
+            (contentTypeHeaders context ++ [contentRange])
+            (if invMethod == InvHead then mempty else LBS.fromStrict rsBody)
 
-  failNotSingular iAcceptContentType queryTotal $
-    response status
-      (contentTypeHeaders context ++ [contentRange])
-      (if invMethod == InvHead then mempty else toS body)
+    RSPlan plan ->
+      pure $ Wai.responseLBS HTTP.status200 (contentTypeHeaders context) $ LBS.fromStrict plan
 
 handleOpenApi :: Bool -> Schema -> RequestContext -> DbHandler Wai.Response
-handleOpenApi headersOnly tSchema (RequestContext conf@AppConfig{..} dbStructure apiRequest _) = do
+handleOpenApi headersOnly tSchema (RequestContext conf@AppConfig{..} dbStructure apiRequest ctxPgVersion) = do
   body <-
     lift $ case configOpenApiMode of
       OAFollowPriv ->
         OpenAPI.encode conf dbStructure
-           <$> SQL.statement tSchema (DbStructure.accessibleTables configDbPreparedStatements)
-           <*> SQL.statement tSchema (DbStructure.accessibleProcs configDbPreparedStatements)
+           <$> SQL.statement [tSchema] (DbStructure.accessibleTables ctxPgVersion configDbPreparedStatements)
+           <*> SQL.statement tSchema (DbStructure.accessibleProcs ctxPgVersion configDbPreparedStatements)
            <*> SQL.statement tSchema (DbStructure.schemaDescription configDbPreparedStatements)
       OAIgnorePriv ->
         OpenAPI.encode conf dbStructure
-              (filter (\x -> tableSchema x == tSchema) $ DbStructure.dbTables dbStructure)
-              (Map.filterWithKey (\(QualifiedIdentifier sch _) _ ->  sch == tSchema) $ DbStructure.dbProcs dbStructure)
+              (HM.filterWithKey (\(QualifiedIdentifier sch _) _ ->  sch == tSchema) $ DbStructure.dbTables dbStructure)
+              (HM.filterWithKey (\(QualifiedIdentifier sch _) _ ->  sch == tSchema) $ DbStructure.dbProcs dbStructure)
           <$> SQL.statement tSchema (DbStructure.schemaDescription configDbPreparedStatements)
       OADisabled ->
         pure mempty
 
   return $
     Wai.responseLBS HTTP.status200
-      (ContentType.toHeader CTOpenAPI : maybeToList (profileHeader apiRequest))
-      (if headersOnly then mempty else toS body)
+      (MediaType.toContentType MTOpenAPI : maybeToList (profileHeader apiRequest))
+      (if headersOnly then mempty else body)
 
 txMode :: ApiRequest -> SQL.Mode
 txMode ApiRequest{..} =
@@ -505,39 +555,25 @@ txMode ApiRequest{..} =
     _ ->
       SQL.Write
 
--- | Result from executing a write query on the database
-data WriteQueryResult = WriteQueryResult
-  { resQueryTotal :: Int64
-  , resFields     :: [ByteString]
-  , resBody       :: ByteString
-  , resGucStatus  :: Maybe HTTP.Status
-  , resGucHeaders :: [GucHeader]
-  }
-
-writeQuery :: QualifiedIdentifier -> Bool -> [Text] -> RequestContext -> DbHandler WriteQueryResult
-writeQuery identifier@QualifiedIdentifier{..} isInsert pkCols context@RequestContext{..} = do
+writeQuery :: Mutation -> QualifiedIdentifier -> Bool -> [Text] -> RequestContext -> DbHandler ResultSet
+writeQuery mutation identifier@QualifiedIdentifier{..} isInsert pkCols context@RequestContext{..} = do
   readReq <- readRequest identifier context
 
   mutateReq <-
     liftEither $
-      ReqBuilder.mutateRequest qiSchema qiName ctxApiRequest
-        (tablePKCols ctxDbStructure qiSchema qiName)
+      ReqBuilder.mutateRequest mutation qiSchema qiName ctxApiRequest
+        pkCols
         readReq
 
-  (_, queryTotal, fields, body, gucHeaders, gucStatus) <-
-    lift . SQL.statement mempty $
-      Statements.createWriteStatement
-        (QueryBuilder.readRequestToQuery readReq)
-        (QueryBuilder.mutateRequestToQuery mutateReq)
-        (iAcceptContentType ctxApiRequest == CTSingularJSON)
-        isInsert
-        (iAcceptContentType ctxApiRequest == CTTextCSV)
-        (iPreferRepresentation ctxApiRequest)
-        pkCols
-        ctxPgVersion
-        (configDbPreparedStatements ctxConfig)
-
-  liftEither $ WriteQueryResult queryTotal fields body <$> gucStatus <*> gucHeaders
+  lift . SQL.statement mempty $
+    Statements.prepareWrite
+      (QueryBuilder.readRequestToQuery readReq)
+      (QueryBuilder.mutateRequestToQuery mutateReq)
+      isInsert
+      (iAcceptMediaType ctxApiRequest)
+      (iPreferRepresentation ctxApiRequest)
+      pkCols
+      (configDbPreparedStatements ctxConfig)
 
 -- | Response with headers and status overridden from GUCs.
 gucResponse
@@ -554,15 +590,25 @@ gucResponse gucStatus gucHeaders status headers =
 -- |
 -- Fail a response if a single JSON object was requested and not exactly one
 -- was found.
-failNotSingular :: ContentType -> Int64 -> Wai.Response -> DbHandler Wai.Response
-failNotSingular contentType queryTotal response =
-  if contentType == CTSingularJSON && queryTotal /= 1 then
+failNotSingular :: MediaType -> Int64 -> Wai.Response -> DbHandler Wai.Response
+failNotSingular mediaType queryTotal response =
+  if mediaType == MTSingularJSON && queryTotal /= 1 then
     do
       lift SQL.condemn
       throwError $ Error.singularityError queryTotal
   else
     return response
 
+failChangesOffLimits :: Maybe Integer -> Int64 -> Wai.Response -> DbHandler Wai.Response
+failChangesOffLimits (Just maxChanges) queryTotal response =
+  if queryTotal > fromIntegral maxChanges
+  then do
+      lift SQL.condemn
+      throwError $ Error.OffLimitsChangesError queryTotal maxChanges
+  else
+    return response
+failChangesOffLimits _ _ response = return response
+
 shouldCount :: Maybe PreferCount -> Bool
 shouldCount preferCount =
   preferCount == Just ExactCount || preferCount == Just EstimatedCount
@@ -580,16 +626,16 @@ readRequest QualifiedIdentifier{..} (RequestContext AppConfig{..} dbStructure ap
 
 contentTypeHeaders :: RequestContext -> [HTTP.Header]
 contentTypeHeaders RequestContext{..} =
-  ContentType.toHeader (iAcceptContentType ctxApiRequest) : maybeToList (profileHeader ctxApiRequest)
+  MediaType.toContentType (iAcceptMediaType ctxApiRequest) : maybeToList (profileHeader ctxApiRequest)
 
--- | If raw(binary) output is requested, check that ContentType is one of the
--- admitted rawContentTypes and that`?select=...` contains only one field other
+-- | If raw(binary) output is requested, check that MediaType is one of the
+-- admitted rawMediaTypes and that`?select=...` contains only one field other
 -- than `*`
 binaryField :: Monad m => RequestContext -> ReadRequest -> Handler m (Maybe FieldName)
 binaryField RequestContext{..} readReq
-  | returnsScalar (iTarget ctxApiRequest) && iAcceptContentType ctxApiRequest `elem` rawContentTypes ctxConfig =
+  | returnsScalar (iTarget ctxApiRequest) && isRawMediaType =
       return $ Just "pgrst_scalar"
-  | iAcceptContentType ctxApiRequest `elem` rawContentTypes ctxConfig =
+  | isRawMediaType =
       let
         fldNames = fstFieldNames readReq
         fieldName = headMay fldNames
@@ -597,20 +643,18 @@ binaryField RequestContext{..} readReq
       if length fldNames == 1 && fieldName /= Just "*" then
         return fieldName
       else
-        throwError $ Error.BinaryFieldError (iAcceptContentType ctxApiRequest)
+        throwError $ Error.BinaryFieldError mediaType
   | otherwise =
       return Nothing
-
-rawContentTypes :: AppConfig -> [ContentType]
-rawContentTypes AppConfig{..} =
-  (ContentType.decodeContentType <$> configRawMediaTypes) `union` [CTOctetStream, CTTextPlain]
+  where
+    mediaType = iAcceptMediaType ctxApiRequest
+    isRawMediaType = mediaType `elem` configRawMediaTypes ctxConfig `union` [MTOctetStream, MTTextPlain, MTTextXML] || isRawPlan mediaType
+    isRawPlan mt = case mt of
+      MTPlan (MTPlanAttrs (Just MTOctetStream) _ _) -> True
+      MTPlan (MTPlanAttrs (Just MTTextPlain) _ _)   -> True
+      MTPlan (MTPlanAttrs (Just MTTextXML) _ _)     -> True
+      _                                             -> False
 
 profileHeader :: ApiRequest -> Maybe HTTP.Header
 profileHeader ApiRequest{..} =
-  (,) "Content-Profile" <$> (toS <$> iProfile)
-
-splitKeyValue :: ByteString -> (ByteString, ByteString)
-splitKeyValue kv =
-  (k, BS8.tail v)
-  where
-    (k, v) = BS8.break (== '=') kv
+  (,) "Content-Profile" <$> (toUtf8 <$> iProfile)

src/PostgREST/AppState.hs

@@ -2,28 +2,33 @@
 
 module PostgREST.AppState
   ( AppState
+  , destroy
   , getConfig
   , getDbStructure
-  , getIsWorkerOn
+  , getIsListenerOn
   , getJsonDbS
   , getMainThreadId
   , getPgVersion
-  , getPool
+  , getRetryNextIn
   , getTime
+  , getWorkerSem
   , init
   , initWithPool
   , logWithZTime
   , putConfig
   , putDbStructure
-  , putIsWorkerOn
+  , putIsListenerOn
   , putJsonDbS
   , putPgVersion
+  , putRetryNextIn
   , releasePool
   , signalListener
+  , usePool
   , waitListener
   ) where
 
-import qualified Hasql.Pool as P
+import qualified Hasql.Pool    as SQL
+import qualified Hasql.Session as SQL
 
 import Control.AutoUpdate (defaultUpdateSettings, mkAutoUpdate,
                            updateAction)
@@ -37,21 +42,22 @@ import PostgREST.Config           (AppConfig (..))
 import PostgREST.Config.PgVersion (PgVersion (..), minimumPgVersion)
 import PostgREST.DbStructure      (DbStructure)
 
-import Protolude      hiding (toS)
-import Protolude.Conv (toS)
+import Protolude
 
 
 data AppState = AppState
-  { statePool         :: P.Pool -- | Connection pool, either a 'Connection' or a 'ConnectionError'
+  { statePool         :: SQL.Pool -- | Connection pool, either a 'Connection' or a 'ConnectionError'
   , statePgVersion    :: IORef PgVersion
   -- | No schema cache at the start. Will be filled in by the connectionWorker
   , stateDbStructure  :: IORef (Maybe DbStructure)
   -- | Cached DbStructure in json
   , stateJsonDbS      :: IORef ByteString
-  -- | Helper ref to make sure just one connectionWorker can run at a time
-  , stateIsWorkerOn   :: IORef Bool
+  -- | Binary semaphore to make sure just one connectionWorker can run at a time
+  , stateWorkerSem    :: MVar ()
   -- | Binary semaphore used to sync the listener(NOTIFY reload) with the connectionWorker.
   , stateListener     :: MVar ()
+  -- | State of the LISTEN channel, used for the admin server checks
+  , stateIsListenerOn :: IORef Bool
   -- | Config that can change at runtime
   , stateConf         :: IORef AppConfig
   -- | Time used for verifying JWT expiration
@@ -60,6 +66,8 @@ data AppState = AppState
   , stateGetZTime     :: IO ZonedTime
   -- | Used for killing the main thread in case a subthread fails
   , stateMainThreadId :: ThreadId
+  -- | Keeps track of when the next retry for connecting to database is scheduled
+  , stateRetryNextIn  :: IORef Int
   }
 
 init :: AppConfig -> IO AppState
@@ -67,28 +75,33 @@ init conf = do
   newPool <- initPool conf
   initWithPool newPool conf
 
-initWithPool :: P.Pool -> AppConfig -> IO AppState
+initWithPool :: SQL.Pool -> AppConfig -> IO AppState
 initWithPool newPool conf =
   AppState newPool
     <$> newIORef minimumPgVersion -- assume we're in a supported version when starting, this will be corrected on a later step
     <*> newIORef Nothing
     <*> newIORef mempty
-    <*> newIORef False
     <*> newEmptyMVar
+    <*> newEmptyMVar
+    <*> newIORef False
     <*> newIORef conf
     <*> mkAutoUpdate defaultUpdateSettings { updateAction = getCurrentTime }
     <*> mkAutoUpdate defaultUpdateSettings { updateAction = getZonedTime }
     <*> myThreadId
+    <*> newIORef 0
 
-initPool :: AppConfig -> IO P.Pool
+destroy :: AppState -> IO ()
+destroy = releasePool
+
+initPool :: AppConfig -> IO SQL.Pool
 initPool AppConfig{..} =
-  P.acquire (configDbPoolSize, configDbPoolTimeout, toS configDbUri)
+  SQL.acquire (configDbPoolSize, configDbPoolTimeout, toUtf8 configDbUri)
 
-getPool :: AppState -> P.Pool
-getPool = statePool
+usePool :: AppState -> SQL.Session a -> IO (Either SQL.UsageError a)
+usePool AppState{..} = SQL.use statePool
 
 releasePool :: AppState -> IO ()
-releasePool AppState{..} = P.release statePool >> throwTo stateMainThreadId UserInterrupt
+releasePool AppState{..} = SQL.release statePool
 
 getPgVersion :: AppState -> IO PgVersion
 getPgVersion = readIORef . statePgVersion
@@ -99,9 +112,8 @@ putPgVersion = atomicWriteIORef . statePgVersion
 getDbStructure :: AppState -> IO (Maybe DbStructure)
 getDbStructure = readIORef . stateDbStructure
 
-putDbStructure :: AppState -> DbStructure -> IO ()
-putDbStructure appState structure =
-  atomicWriteIORef (stateDbStructure appState) $ Just structure
+putDbStructure :: AppState -> Maybe DbStructure -> IO ()
+putDbStructure appState = atomicWriteIORef (stateDbStructure appState)
 
 getJsonDbS :: AppState -> IO ByteString
 getJsonDbS = readIORef . stateJsonDbS
@@ -109,11 +121,14 @@ getJsonDbS = readIORef . stateJsonDbS
 putJsonDbS :: AppState -> ByteString -> IO ()
 putJsonDbS appState = atomicWriteIORef (stateJsonDbS appState)
 
-getIsWorkerOn :: AppState -> IO Bool
-getIsWorkerOn = readIORef . stateIsWorkerOn
+getWorkerSem :: AppState -> MVar ()
+getWorkerSem = stateWorkerSem
 
-putIsWorkerOn :: AppState -> Bool -> IO ()
-putIsWorkerOn = atomicWriteIORef . stateIsWorkerOn
+getRetryNextIn :: AppState -> IO Int
+getRetryNextIn = readIORef . stateRetryNextIn
+
+putRetryNextIn :: AppState -> Int -> IO ()
+putRetryNextIn = atomicWriteIORef . stateRetryNextIn
 
 getConfig :: AppState -> IO AppConfig
 getConfig = readIORef . stateConf
@@ -143,3 +158,9 @@ waitListener = takeMVar . stateListener
 -- the connectionWorker is the only mvar producer.
 signalListener :: AppState -> IO ()
 signalListener appState = void $ tryPutMVar (stateListener appState) ()
+
+getIsListenerOn :: AppState -> IO Bool
+getIsListenerOn = readIORef . stateIsListenerOn
+
+putIsListenerOn :: AppState -> Bool -> IO ()
+putIsListenerOn = atomicWriteIORef . stateIsListenerOn

src/PostgREST/Auth.hs

@@ -12,40 +12,55 @@ very simple authentication system inside the PostgreSQL database.
 -}
 {-# LANGUAGE RecordWildCards #-}
 module PostgREST.Auth
-  ( containsRole
-  , jwtClaims
-  , JWTClaims
+  ( AuthResult (..)
+  , getResult
+  , getRole
+  , middleware
   ) where
 
-import qualified Crypto.JWT          as JWT
-import qualified Data.Aeson          as JSON
-import qualified Data.HashMap.Strict as M
-import qualified Data.Vector         as V
+import qualified Crypto.JWT                      as JWT
+import qualified Data.Aeson                      as JSON
+import qualified Data.Aeson.Key                  as K
+import qualified Data.Aeson.KeyMap               as KM
+import qualified Data.Aeson.Types                as JSON
+import qualified Data.ByteString.Lazy.Char8      as LBS
+import qualified Data.Text.Encoding              as T
+import qualified Data.Vault.Lazy                 as Vault
+import qualified Data.Vector                     as V
+import qualified Network.HTTP.Types.Header       as HTTP
+import qualified Network.Wai                     as Wai
+import qualified Network.Wai.Middleware.HttpAuth as Wai
 
 import Control.Lens            (set)
 import Control.Monad.Except    (liftEither)
 import Data.Either.Combinators (mapLeft)
+import Data.List               (lookup)
 import Data.Time.Clock         (UTCTime)
+import System.IO.Unsafe        (unsafePerformIO)
 
-import PostgREST.Config (AppConfig (..), JSPath, JSPathExp (..))
-import PostgREST.Error  (Error (..))
+import PostgREST.AppState (AppState, getConfig, getTime)
+import PostgREST.Config   (AppConfig (..), JSPath, JSPathExp (..))
+import PostgREST.Error    (Error (..))
 
 import Protolude
 
 
-type JWTClaims = M.HashMap Text JSON.Value
+data AuthResult = AuthResult
+  { authClaims :: KM.KeyMap JSON.Value
+  , authRole   :: Text
+  }
 
 -- | Receives the JWT secret and audience (from config) and a JWT and returns a
--- map of JWT claims.
-jwtClaims :: Monad m =>
-  AppConfig -> LByteString -> UTCTime -> ExceptT Error m JWTClaims
-jwtClaims _ "" _ = return M.empty
-jwtClaims AppConfig{..} payload time = do
+-- JSON object of JWT claims.
+parseToken :: Monad m =>
+  AppConfig -> LByteString -> UTCTime -> ExceptT Error m JSON.Value
+parseToken _ "" _ = return JSON.emptyObject
+parseToken AppConfig{..} token time = do
   secret <- liftEither . maybeToRight JwtTokenMissing $ configJWKS
   eitherClaims <-
     lift . runExceptT $
-      JWT.verifyClaimsAt validation secret time =<< JWT.decodeCompact payload
-  liftEither . mapLeft jwtClaimsError $ claimsMap configJwtRoleClaimKey <$> eitherClaims
+      JWT.verifyClaimsAt validation secret time =<< JWT.decodeCompact token
+  liftEither . mapLeft jwtClaimsError $ JSON.toJSON <$> eitherClaims
   where
     validation =
       JWT.defaultJWTValidationSettings audienceCheck & set JWT.allowedSkew 1
@@ -57,26 +72,50 @@ jwtClaims AppConfig{..} payload time = do
     jwtClaimsError JWT.JWTExpired = JwtTokenInvalid "JWT expired"
     jwtClaimsError e              = JwtTokenInvalid $ show e
 
--- | Turn JWT ClaimSet into something easier to work with.
---
--- Also, here the jspath is applied to put the "role" in the map.
-claimsMap :: JSPath -> JWT.ClaimsSet -> JWTClaims
-claimsMap jspath claims =
-  case JSON.toJSON claims of
-    val@(JSON.Object o) ->
-      M.delete "role" o `M.union` role val
-    _ ->
-      M.empty
+parseClaims :: Monad m =>
+  AppConfig -> JSON.Value -> ExceptT Error m AuthResult
+parseClaims AppConfig{..} jclaims@(JSON.Object mclaims) = do
+  -- role defaults to anon if not specified in jwt
+  role <- liftEither . maybeToRight JwtTokenRequired $
+    unquoted <$> walkJSPath (Just jclaims) configJwtRoleClaimKey <|> configDbAnonRole
+  return AuthResult
+           { authClaims = mclaims & KM.insert "role" (JSON.toJSON role)
+           , authRole = role
+           }
   where
-    role value =
-      maybe M.empty (M.singleton "role") $ walkJSPath (Just value) jspath
-
     walkJSPath :: Maybe JSON.Value -> JSPath -> Maybe JSON.Value
     walkJSPath x                      []                = x
-    walkJSPath (Just (JSON.Object o)) (JSPKey key:rest) = walkJSPath (M.lookup key o) rest
+    walkJSPath (Just (JSON.Object o)) (JSPKey key:rest) = walkJSPath (KM.lookup (K.fromText key) o) rest
     walkJSPath (Just (JSON.Array ar)) (JSPIdx idx:rest) = walkJSPath (ar V.!? idx) rest
     walkJSPath _                      _                 = Nothing
 
--- | Whether a response from jwtClaims contains a role claim
-containsRole :: JWTClaims -> Bool
-containsRole = M.member "role"
+    unquoted :: JSON.Value -> Text
+    unquoted (JSON.String t) = t
+    unquoted v = T.decodeUtf8 . LBS.toStrict $ JSON.encode v
+-- impossible case - just added to please -Wincomplete-patterns
+parseClaims _ _ = return AuthResult { authClaims = KM.empty, authRole = mempty }
+
+-- | Validate authorization header.
+--   Parse and store JWT claims for future use in the request.
+middleware :: AppState -> Wai.Middleware
+middleware appState app req respond = do
+  conf <- getConfig appState
+  time <- getTime appState
+
+  let token = fromMaybe "" $ Wai.extractBearerAuth =<< lookup HTTP.hAuthorization (Wai.requestHeaders req)
+  authResult <- runExceptT $
+    parseToken conf (LBS.fromStrict token) time >>=
+    parseClaims conf
+
+  let req' = req { Wai.vault = Wai.vault req & Vault.insert authResultKey authResult }
+  app req' respond
+
+authResultKey :: Vault.Key (Either Error AuthResult)
+authResultKey = unsafePerformIO Vault.newKey
+{-# NOINLINE authResultKey #-}
+
+getResult :: Wai.Request -> Maybe (Either Error AuthResult)
+getResult = Vault.lookup authResultKey . Wai.vault
+
+getRole :: Wai.Request -> Maybe Text
+getRole req = authRole <$> (rightToMaybe =<< getResult req)

src/PostgREST/CLI.hs

@@ -8,12 +8,11 @@ module PostgREST.CLI
   , readCLIShowHelp
   ) where
 
-import qualified Data.Aeson                 as Aeson
+import qualified Data.Aeson                 as JSON
+import qualified Data.ByteString.Char8      as BS
 import qualified Data.ByteString.Lazy       as LBS
-import qualified Hasql.Pool                 as P
-import qualified Hasql.Transaction.Sessions as HT
+import qualified Hasql.Transaction.Sessions as SQL
 import qualified Options.Applicative        as O
-import qualified Protolude.Conv             as Conv
 
 import Data.Text.IO (hPutStrLn)
 import Text.Heredoc (str)
@@ -35,38 +34,37 @@ main :: App.SignalHandlerInstaller -> Maybe App.SocketRunner -> CLI -> IO ()
 main installSignalHandlers runAppWithSocket CLI{cliCommand, cliPath} = do
   conf@AppConfig{..} <-
     either panic identity <$> Config.readAppConfig mempty cliPath Nothing
-  appState <- AppState.init conf
 
-  -- Override the config with config options from the db
-  -- TODO: the same operation is repeated on connectionWorker, ideally this
-  -- would be done only once, but dump CmdDumpConfig needs it for tests.
-  when configDbConfig $ reReadConfig True appState
-
-  exec cliCommand appState
-  where
-    exec :: Command -> AppState -> IO ()
-    exec CmdDumpConfig appState = putStr . Config.toText =<< AppState.getConfig appState
-    exec CmdDumpSchema appState = putStrLn =<< dumpSchema appState
-    exec CmdRun appState = App.run installSignalHandlers runAppWithSocket appState
+  -- Per https://github.com/PostgREST/postgrest/issues/268, we want to
+  -- explicitly close the connections to PostgreSQL on shutdown.
+  -- 'AppState.destroy' takes care of that.
+  bracket
+    (AppState.init conf)
+    AppState.destroy
+    (\appState -> case cliCommand of
+      CmdDumpConfig -> do
+        when configDbConfig $ reReadConfig True appState
+        putStr . Config.toText =<< AppState.getConfig appState
+      CmdDumpSchema -> putStrLn =<< dumpSchema appState
+      CmdRun -> App.run installSignalHandlers runAppWithSocket appState)
 
 -- | Dump DbStructure schema to JSON
 dumpSchema :: AppState -> IO LBS.ByteString
 dumpSchema appState = do
   AppConfig{..} <- AppState.getConfig appState
   result <-
-    let transaction = if configDbPreparedStatements then HT.transaction else HT.unpreparedTransaction in
-    P.use (AppState.getPool appState) $
-      transaction HT.ReadCommitted HT.Read $
+    let transaction = if configDbPreparedStatements then SQL.transaction else SQL.unpreparedTransaction in
+    AppState.usePool appState $
+      transaction SQL.ReadCommitted SQL.Read $
         queryDbStructure
           (toList configDbSchemas)
           configDbExtraSearchPath
           configDbPreparedStatements
-  P.release $ AppState.getPool appState
   case result of
     Left e -> do
       hPutStrLn stderr $ "An error ocurred when loading the schema cache:\n" <> show e
       exitFailure
-    Right dbStructure -> return $ Aeson.encode dbStructure
+    Right dbStructure -> return $ JSON.encode dbStructure
 
 -- | Command line interface options
 data CLI = CLI
@@ -80,25 +78,20 @@ data Command
   | CmdDumpSchema
 
 -- | Read command line interface options. Also prints help.
-readCLIShowHelp :: Bool -> IO CLI
-readCLIShowHelp hasEnvironment =
+readCLIShowHelp :: IO CLI
+readCLIShowHelp =
   O.customExecParser prefs opts
   where
     prefs = O.prefs $ O.showHelpOnError <> O.showHelpOnEmpty
-    opts = O.info parser $ O.fullDesc <> progDesc <> footer
+    opts = O.info parser $ O.fullDesc <> progDesc
     parser = O.helper <*> exampleParser <*> cliParser
 
     progDesc =
       O.progDesc $
         "PostgREST "
-        <> Conv.toS prettyVersion
+        <> BS.unpack prettyVersion
         <> " / create a REST API to an existing Postgres database"
 
-    footer =
-      O.footer $
-        "To run PostgREST, please pass the FILENAME argument"
-        <> " or set PGRST_ environment variables."
-
     exampleParser =
       O.infoOption exampleConfigFile $
         O.long "example"
@@ -109,12 +102,12 @@ readCLIShowHelp hasEnvironment =
     cliParser =
       CLI
         <$> (dumpConfigFlag <|> dumpSchemaFlag)
-        <*> optionalIf hasEnvironment configFileOption
+        <*> O.optional configFileOption
 
     configFileOption =
       O.strArgument $
         O.metavar "FILENAME"
-        <> O.help "Path to configuration file (optional with PGRST_ environment variables)"
+        <> O.help "Path to configuration file"
 
     dumpConfigFlag =
       O.flag CmdRun CmdDumpConfig $
@@ -126,36 +119,13 @@ readCLIShowHelp hasEnvironment =
         O.long "dump-schema"
         <> O.help "Dump loaded schema as JSON and exit (for debugging, output structure is unstable)"
 
-    optionalIf :: Alternative f => Bool -> f a -> f (Maybe a)
-    optionalIf True  = O.optional
-    optionalIf False = fmap Just
-
 exampleConfigFile :: [Char]
 exampleConfigFile =
-  [str|### REQUIRED:
-      |db-uri = "postgres://user:pass@localhost:5432/dbname"
-      |db-schema = "public"
-      |db-anon-role = "postgres"
+  [str|## Admin server used for checks. It's disabled by default unless a port is specified.
+      |# admin-server-port = 3001
       |
-      |### OPTIONAL:
-      |## number of open connections in the pool
-      |db-pool = 10
-      |
-      |## Time to live, in seconds, for an idle database pool connection.
-      |db-pool-timeout = 10
-      |
-      |## extra schemas to add to the search_path of every request
-      |db-extra-search-path = "public"
-      |
-      |## limit rows in response
-      |# db-max-rows = 1000
-      |
-      |## stored proc to exec immediately after auth
-      |# db-pre-request = "stored_proc_name"
-      |
-      |## stored proc that overrides the root "/" spec
-      |## it must be inside the db-schema
-      |# db-root-spec = "stored_proc_name"
+      |## The database role to use when no client authentication is provided
+      |# db-anon-role = "anon"
       |
       |## Notification channel for reloading the schema cache
       |db-channel = "pgrst"
@@ -166,52 +136,82 @@ exampleConfigFile =
       |## Enable in-database configuration
       |db-config = true
       |
-      |## how to terminate database transactions
-      |## possible values are:
+      |## Extra schemas to add to the search_path of every request
+      |db-extra-search-path = "public"
+      |
+      |## Limit rows in response
+      |# db-max-rows = 1000
+      |
+      |## Allow getting the EXPLAIN plan through the `Accept: application/vnd.pgrst.plan` header
+      |# db-plan-enabled = false
+      |
+      |## Number of open connections in the pool
+      |db-pool = 10
+      |
+      |## Time to live, in seconds, for an idle database pool connection
+      |db-pool-timeout = 3600
+      |
+      |## Stored proc to exec immediately after auth
+      |# db-pre-request = "stored_proc_name"
+      |
+      |## Enable or disable prepared statements. disabling is only necessary when behind a connection pooler.
+      |## When disabled, statements will be parametrized but won't be prepared.
+      |db-prepared-statements = true
+      |
+      |## The name of which database schema to expose to REST clients
+      |db-schemas = "public"
+      |
+      |## How to terminate database transactions
+      |## Possible values are:
       |## commit (default)
-      |##   transaction is always committed, this can not be overriden
+      |##   Transaction is always committed, this can not be overriden
       |## commit-allow-override
-      |##   transaction is committed, but can be overriden with Prefer tx=rollback header
+      |##   Transaction is committed, but can be overriden with Prefer tx=rollback header
       |## rollback
-      |##   transaction is always rolled back, this can not be overriden
+      |##   Transaction is always rolled back, this can not be overriden
       |## rollback-allow-override
-      |##   transaction is rolled back, but can be overriden with Prefer tx=commit header
+      |##   Transaction is rolled back, but can be overriden with Prefer tx=commit header
       |db-tx-end = "commit"
       |
-      |## enable or disable prepared statements. disabling is only necessary when behind a connection pooler.
-      |## when disabled, statements will be parametrized but won't be prepared.
-      |db-prepared-statements = true
+      |## The standard connection URI format, documented at
+      |## https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING
+      |db-uri = "postgresql://"
+      |
+      |## Determine if GUC request settings for headers, cookies and jwt claims use the legacy names (string with dashes, invalid starting from PostgreSQL v14) with text values instead of the new names (string without dashes, valid on all PostgreSQL versions) with json values.
+      |## For PostgreSQL v14 and up, this setting will be ignored.
+      |db-use-legacy-gucs = true
+      |
+      |# jwt-aud = "your_audience_claim"
+      |
+      |## Jspath to the role claim key
+      |jwt-role-claim-key = ".role"
+      |
+      |## Choose a secret, JSON Web Key (or set) to enable JWT auth
+      |## (use "@filename" to load from separate file)
+      |# jwt-secret = "secret_with_at_least_32_characters"
+      |jwt-secret-is-base64 = false
+      |
+      |## Logging level, the admitted values are: crit, error, warn and info.
+      |log-level = "error"
+      |
+      |## Determine if the OpenAPI output should follow or ignore role privileges or be disabled entirely.
+      |## Admitted values: follow-privileges, ignore-privileges, disabled
+      |openapi-mode = "follow-privileges"
+      |
+      |## Base url for the OpenAPI output
+      |openapi-server-proxy-uri = ""
+      |
+      |## Content types to produce raw output
+      |# raw-media-types="image/png, image/jpg"
       |
       |server-host = "!4"
       |server-port = 3000
       |
-      |## unix socket location
+      |## Unix socket location
       |## if specified it takes precedence over server-port
       |# server-unix-socket = "/tmp/pgrst.sock"
       |
-      |## unix socket file mode
-      |## when none is provided, 660 is applied by default
+      |## Unix socket file mode
+      |## When none is provided, 660 is applied by default
       |# server-unix-socket-mode = "660"
-      |
-      |## determine if the OpenAPI output should follow or ignore role privileges or be disabled entirely
-      |## admitted values: follow-privileges, ignore-privileges, disabled
-      |openapi-mode = "follow-privileges"
-      |
-      |## base url for the OpenAPI output
-      |openapi-server-proxy-uri = ""
-      |
-      |## choose a secret, JSON Web Key (or set) to enable JWT auth
-      |## (use "@filename" to load from separate file)
-      |# jwt-secret = "secret_with_at_least_32_characters"
-      |# jwt-aud = "your_audience_claim"
-      |jwt-secret-is-base64 = false
-      |
-      |## jspath to the role claim key
-      |jwt-role-claim-key = ".role"
-      |
-      |## content types to produce raw output
-      |# raw-media-types="image/png, image/jpg"
-      |
-      |## logging level, the admitted values are: crit, error, warn and info.
-      |log-level = "error"
       |]

src/PostgREST/Config.hs

@@ -29,19 +29,18 @@ module PostgREST.Config
 import qualified Crypto.JOSE.Types      as JOSE
 import qualified Crypto.JWT             as JWT
 import qualified Data.Aeson             as JSON
-import qualified Data.ByteString        as B
+import qualified Data.ByteString        as BS
 import qualified Data.ByteString.Base64 as B64
-import qualified Data.ByteString.Char8  as BS
+import qualified Data.ByteString.Lazy   as LBS
 import qualified Data.Configurator      as C
 import qualified Data.Map.Strict        as M
 import qualified Data.Text              as T
-
-import qualified GHC.Show (show)
+import qualified Data.Text.Encoding     as T
 
 import Control.Lens            (preview)
 import Control.Monad           (fail)
 import Crypto.JWT              (JWK, JWKSet, StringOrURI, stringOrUri)
-import Data.Aeson              (encode, toJSON)
+import Data.Aeson              (toJSON)
 import Data.Either.Combinators (mapLeft)
 import Data.List               (lookup)
 import Data.List.NonEmpty      (fromList, toList)
@@ -53,22 +52,24 @@ import System.Environment      (getEnvironment)
 import System.Posix.Types      (FileMode)
 
 import PostgREST.Config.JSPath           (JSPath, JSPathExp (..),
-                                          pRoleClaimKey)
+                                          dumpJSPath, pRoleClaimKey)
 import PostgREST.Config.Proxy            (Proxy (..),
                                           isMalformedProxyUri, toURI)
-import PostgREST.DbStructure.Identifiers (QualifiedIdentifier, toQi)
+import PostgREST.DbStructure.Identifiers (QualifiedIdentifier, dumpQi,
+                                          toQi)
+import PostgREST.MediaType               (MediaType (..), toMime)
 
-import Protolude      hiding (Proxy, toList, toS)
-import Protolude.Conv (toS)
+import Protolude hiding (Proxy, toList)
 
 
 data AppConfig = AppConfig
   { configAppSettings           :: [(Text, Text)]
-  , configDbAnonRole            :: Text
+  , configDbAnonRole            :: Maybe Text
   , configDbChannel             :: Text
   , configDbChannelEnabled      :: Bool
   , configDbExtraSearchPath     :: [Text]
   , configDbMaxRows             :: Maybe Integer
+  , configDbPlanEnabled         :: Bool
   , configDbPoolSize            :: Int
   , configDbPoolTimeout         :: NominalDiffTime
   , configDbPreRequest          :: Maybe QualifiedIdentifier
@@ -79,37 +80,42 @@ data AppConfig = AppConfig
   , configDbTxAllowOverride     :: Bool
   , configDbTxRollbackAll       :: Bool
   , configDbUri                 :: Text
+  , configDbUseLegacyGucs       :: Bool
   , configFilePath              :: Maybe FilePath
   , configJWKS                  :: Maybe JWKSet
   , configJwtAudience           :: Maybe StringOrURI
   , configJwtRoleClaimKey       :: JSPath
-  , configJwtSecret             :: Maybe B.ByteString
+  , configJwtSecret             :: Maybe BS.ByteString
   , configJwtSecretIsBase64     :: Bool
   , configLogLevel              :: LogLevel
   , configOpenApiMode           :: OpenAPIMode
+  , configOpenApiSecurityActive :: Bool
   , configOpenApiServerProxyUri :: Maybe Text
-  , configRawMediaTypes         :: [B.ByteString]
+  , configRawMediaTypes         :: [MediaType]
   , configServerHost            :: Text
   , configServerPort            :: Int
   , configServerUnixSocket      :: Maybe FilePath
   , configServerUnixSocketMode  :: FileMode
+  , configAdminServerPort       :: Maybe Int
   }
 
 data LogLevel = LogCrit | LogError | LogWarn | LogInfo
 
-instance Show LogLevel where
-  show LogCrit  = "crit"
-  show LogError = "error"
-  show LogWarn  = "warn"
-  show LogInfo  = "info"
+dumpLogLevel :: LogLevel -> Text
+dumpLogLevel = \case
+  LogCrit  -> "crit"
+  LogError -> "error"
+  LogWarn  -> "warn"
+  LogInfo  -> "info"
 
 data OpenAPIMode = OAFollowPriv | OAIgnorePriv | OADisabled
   deriving Eq
 
-instance Show OpenAPIMode where
-  show OAFollowPriv = "follow-privileges"
-  show OAIgnorePriv = "ignore-privileges"
-  show OADisabled   = "disabled"
+dumpOpenApiMode :: OpenAPIMode -> Text
+dumpOpenApiMode = \case
+  OAFollowPriv -> "follow-privileges"
+  OAIgnorePriv -> "ignore-privileges"
+  OADisabled   -> "disabled"
 
 -- | Dump the config
 toText :: AppConfig -> Text
@@ -118,32 +124,36 @@ toText conf =
   where
     -- apply conf to all pgrst settings
     pgrstSettings = (\(k, v) -> (k, v conf)) <$>
-      [("db-anon-role",              q . configDbAnonRole)
+      [("db-anon-role",              q . fromMaybe "" . configDbAnonRole)
       ,("db-channel",                q . configDbChannel)
       ,("db-channel-enabled",            T.toLower . show . configDbChannelEnabled)
       ,("db-extra-search-path",      q . T.intercalate "," . configDbExtraSearchPath)
       ,("db-max-rows",                   maybe "\"\"" show . configDbMaxRows)
+      ,("db-plan-enabled",               T.toLower . show . configDbPlanEnabled)
       ,("db-pool",                       show . configDbPoolSize)
       ,("db-pool-timeout",               show . floor . configDbPoolTimeout)
-      ,("db-pre-request",            q . maybe mempty show . configDbPreRequest)
+      ,("db-pre-request",            q . maybe mempty dumpQi . configDbPreRequest)
       ,("db-prepared-statements",        T.toLower . show . configDbPreparedStatements)
-      ,("db-root-spec",              q . maybe mempty show . configDbRootSpec)
+      ,("db-root-spec",              q . maybe mempty dumpQi . configDbRootSpec)
       ,("db-schemas",                q . T.intercalate "," . toList . configDbSchemas)
-      ,("db-config",                 q . T.toLower . show . configDbConfig)
+      ,("db-config",                     T.toLower . show . configDbConfig)
       ,("db-tx-end",                 q . showTxEnd)
       ,("db-uri",                    q . configDbUri)
-      ,("jwt-aud",                       toS . encode . maybe "" toJSON . configJwtAudience)
-      ,("jwt-role-claim-key",        q . T.intercalate mempty . fmap show . configJwtRoleClaimKey)
-      ,("jwt-secret",                q . toS . showJwtSecret)
+      ,("db-use-legacy-gucs",            T.toLower . show . configDbUseLegacyGucs)
+      ,("jwt-aud",                       T.decodeUtf8 . LBS.toStrict . JSON.encode . maybe "" toJSON . configJwtAudience)
+      ,("jwt-role-claim-key",        q . T.intercalate mempty . fmap dumpJSPath . configJwtRoleClaimKey)
+      ,("jwt-secret",                q . T.decodeUtf8 . showJwtSecret)
       ,("jwt-secret-is-base64",          T.toLower . show . configJwtSecretIsBase64)
-      ,("log-level",                 q . show . configLogLevel)
-      ,("openapi-mode",              q . show . configOpenApiMode)
+      ,("log-level",                 q . dumpLogLevel . configLogLevel)
+      ,("openapi-mode",              q . dumpOpenApiMode . configOpenApiMode)
+      ,("openapi-security-active",       T.toLower . show . configOpenApiSecurityActive)
       ,("openapi-server-proxy-uri",  q . fromMaybe mempty . configOpenApiServerProxyUri)
-      ,("raw-media-types",           q . toS . B.intercalate "," . configRawMediaTypes)
+      ,("raw-media-types",           q . T.decodeUtf8 . BS.intercalate "," . fmap toMime . configRawMediaTypes)
       ,("server-host",               q . configServerHost)
       ,("server-port",                   show . configServerPort)
       ,("server-unix-socket",        q . maybe mempty T.pack . configServerUnixSocket)
       ,("server-unix-socket-mode",   q . T.pack . showSocketMode)
+      ,("admin-server-port",             maybe "\"\"" show . configAdminServerPort)
       ]
 
     -- quote all app.settings
@@ -159,7 +169,7 @@ toText conf =
       ( True , True  ) -> "rollback-allow-override"
     showJwtSecret c
       | configJwtSecretIsBase64 c = B64.encode secret
-      | otherwise                 = toS secret
+      | otherwise                 = secret
       where
         secret = fromMaybe mempty $ configJwtSecret c
     showSocketMode c = showOct (configServerUnixSocketMode c) mempty
@@ -170,10 +180,10 @@ class JustIfMaybe a b where
   justIfMaybe :: a -> b
 
 instance JustIfMaybe a a where
-  justIfMaybe a = a
+  justIfMaybe = identity
 
 instance JustIfMaybe a (Maybe a) where
-  justIfMaybe a = Just a
+  justIfMaybe = Just
 
 -- | Reads and parses the config and overrides its parameters from env vars,
 -- files or db settings.
@@ -202,26 +212,27 @@ parser :: Maybe FilePath -> Environment -> [(Text, Text)] -> C.Parser C.Config A
 parser optPath env dbSettings =
   AppConfig
     <$> parseAppSettings "app.settings"
-    <*> reqString "db-anon-role"
+    <*> optString "db-anon-role"
     <*> (fromMaybe "pgrst" <$> optString "db-channel")
     <*> (fromMaybe True <$> optBool "db-channel-enabled")
     <*> (maybe ["public"] splitOnCommas <$> optValue "db-extra-search-path")
     <*> optWithAlias (optInt "db-max-rows")
                      (optInt "max-rows")
+    <*> (fromMaybe False <$> optBool "db-plan-enabled")
     <*> (fromMaybe 10 <$> optInt "db-pool")
-    <*> (fromIntegral . fromMaybe 10 <$> optInt "db-pool-timeout")
+    <*> (fromIntegral . fromMaybe 3600 <$> optInt "db-pool-timeout")
     <*> (fmap toQi <$> optWithAlias (optString "db-pre-request")
                                     (optString "pre-request"))
     <*> (fromMaybe True <$> optBool "db-prepared-statements")
     <*> (fmap toQi <$> optWithAlias (optString "db-root-spec")
                                     (optString "root-spec"))
-    <*> (fromList . splitOnCommas <$> reqWithAlias (optValue "db-schemas")
-                                                   (optValue "db-schema")
-                                                   "missing key: either db-schemas or db-schema must be set")
+    <*> (fromList . maybe ["public"] splitOnCommas <$> optWithAlias (optValue "db-schemas")
+                                                                    (optValue "db-schema"))
     <*> (fromMaybe True <$> optBool "db-config")
     <*> parseTxEnd "db-tx-end" snd
     <*> parseTxEnd "db-tx-end" fst
-    <*> reqString "db-uri"
+    <*> (fromMaybe "postgresql://" <$> optString "db-uri")
+    <*> (fromMaybe True <$> optBool "db-use-legacy-gucs")
     <*> pure optPath
     <*> pure Nothing
     <*> parseJwtAudience "jwt-aud"
@@ -232,12 +243,14 @@ parser optPath env dbSettings =
           (optBool "secret-is-base64"))
     <*> parseLogLevel "log-level"
     <*> parseOpenAPIMode "openapi-mode"
+    <*> (fromMaybe False <$> optBool "openapi-security-active")
     <*> parseOpenAPIServerProxyURI "openapi-server-proxy-uri"
-    <*> (maybe [] (fmap encodeUtf8 . splitOnCommas) <$> optValue "raw-media-types")
+    <*> (maybe [] (fmap (MTOther . encodeUtf8) . splitOnCommas) <$> optValue "raw-media-types")
     <*> (fromMaybe "!4" <$> optString "server-host")
     <*> (fromMaybe 3000 <$> optInt "server-port")
     <*> (fmap T.unpack <$> optString "server-unix-socket")
     <*> parseSocketFileMode "server-unix-socket-mode"
+    <*> optInt "admin-server-port"
   where
     parseAppSettings :: C.Key -> C.Parser C.Config [(Text, Text)]
     parseAppSettings key = addFromEnv . fmap (fmap coerceText) <$> C.subassocs key C.value
@@ -310,24 +323,12 @@ parser optPath env dbSettings =
         Nothing  -> pure [JSPKey "role"]
         Just rck -> either (fail . show) pure $ pRoleClaimKey rck
 
-    reqWithAlias :: C.Parser C.Config (Maybe a) -> C.Parser C.Config (Maybe a) -> [Char] -> C.Parser C.Config a
-    reqWithAlias orig alias err =
-      orig >>= \case
-        Just v  -> pure v
-        Nothing ->
-          alias >>= \case
-            Just v  -> pure v
-            Nothing -> fail err
-
     optWithAlias :: C.Parser C.Config (Maybe a) -> C.Parser C.Config (Maybe a) -> C.Parser C.Config (Maybe a)
     optWithAlias orig alias =
       orig >>= \case
         Just v  -> pure $ Just v
         Nothing -> alias
 
-    reqString :: C.Key -> C.Parser C.Config Text
-    reqString k = overrideFromDbOrEnvironment C.required k coerceText
-
     optString :: C.Key -> C.Parser C.Config (Maybe Text)
     optString k = mfilter (/= "") <$> overrideFromDbOrEnvironment C.optional k coerceText
 
@@ -354,8 +355,8 @@ parser optPath env dbSettings =
         reloadableDbSetting =
           let dbSettingName = T.pack $ dashToUnderscore <$> toS key in
           if dbSettingName `notElem` [
-            "server_host", "server_port", "server_unix_socket", "server_unix_socket_mode", "log_level",
-            "db_anon_role", "db_uri", "db_channel_enabled", "db_channel", "db_pool", "db_pool_timeout", "db_config"]
+            "server_host", "server_port", "server_unix_socket", "server_unix_socket_mode", "admin_server_port", "log_level",
+            "db_uri", "db_channel_enabled", "db_channel", "db_pool", "db_pool_timeout", "db_config"]
           then lookup dbSettingName dbSettings
           else Nothing
 
@@ -365,17 +366,17 @@ parser optPath env dbSettings =
 
     coerceInt :: (Read i, Integral i) => C.Value -> Maybe i
     coerceInt (C.Number x) = rightToMaybe $ floatingOrInteger x
-    coerceInt (C.String x) = readMaybe $ toS x
+    coerceInt (C.String x) = readMaybe x
     coerceInt _            = Nothing
 
     coerceBool :: C.Value -> Maybe Bool
     coerceBool (C.Bool b)   = Just b
     coerceBool (C.String s) =
       -- parse all kinds of text: True, true, TRUE, "true", ...
-      case readMaybe . toS $ T.toTitle $ T.filter isAlpha $ toS s of
+      case readMaybe $ T.toTitle $ T.filter isAlpha $ toS s of
         Just b  -> Just b
         -- numeric instead?
-        Nothing -> (> 0) <$> (readMaybe $ toS s :: Maybe Integer)
+        Nothing -> (> 0) <$> (readMaybe s :: Maybe Integer)
     coerceBool _            = Nothing
 
     splitOnCommas :: C.Value -> [Text]
@@ -420,8 +421,8 @@ parseSecret bytes =
   fromMaybe (maybe secret (\jwk' -> JWT.JWKSet [jwk']) maybeJWK)
     maybeJWKSet
   where
-    maybeJWKSet = JSON.decode (toS bytes) :: Maybe JWKSet
-    maybeJWK = JSON.decode (toS bytes) :: Maybe JWK
+    maybeJWKSet = JSON.decodeStrict bytes :: Maybe JWKSet
+    maybeJWK = JSON.decodeStrict bytes :: Maybe JWK
     secret = JWT.JWKSet [JWT.fromKeyMaterial keyMaterial]
     keyMaterial = JWT.OctKeyMaterial . JWT.OctKeyParameters $ JOSE.Base64Octets bytes
 

src/PostgREST/Config/Database.hs

@@ -1,7 +1,8 @@
 {-# LANGUAGE QuasiQuotes #-}
 
 module PostgREST.Config.Database
-  ( queryDbSettings
+  ( pgVersionStatement
+  , queryDbSettings
   , queryPgVersion
   ) where
 
@@ -9,46 +10,54 @@ import PostgREST.Config.PgVersion (PgVersion (..))
 
 import qualified Hasql.Decoders             as HD
 import qualified Hasql.Encoders             as HE
-import qualified Hasql.Pool                 as P
-import qualified Hasql.Session              as H
-import qualified Hasql.Statement            as H
-import qualified Hasql.Transaction          as HT
-import qualified Hasql.Transaction.Sessions as HT
+import           Hasql.Session              (Session, statement)
+import qualified Hasql.Statement            as SQL
+import qualified Hasql.Transaction          as SQL
+import qualified Hasql.Transaction.Sessions as SQL
 
 import Text.InterpolatedString.Perl6 (q)
 
 import Protolude
 
-queryPgVersion :: H.Session PgVersion
-queryPgVersion = H.statement mempty $ H.Statement sql HE.noParams versionRow False
+queryPgVersion :: Session PgVersion
+queryPgVersion = statement mempty pgVersionStatement
+
+pgVersionStatement :: SQL.Statement () PgVersion
+pgVersionStatement = SQL.Statement sql HE.noParams versionRow False
   where
     sql = "SELECT current_setting('server_version_num')::integer, current_setting('server_version')"
     versionRow = HD.singleRow $ PgVersion <$> column HD.int4 <*> column HD.text
 
-queryDbSettings :: P.Pool -> Bool -> IO (Either P.UsageError [(Text, Text)])
-queryDbSettings pool prepared =
-  let transaction = if prepared then HT.transaction else HT.unpreparedTransaction in
-  P.use pool . transaction HT.ReadCommitted HT.Read $
-    HT.statement mempty dbSettingsStatement
+queryDbSettings :: Bool -> Session [(Text, Text)]
+queryDbSettings prepared =
+  let transaction = if prepared then SQL.transaction else SQL.unpreparedTransaction in
+  transaction SQL.ReadCommitted SQL.Read $ SQL.statement mempty dbSettingsStatement
 
 -- | Get db settings from the connection role. Global settings will be overridden by database specific settings.
-dbSettingsStatement :: H.Statement () [(Text, Text)]
-dbSettingsStatement = H.Statement sql HE.noParams decodeSettings False
+dbSettingsStatement :: SQL.Statement () [(Text, Text)]
+dbSettingsStatement = SQL.Statement sql HE.noParams decodeSettings False
   where
     sql = [q|
-      with
-      role_setting as (
-        select setdatabase, unnest(setconfig) as setting from pg_catalog.pg_db_role_setting
-        where setrole = current_user::regrole::oid
-          and setdatabase in (0, (select oid from pg_catalog.pg_database where datname = current_catalog))
+      WITH
+      role_setting (database, setting) AS (
+        SELECT setdatabase,
+               unnest(setconfig)
+          FROM pg_catalog.pg_db_role_setting
+         WHERE setrole = CURRENT_USER::regrole::oid
+           AND setdatabase IN (0, (SELECT oid FROM pg_catalog.pg_database WHERE datname = CURRENT_CATALOG))
       ),
-      kv_settings as (
-        select setdatabase, split_part(setting, '=', 1) as k, split_part(setting, '=', 2) as value from role_setting
-        where setting like 'pgrst.%'
+      kv_settings (database, k, v) AS (
+        SELECT database,
+               substr(setting, 1, strpos(setting, '=') - 1),
+               substr(setting, strpos(setting, '=') + 1)
+          FROM role_setting
+         WHERE setting LIKE 'pgrst.%'
       )
-      select distinct on (key) replace(k, 'pgrst.', '') as key, value
-      from kv_settings
-      order by key, setdatabase desc;
+      SELECT DISTINCT ON (key)
+             replace(k, 'pgrst.', '') AS key,
+             v AS value
+        FROM kv_settings
+       ORDER BY key, database DESC;
     |]
     decodeSettings = HD.rowList $ (,) <$> column HD.text <*> column HD.text
 

src/PostgREST/Config/JSPath.hs

@@ -1,12 +1,7 @@
-{-|
-Module      : PostgREST.Types
-Description : PostgREST common types and functions used by the rest of the modules
--}
-{-# LANGUAGE DuplicateRecordFields #-}
-
 module PostgREST.Config.JSPath
   ( JSPath
   , JSPathExp(..)
+  , dumpJSPath
   , pRoleClaimKey
   ) where
 
@@ -16,10 +11,7 @@ import Data.Either.Combinators       (mapLeft)
 import Text.ParserCombinators.Parsec ((<?>))
 import Text.Read                     (read)
 
-import qualified GHC.Show (show)
-
-import Protolude      hiding (toS)
-import Protolude.Conv (toS)
+import Protolude
 
 
 -- | full jspath, e.g. .property[0].attr.detail
@@ -30,10 +22,10 @@ data JSPathExp
   = JSPKey Text
   | JSPIdx Int
 
-instance Show JSPathExp where
-  -- TODO: this needs to be quoted properly for special chars
-  show (JSPKey k) = "." <> show k
-  show (JSPIdx i) = "[" <> show i <> "]"
+dumpJSPath :: JSPathExp -> Text
+-- TODO: this needs to be quoted properly for special chars
+dumpJSPath (JSPKey k) = "." <> show k
+dumpJSPath (JSPIdx i) = "[" <> show i <> "]"
 
 -- Used for the config value "role-claim-key"
 pRoleClaimKey :: Text -> Either Text JSPath

src/PostgREST/Config/PgVersion.hs

@@ -3,15 +3,16 @@
 module PostgREST.Config.PgVersion
   ( PgVersion(..)
   , minimumPgVersion
-  , pgVersion95
   , pgVersion96
   , pgVersion100
   , pgVersion109
   , pgVersion110
   , pgVersion112
   , pgVersion114
+  , pgVersion120
   , pgVersion121
   , pgVersion130
+  , pgVersion140
   ) where
 
 import qualified Data.Aeson as JSON
@@ -30,10 +31,7 @@ instance Ord PgVersion where
 
 -- | Tells the minimum PostgreSQL version required by this version of PostgREST
 minimumPgVersion :: PgVersion
-minimumPgVersion = pgVersion95
-
-pgVersion95 :: PgVersion
-pgVersion95 = PgVersion 90500 "9.5"
+minimumPgVersion = pgVersion96
 
 pgVersion96 :: PgVersion
 pgVersion96 = PgVersion 90600 "9.6"
@@ -53,8 +51,14 @@ pgVersion112 = PgVersion 110002 "11.2"
 pgVersion114 :: PgVersion
 pgVersion114 = PgVersion 110004 "11.4"
 
+pgVersion120 :: PgVersion
+pgVersion120 = PgVersion 120000 "12.0"
+
 pgVersion121 :: PgVersion
 pgVersion121 = PgVersion 120001 "12.1"
 
 pgVersion130 :: PgVersion
 pgVersion130 = PgVersion 130000 "13.0"
+
+pgVersion140 :: PgVersion
+pgVersion140 = PgVersion 140000 "14.0"

src/PostgREST/Config/Proxy.hs

@@ -8,13 +8,12 @@ module PostgREST.Config.Proxy
   , toURI
   ) where
 
+import qualified Data.Text as T
+
 import Data.Maybe  (fromJust)
-import Data.Text   (pack, toLower)
 import Network.URI (URI (..), URIAuth (..), isAbsoluteURI, parseURI)
 
-import Protolude      hiding (Proxy, dropWhile, get, intercalate,
-                       toLower, toS, (&))
-import Protolude.Conv (toS)
+import Protolude hiding (Proxy)
 
 data Proxy = Proxy
   { proxyScheme :: Text
@@ -48,8 +47,8 @@ fAnd fs x = all ($ x) fs
 
 isSchemeValid :: URI -> Bool
 isSchemeValid URI {uriScheme = s}
-  | toLower (pack s) == "https:" = True
-  | toLower (pack s) == "http:" = True
+  | T.toLower (T.pack s) == "https:" = True
+  | T.toLower (T.pack s) == "http:" = True
   | otherwise = False
 
 isQueryValid :: URI -> Bool

src/PostgREST/ContentType.hs

@@ -1,64 +0,0 @@
-{-# LANGUAGE DuplicateRecordFields #-}
-
-module PostgREST.ContentType
-  ( ContentType(..)
-  , toHeader
-  , toMime
-  , decodeContentType
-  ) where
-
-import qualified Data.ByteString          as BS
-import qualified Data.ByteString.Internal as BS (c2w)
-
-import Network.HTTP.Types.Header (Header, hContentType)
-
-import Protolude
-
--- | Enumeration of currently supported response content types
-data ContentType
-  = CTApplicationJSON
-  | CTSingularJSON
-  | CTTextCSV
-  | CTTextPlain
-  | CTOpenAPI
-  | CTUrlEncoded
-  | CTOctetStream
-  | CTAny
-  | CTOther ByteString
-  deriving (Eq)
-
--- | Convert from ContentType to a full HTTP Header
-toHeader :: ContentType -> Header
-toHeader ct = (hContentType, toMime ct <> charset)
-  where
-    charset = case ct of
-      CTOctetStream -> mempty
-      CTOther _     -> mempty
-      _             -> "; charset=utf-8"
-
--- | Convert from ContentType to a ByteString representing the mime type
-toMime :: ContentType -> ByteString
-toMime CTApplicationJSON = "application/json"
-toMime CTTextCSV         = "text/csv"
-toMime CTTextPlain       = "text/plain"
-toMime CTOpenAPI         = "application/openapi+json"
-toMime CTSingularJSON    = "application/vnd.pgrst.object+json"
-toMime CTUrlEncoded      = "application/x-www-form-urlencoded"
-toMime CTOctetStream     = "application/octet-stream"
-toMime CTAny             = "*/*"
-toMime (CTOther ct)      = ct
-
--- | Convert from ByteString to ContentType. Warning: discards MIME parameters
-decodeContentType :: BS.ByteString -> ContentType
-decodeContentType ct =
-  case BS.takeWhile (/= BS.c2w ';') ct of
-    "application/json"                  -> CTApplicationJSON
-    "text/csv"                          -> CTTextCSV
-    "text/plain"                        -> CTTextPlain
-    "application/openapi+json"          -> CTOpenAPI
-    "application/vnd.pgrst.object+json" -> CTSingularJSON
-    "application/vnd.pgrst.object"      -> CTSingularJSON
-    "application/x-www-form-urlencoded" -> CTUrlEncoded
-    "application/octet-stream"          -> CTOctetStream
-    "*/*"                               -> CTAny
-    ct'                                 -> CTOther ct'

src/PostgREST/Cors.hs

@@ -0,0 +1,42 @@
+{-|
+Module      : PostgREST.Cors
+Description : Wai Middleware to set cors policy.
+-}
+module PostgREST.Cors (middleware) where
+
+import qualified Data.ByteString.Char8       as BS
+import qualified Data.CaseInsensitive        as CI
+import qualified Network.Wai                 as Wai
+import qualified Network.Wai.Middleware.Cors as Wai
+
+import Data.List (lookup)
+
+import Protolude
+
+middleware :: Wai.Middleware
+middleware = Wai.cors corsPolicy
+
+-- | CORS policy to be used in by Wai Cors middleware
+corsPolicy :: Wai.Request -> Maybe Wai.CorsResourcePolicy
+corsPolicy req = case lookup "origin" headers of
+  Just origin ->
+    Just Wai.CorsResourcePolicy
+    { Wai.corsOrigins = Just ([origin], True)
+    , Wai.corsMethods = ["GET", "POST", "PATCH", "PUT", "DELETE", "OPTIONS"]
+    , Wai.corsRequestHeaders = "Authorization" : accHeaders
+    , Wai.corsExposedHeaders = Just
+      [ "Content-Encoding", "Content-Location", "Content-Range", "Content-Type"
+      , "Date", "Location", "Server", "Transfer-Encoding", "Range-Unit"]
+    , Wai.corsMaxAge = Just $ 60*60*24
+    , Wai.corsVaryOrigin = False
+    , Wai.corsRequireOrigin = False
+    , Wai.corsIgnoreFailures = True
+    }
+  Nothing -> Nothing
+  where
+    headers = Wai.requestHeaders req
+    accHeaders = case lookup "access-control-request-headers" headers of
+      Just hdrs -> map (CI.mk . BS.strip) $ BS.split ',' hdrs
+       -- Impossible case, Middleware.Cors will not evaluate this when
+       -- the Access-Control-Request-Headers header is not set.
+      Nothing   -> []

src/PostgREST/DbStructure/Identifiers.hs

@@ -6,12 +6,12 @@ module PostgREST.DbStructure.Identifiers
   , Schema
   , TableName
   , FieldName
+  , dumpQi
   , toQi
   ) where
 
 import qualified Data.Aeson as JSON
 import qualified Data.Text  as T
-import qualified GHC.Show
 
 import Protolude
 
@@ -26,9 +26,9 @@ data QualifiedIdentifier = QualifiedIdentifier
 
 instance Hashable QualifiedIdentifier
 
-instance Show QualifiedIdentifier where
-  show (QualifiedIdentifier s i) =
-    (if T.null s then mempty else toS s <> ".") <> toS i
+dumpQi :: QualifiedIdentifier -> Text
+dumpQi (QualifiedIdentifier s i) =
+  (if T.null s then mempty else s <> ".") <> i
 
 -- TODO: Handle a case where the QI comes like this: "my.fav.schema"."my.identifier"
 -- Right now it only handles the schema.identifier case

src/PostgREST/DbStructure/Proc.hs

@@ -2,37 +2,26 @@
 {-# LANGUAGE DeriveGeneric  #-}
 
 module PostgREST.DbStructure.Proc
-  ( PgArg(..)
-  , PgType(..)
+  ( PgType(..)
   , ProcDescription(..)
+  , ProcParam(..)
   , ProcVolatility(..)
   , ProcsMap
   , RetType(..)
   , procReturnsScalar
   , procReturnsSingle
+  , procReturnsVoid
   , procTableName
-  , specifiedProcArgs
   ) where
 
 import qualified Data.Aeson          as JSON
-import qualified Data.HashMap.Strict as M
-import qualified Data.Set            as S
+import qualified Data.HashMap.Strict as HM
 
-import PostgREST.DbStructure.Identifiers (FieldName,
-                                          QualifiedIdentifier (..),
+import PostgREST.DbStructure.Identifiers (QualifiedIdentifier (..),
                                           Schema, TableName)
 
 import Protolude
 
-
-data PgArg = PgArg
-  { pgaName :: Text
-  , pgaType :: Text
-  , pgaReq  :: Bool
-  , pgaVar  :: Bool
-  }
-  deriving (Eq, Ord, Generic, JSON.ToJSON)
-
 data PgType
   = Scalar
   | Composite QualifiedIdentifier
@@ -53,45 +42,50 @@ data ProcDescription = ProcDescription
   { pdSchema      :: Schema
   , pdName        :: Text
   , pdDescription :: Maybe Text
-  , pdArgs        :: [PgArg]
-  , pdReturnType  :: RetType
+  , pdParams      :: [ProcParam]
+  , pdReturnType  :: Maybe RetType
   , pdVolatility  :: ProcVolatility
   , pdHasVariadic :: Bool
   }
   deriving (Eq, Generic, JSON.ToJSON)
 
--- Order by least number of args in the case of overloaded functions
+data ProcParam = ProcParam
+  { ppName :: Text
+  , ppType :: Text
+  , ppReq  :: Bool
+  , ppVar  :: Bool
+  }
+  deriving (Eq, Ord, Generic, JSON.ToJSON)
+
+-- Order by least number of params in the case of overloaded functions
 instance Ord ProcDescription where
-  ProcDescription schema1 name1 des1 args1 rt1 vol1 hasVar1 `compare` ProcDescription schema2 name2 des2 args2 rt2 vol2 hasVar2
-    | schema1 == schema2 && name1 == name2 && length args1 < length args2  = LT
-    | schema2 == schema2 && name1 == name2 && length args1 > length args2  = GT
-    | otherwise = (schema1, name1, des1, args1, rt1, vol1, hasVar1) `compare` (schema2, name2, des2, args2, rt2, vol2, hasVar2)
+  ProcDescription schema1 name1 des1 prms1 rt1 vol1 hasVar1 `compare` ProcDescription schema2 name2 des2 prms2 rt2 vol2 hasVar2
+    | schema1 == schema2 && name1 == name2 && length prms1 < length prms2  = LT
+    | schema2 == schema2 && name1 == name2 && length prms1 > length prms2  = GT
+    | otherwise = (schema1, name1, des1, prms1, rt1, vol1, hasVar1) `compare` (schema2, name2, des2, prms2, rt2, vol2, hasVar2)
 
 -- | A map of all procs, all of which can be overloaded(one entry will have more than one ProcDescription).
 -- | It uses a HashMap for a faster lookup.
-type ProcsMap = M.HashMap QualifiedIdentifier [ProcDescription]
-
-{-|
-  Search the procedure parameters by matching them with the specified keys.
-  If the key doesn't match a parameter, a parameter with a default type "text" is assumed.
--}
-specifiedProcArgs :: S.Set FieldName -> ProcDescription -> [PgArg]
-specifiedProcArgs keys proc =
-  (\k -> fromMaybe (PgArg k "text" True False) (find ((==) k . pgaName) (pdArgs proc))) <$> S.toList keys
+type ProcsMap = HM.HashMap QualifiedIdentifier [ProcDescription]
 
 procReturnsScalar :: ProcDescription -> Bool
 procReturnsScalar proc = case proc of
-  ProcDescription{pdReturnType = (Single Scalar)} -> True
-  ProcDescription{pdReturnType = (SetOf Scalar)}  -> True
-  _                                               -> False
+  ProcDescription{pdReturnType = Just (Single Scalar)} -> True
+  ProcDescription{pdReturnType = Just (SetOf Scalar)}  -> True
+  _                                                    -> False
 
 procReturnsSingle :: ProcDescription -> Bool
 procReturnsSingle proc = case proc of
-  ProcDescription{pdReturnType = (Single _)} -> True
-  _                                          -> False
+  ProcDescription{pdReturnType = Just (Single _)} -> True
+  _                                               -> False
+
+procReturnsVoid :: ProcDescription -> Bool
+procReturnsVoid proc = case proc of
+  ProcDescription{pdReturnType = Nothing} -> True
+  _                                       -> False
 
 procTableName :: ProcDescription -> Maybe TableName
 procTableName proc = case pdReturnType proc of
-  SetOf  (Composite qi) -> Just $ qiName qi
-  Single (Composite qi) -> Just $ qiName qi
-  _                     -> Nothing
+  Just (SetOf  (Composite qi)) -> Just $ qiName qi
+  Just (Single (Composite qi)) -> Just $ qiName qi
+  _                            -> Nothing

src/PostgREST/DbStructure/Relationship.hs

@@ -3,60 +3,62 @@
 
 module PostgREST.DbStructure.Relationship
   ( Cardinality(..)
-  , PrimaryKey(..)
   , Relationship(..)
   , Junction(..)
-  , isSelfReference
+  , RelationshipsMap
   ) where
 
-import qualified Data.Aeson as JSON
+import qualified Data.Aeson          as JSON
+import qualified Data.HashMap.Strict as HM
 
-import PostgREST.DbStructure.Table (Column (..), Table (..))
+import PostgREST.DbStructure.Identifiers (FieldName,
+                                          QualifiedIdentifier, Schema)
 
 import Protolude
 
 
 -- | Relationship between two tables.
---
--- The order of the relColumns and relForeignColumns should be maintained to get the
--- join conditions right.
---
--- TODO merge relColumns and relForeignColumns to a tuple or Data.Bimap
 data Relationship = Relationship
-  { relTable          :: Table
-  , relColumns        :: [Column]
-  , relForeignTable   :: Table
-  , relForeignColumns :: [Column]
-  , relCardinality    :: Cardinality
+  { relTable        :: QualifiedIdentifier
+  , relForeignTable :: QualifiedIdentifier
+  , relIsSelf       :: Bool -- ^ Whether is a self relationship
+  , relCardinality  :: Cardinality
+  , relTableIsView  :: Bool
+  , relFTableIsView :: Bool
   }
-  deriving (Eq, Generic, JSON.ToJSON)
+  | ComputedRelationship
+  { relFunction     :: QualifiedIdentifier
+  , relTable        :: QualifiedIdentifier
+  , relForeignTable :: QualifiedIdentifier
+  , relToOne        :: Bool
+  , relIsSelf       :: Bool
+  }
+  deriving (Eq, Ord, Generic, JSON.ToJSON)
 
 -- | The relationship cardinality
 -- | https://en.wikipedia.org/wiki/Cardinality_(data_modeling)
--- TODO: missing one-to-one
 data Cardinality
-  = O2M FKConstraint -- ^ one-to-many cardinality
-  | M2O FKConstraint -- ^ many-to-one cardinality
-  | M2M Junction     -- ^ many-to-many cardinality
-  deriving (Eq, Generic, JSON.ToJSON)
+  = O2M {relCons :: FKConstraint, relColumns :: [(FieldName, FieldName)]}
+  -- ^ one-to-many
+  | M2O {relCons :: FKConstraint, relColumns :: [(FieldName, FieldName)]}
+  -- ^ many-to-one
+  | O2O {relCons :: FKConstraint, relColumns :: [(FieldName, FieldName)]}
+  -- ^ one-to-one, this is a refinement over M2O so operating on it is pretty much the same as M2O
+  | M2M Junction
+  -- ^ many-to-many
+  deriving (Eq, Ord, Generic, JSON.ToJSON)
 
 type FKConstraint = Text
 
 -- | Junction table on an M2M relationship
 data Junction = Junction
-  { junTable       :: Table
+  { junTable       :: QualifiedIdentifier
   , junConstraint1 :: FKConstraint
-  , junColumns1    :: [Column]
   , junConstraint2 :: FKConstraint
-  , junColumns2    :: [Column]
+  , junColumns1    :: [(FieldName, FieldName)]
+  , junColumns2    :: [(FieldName, FieldName)]
   }
-  deriving (Eq, Generic, JSON.ToJSON)
+  deriving (Eq, Ord, Generic, JSON.ToJSON)
 
-isSelfReference :: Relationship -> Bool
-isSelfReference r = relTable r == relForeignTable r
-
-data PrimaryKey = PrimaryKey
-  { pkTable :: Table
-  , pkName  :: Text
-  }
-  deriving (Generic, JSON.ToJSON)
+-- | Key based on the source table and the foreign table schema
+type RelationshipsMap = HM.HashMap (QualifiedIdentifier, Schema)  [Relationship]

src/PostgREST/DbStructure/Table.hs

@@ -4,10 +4,11 @@
 module PostgREST.DbStructure.Table
   ( Column(..)
   , Table(..)
-  , tableQi
+  , TablesMap
   ) where
 
-import qualified Data.Aeson as JSON
+import qualified Data.Aeson          as JSON
+import qualified Data.HashMap.Strict as HM
 
 import PostgREST.DbStructure.Identifiers (FieldName,
                                           QualifiedIdentifier (..),
@@ -20,22 +21,22 @@ data Table = Table
   { tableSchema      :: Schema
   , tableName        :: TableName
   , tableDescription :: Maybe Text
+     -- TODO Find a better way to separate tables and views
+   , tableIsView     :: Bool
     -- The following fields identify what can be done on the table/view, they're not related to the privileges granted to it
   , tableInsertable  :: Bool
   , tableUpdatable   :: Bool
   , tableDeletable   :: Bool
+  , tablePKCols      :: [FieldName]
+  , tableColumns     :: [Column]
   }
   deriving (Show, Ord, Generic, JSON.ToJSON)
 
 instance Eq Table where
   Table{tableSchema=s1,tableName=n1} == Table{tableSchema=s2,tableName=n2} = s1 == s2 && n1 == n2
 
-tableQi :: Table -> QualifiedIdentifier
-tableQi Table{tableSchema=s, tableName=n} = QualifiedIdentifier s n
-
 data Column = Column
-  { colTable       :: Table
-  , colName        :: FieldName
+  { colName        :: FieldName
   , colDescription :: Maybe Text
   , colNullable    :: Bool
   , colType        :: Text
@@ -43,13 +44,6 @@ data Column = Column
   , colDefault     :: Maybe Text
   , colEnum        :: [Text]
   }
-  deriving (Ord, Generic, JSON.ToJSON)
+  deriving (Eq, Show, Ord, Generic, JSON.ToJSON)
 
-instance Eq Column where
-  Column{colTable=t1,colName=n1} == Column{colTable=t2,colName=n2} = t1 == t2 && n1 == n2
-
-data PrimaryKey = PrimaryKey
-  { pkTable :: Table
-  , pkName  :: Text
-  }
-  deriving (Generic, JSON.ToJSON)
+type TablesMap = HM.HashMap QualifiedIdentifier Table

src/PostgREST/Error.hs

@@ -16,32 +16,35 @@ module PostgREST.Error
   ) where
 
 import qualified Data.Aeson                as JSON
+import qualified Data.ByteString.Char8     as BS
 import qualified Data.Text                 as T
-import qualified Hasql.Pool                as P
-import qualified Hasql.Session             as H
-import qualified Network.HTTP.Types.Status as HT
+import qualified Data.Text.Encoding        as T
+import qualified Data.Text.Encoding.Error  as T
+import qualified Hasql.Pool                as SQL
+import qualified Hasql.Session             as SQL
+import qualified Network.HTTP.Types.Status as HTTP
 
 import Data.Aeson  ((.=))
 import Network.Wai (Response, responseLBS)
 
 import Network.HTTP.Types.Header (Header)
 
-import           PostgREST.ContentType (ContentType (..))
-import qualified PostgREST.ContentType as ContentType
+import           PostgREST.MediaType     (MediaType (..))
+import qualified PostgREST.MediaType     as MediaType
+import           PostgREST.Request.Types (ApiRequestError (..),
+                                          QPError (..))
 
-import PostgREST.DbStructure.Proc         (PgArg (..),
-                                           ProcDescription (..))
+import PostgREST.DbStructure.Identifiers  (QualifiedIdentifier (..))
+import PostgREST.DbStructure.Proc         (ProcDescription (..),
+                                           ProcParam (..))
 import PostgREST.DbStructure.Relationship (Cardinality (..),
                                            Junction (..),
                                            Relationship (..))
-import PostgREST.DbStructure.Table        (Column (..), Table (..))
-
-import Protolude      hiding (toS)
-import Protolude.Conv (toS, toSL)
+import Protolude
 
 
 class (JSON.ToJSON a) => PgrstError a where
-  status   :: a -> HT.Status
+  status   :: a -> HTTP.Status
   headers  :: a -> [Header]
 
   errorPayload :: a -> LByteString
@@ -50,272 +53,365 @@ class (JSON.ToJSON a) => PgrstError a where
   errorResponseFor :: a -> Response
   errorResponseFor err = responseLBS (status err) (headers err) $ errorPayload err
 
-
-
-data ApiRequestError
-  = ActionInappropriate
-  | InvalidRange
-  | InvalidBody ByteString
-  | ParseRequestError Text Text
-  | NoRelBetween Text Text
-  | AmbiguousRelBetween Text Text [Relationship]
-  | AmbiguousRpc [ProcDescription]
-  | NoRpc Text Text [Text] Bool
-  | InvalidFilters
-  | UnacceptableSchema [Text]
-  | ContentTypeError [ByteString]
-  | UnsupportedVerb                -- Unreachable?
-
 instance PgrstError ApiRequestError where
-  status InvalidRange            = HT.status416
-  status InvalidFilters          = HT.status405
-  status (InvalidBody _)         = HT.status400
-  status UnsupportedVerb         = HT.status405
-  status ActionInappropriate     = HT.status405
-  status (ParseRequestError _ _) = HT.status400
-  status (NoRelBetween _ _)      = HT.status400
-  status AmbiguousRelBetween{}   = HT.status300
-  status (AmbiguousRpc _)        = HT.status300
-  status NoRpc{}                 = HT.status404
-  status (UnacceptableSchema _)  = HT.status406
-  status (ContentTypeError _)    = HT.status415
+  status AmbiguousRelBetween{}   = HTTP.status300
+  status AmbiguousRpc{}          = HTTP.status300
+  status MediaTypeError{}        = HTTP.status415
+  status InvalidBody{}           = HTTP.status400
+  status InvalidFilters          = HTTP.status405
+  status InvalidRpcMethod{}      = HTTP.status405
+  status InvalidRange            = HTTP.status416
+  status NotFound                = HTTP.status404
+  status NoRelBetween{}          = HTTP.status400
+  status NoRpc{}                 = HTTP.status404
+  status NotEmbedded{}           = HTTP.status400
+  status ParseRequestError{}     = HTTP.status400
+  status PutRangeNotAllowedError = HTTP.status400
+  status QueryParamError{}       = HTTP.status400
+  status UnacceptableSchema{}    = HTTP.status406
+  status UnsupportedMethod{}     = HTTP.status405
+  status LimitNoOrderError       = HTTP.status400
 
-  headers _ = [ContentType.toHeader CTApplicationJSON]
+  headers _ = [MediaType.toContentType MTApplicationJSON]
 
 instance JSON.ToJSON ApiRequestError where
-  toJSON (ParseRequestError message details) = JSON.object [
-    "message" .= message, "details" .= details]
-  toJSON ActionInappropriate = JSON.object [
-    "message" .= ("Bad Request" :: Text)]
+  toJSON (QueryParamError (QPError message details)) = JSON.object [
+    "code"    .= ApiRequestErrorCode00,
+    "message" .= message,
+    "details" .= details,
+    "hint"    .= JSON.Null]
+  toJSON (InvalidRpcMethod method) = JSON.object [
+    "code"    .= ApiRequestErrorCode01,
+    "message" .= ("Cannot use the " <> T.decodeUtf8 method <> " method on RPC"),
+    "details" .= JSON.Null,
+    "hint"    .= JSON.Null]
   toJSON (InvalidBody errorMessage) = JSON.object [
-    "message" .= (toS errorMessage :: Text)]
+    "code"    .= ApiRequestErrorCode02,
+    "message" .= T.decodeUtf8 errorMessage,
+    "details" .= JSON.Null,
+    "hint"    .= JSON.Null]
   toJSON InvalidRange = JSON.object [
-    "message" .= ("HTTP Range error" :: Text)]
-  toJSON (NoRelBetween parent child) = JSON.object [
-    "hint"    .= ("If a new foreign key between these entities was created in the database, try reloading the schema cache." :: Text),
-    "message" .= ("Could not find a relationship between " <> parent <> " and " <> child <> " in the schema cache" :: Text)]
-  toJSON (AmbiguousRelBetween parent child rels) = JSON.object [
-    "hint"    .= ("By following the 'details' key, disambiguate the request by changing the url to /origin?select=relationship(*) or /origin?select=target!relationship(*)" :: Text),
-    "message" .= ("More than one relationship was found for " <> parent <> " and " <> child :: Text),
-    "details" .= (compressedRel <$> rels) ]
-  toJSON (AmbiguousRpc procs)  = JSON.object [
-    "hint"    .= ("Overloaded functions with the same argument name but different types are not supported" :: Text),
-    "message" .= ("Could not choose the best candidate function between: " <> T.intercalate ", " [pdSchema p <> "." <> pdName p <> "(" <> T.intercalate ", " [pgaName a <> " => " <> pgaType a | a <- pdArgs p] <> ")" | p <- procs])]
-  toJSON (NoRpc schema procName payloadKeys hasPreferSingleObject)  = JSON.object [
-    "hint"    .= ("If a new function was created in the database with this name and arguments, try reloading the schema cache." :: Text),
-    "message" .= ("Could not find the " <> schema <> "." <> procName <> (if hasPreferSingleObject then " function with a single json or jsonb argument" else "(" <> T.intercalate ", " payloadKeys <> ")" <> " function") <> " in the schema cache")]
-  toJSON UnsupportedVerb = JSON.object [
-    "message" .= ("Unsupported HTTP verb" :: Text)]
+    "code"    .= ApiRequestErrorCode03,
+    "message" .= ("HTTP Range error" :: Text),
+    "details" .= JSON.Null,
+    "hint"    .= JSON.Null]
+  toJSON (ParseRequestError message details) = JSON.object [
+    "code"    .= ApiRequestErrorCode04,
+    "message" .= message,
+    "details" .= details,
+    "hint"    .= JSON.Null]
   toJSON InvalidFilters = JSON.object [
-    "message" .= ("Filters must include all and only primary key columns with 'eq' operators" :: Text)]
+    "code"    .= ApiRequestErrorCode05,
+    "message" .= ("Filters must include all and only primary key columns with 'eq' operators" :: Text),
+    "details" .= JSON.Null,
+    "hint"    .= JSON.Null]
   toJSON (UnacceptableSchema schemas) = JSON.object [
-    "message" .= ("The schema must be one of the following: " <> T.intercalate ", " schemas)]
-  toJSON (ContentTypeError cts)    = JSON.object [
-    "message" .= ("None of these Content-Types are available: " <> (toS . intercalate ", " . map toS) cts :: Text)]
+    "code"    .= ApiRequestErrorCode06,
+    "message" .= ("The schema must be one of the following: " <> T.intercalate ", " schemas),
+    "details" .= JSON.Null,
+    "hint"    .= JSON.Null]
+  toJSON (MediaTypeError cts)    = JSON.object [
+    "code"    .= ApiRequestErrorCode07,
+    "message" .= ("None of these media types are available: " <> T.intercalate ", " (map T.decodeUtf8 cts)),
+    "details" .= JSON.Null,
+    "hint"    .= JSON.Null]
+  toJSON NotFound = JSON.object []
+  toJSON (NotEmbedded resource) = JSON.object [
+    "code"    .= ApiRequestErrorCode08,
+    "message" .= ("Cannot apply filter because '" <> resource <> "' is not an embedded resource in this request" :: Text),
+    "details" .= JSON.Null,
+    "hint"    .= ("Verify that '" <> resource <> "' is included in the 'select' query parameter." :: Text)]
+
+  toJSON LimitNoOrderError = JSON.object [
+    "code"    .= ApiRequestErrorCode09,
+    "message" .= ("A 'limit' was applied without an explicit 'order'":: Text),
+    "details" .= JSON.Null,
+    "hint"    .= ("Apply an 'order' using unique column(s)" :: Text)]
+
+  toJSON PutRangeNotAllowedError = JSON.object [
+    "code"    .= ApiRequestErrorCode14,
+    "message" .= ("Range header and limit/offset querystring parameters are not allowed for PUT" :: Text),
+    "details" .= JSON.Null,
+    "hint"    .= JSON.Null]
+
+  toJSON (UnsupportedMethod method) = JSON.object [
+    "code"    .= ApiRequestErrorCode17,
+    "message" .= ("Unsupported HTTP method: " <> T.decodeUtf8 method),
+    "details" .= JSON.Null,
+    "hint"    .= JSON.Null]
+
+  toJSON (NoRelBetween parent child schema) = JSON.object [
+    "code"    .= SchemaCacheErrorCode00,
+    "message" .= ("Could not find a relationship between '" <> parent <> "' and '" <> child <> "' in the schema cache" :: Text),
+    "details" .= JSON.Null,
+    "hint"    .= ("Verify that '" <> parent <> "' and '" <> child <> "' exist in the schema '" <> schema <> "' and that there is a foreign key relationship between them. If a new relationship was created, try reloading the schema cache." :: Text)]
+  toJSON (AmbiguousRelBetween parent child rels) = JSON.object [
+    "code"    .= SchemaCacheErrorCode01,
+    "message" .= ("Could not embed because more than one relationship was found for '" <> parent <> "' and '" <> child <> "'" :: Text),
+    "details" .= (compressedRel <$> rels),
+    "hint"    .= ("Try changing '" <> child <> "' to one of the following: " <> relHint rels <> ". Find the desired relationship in the 'details' key." :: Text)]
+  toJSON (NoRpc schema procName argumentKeys hasPreferSingleObject contentType isInvPost)  =
+    let prms = "(" <> T.intercalate ", " argumentKeys <> ")" in JSON.object [
+    "code"    .= SchemaCacheErrorCode02,
+    "message" .= ("Could not find the " <> schema <> "." <> procName <>
+      (case (hasPreferSingleObject, isInvPost, contentType) of
+        (True, _, _)                 -> " function with a single json or jsonb parameter"
+        (_, True, MTTextPlain)       -> " function with a single unnamed text parameter"
+        (_, True, MTTextXML)         -> " function with a single unnamed xml parameter"
+        (_, True, MTOctetStream)     -> " function with a single unnamed bytea parameter"
+        (_, True, MTApplicationJSON) -> prms <> " function or the " <> schema <> "." <> procName <>" function with a single unnamed json or jsonb parameter"
+        _                            -> prms <> " function") <>
+      " in the schema cache"),
+    "details" .= JSON.Null,
+    "hint"    .= ("If a new function was created in the database with this name and parameters, try reloading the schema cache." :: Text)]
+  toJSON (AmbiguousRpc procs)  = JSON.object [
+    "code"    .= SchemaCacheErrorCode03,
+    "message" .= ("Could not choose the best candidate function between: " <> T.intercalate ", " [pdSchema p <> "." <> pdName p <> "(" <> T.intercalate ", " [ppName a <> " => " <> ppType a | a <- pdParams p] <> ")" | p <- procs]),
+    "details" .= JSON.Null,
+    "hint"    .= ("Try renaming the parameters or the function itself in the database so function overloading can be resolved" :: Text)]
 
 compressedRel :: Relationship -> JSON.Value
+-- An ambiguousness error cannot happen for computed relationships TODO refactor so this mempty is not needed
+compressedRel ComputedRelationship{} = JSON.object mempty
 compressedRel Relationship{..} =
   let
-    fmtTbl Table{..} = tableSchema <> "." <> tableName
-    fmtEls els = "[" <> T.intercalate ", " els <> "]"
+    fmtEls els = "(" <> T.intercalate ", " els <> ")"
   in
-  JSON.object $ [
-    "origin"      .= fmtTbl relTable
-  , "target"      .= fmtTbl relForeignTable
-  ] ++
-  case relCardinality of
-    M2M Junction{..} -> [
-        "cardinality" .= ("m2m" :: Text)
-      , "relationship" .= (fmtTbl junTable <> fmtEls [junConstraint1] <> fmtEls [junConstraint2])
-      ]
-    M2O cons -> [
-        "cardinality" .= ("m2o" :: Text)
-      , "relationship" .= (cons <> fmtEls (colName <$> relColumns) <> fmtEls (colName <$> relForeignColumns))
-      ]
-    O2M cons -> [
-        "cardinality" .= ("o2m" :: Text)
-      , "relationship" .= (cons <> fmtEls (colName <$> relColumns) <> fmtEls (colName <$> relForeignColumns))
-      ]
+  JSON.object $
+    ("embedding" .= (qiName relTable <> " with " <> qiName relForeignTable :: Text))
+    : case relCardinality of
+        M2M Junction{..} -> [
+            "cardinality" .= ("many-to-many" :: Text)
+          , "relationship" .= (qiName junTable <> " using " <> junConstraint1 <> fmtEls (snd <$> junColumns1) <> " and " <> junConstraint2 <> fmtEls (snd <$> junColumns2))
+          ]
+        M2O cons relColumns -> [
+            "cardinality" .= ("many-to-one" :: Text)
+          , "relationship" .= (cons <> " using " <> qiName relTable <> fmtEls (fst <$> relColumns) <> " and " <> qiName relForeignTable <> fmtEls (snd <$> relColumns))
+          ]
+        O2O cons relColumns -> [
+            "cardinality" .= ("one-to-one" :: Text)
+          , "relationship" .= (cons <> " using " <> qiName relTable <> fmtEls (fst <$> relColumns) <> " and " <> qiName relForeignTable <> fmtEls (snd <$> relColumns))
+          ]
+        O2M cons relColumns -> [
+            "cardinality" .= ("one-to-many" :: Text)
+          , "relationship" .= (cons <> " using " <> qiName relTable <> fmtEls (fst <$> relColumns) <> " and " <> qiName relForeignTable <> fmtEls (snd <$> relColumns))
+          ]
 
-data PgError = PgError Authenticated P.UsageError
+relHint :: [Relationship] -> Text
+relHint rels = T.intercalate ", " (hintList <$> rels)
+  where
+    hintList Relationship{..} =
+      let buildHint rel = "'" <> qiName relForeignTable <> "!" <> rel <> "'" in
+      case relCardinality of
+        M2M Junction{..} -> buildHint (qiName junTable)
+        M2O cons _       -> buildHint cons
+        O2O cons _       -> buildHint cons
+        O2M cons _       -> buildHint cons
+    -- An ambiguousness error cannot happen for computed relationships TODO refactor so this mempty is not needed
+    hintList ComputedRelationship{} = mempty
+
+data PgError = PgError Authenticated SQL.UsageError
 type Authenticated = Bool
 
 instance PgrstError PgError where
   status (PgError authed usageError) = pgErrorStatus authed usageError
 
   headers err =
-    if status err == HT.status401
-       then [ContentType.toHeader CTApplicationJSON, ("WWW-Authenticate", "Bearer") :: Header]
-       else [ContentType.toHeader CTApplicationJSON]
+    if status err == HTTP.status401
+       then [MediaType.toContentType MTApplicationJSON, ("WWW-Authenticate", "Bearer") :: Header]
+       else [MediaType.toContentType MTApplicationJSON]
 
 instance JSON.ToJSON PgError where
   toJSON (PgError _ usageError) = JSON.toJSON usageError
 
-instance JSON.ToJSON P.UsageError where
-  toJSON (P.ConnectionError e) = JSON.object [
-    "code"    .= ("" :: Text),
+instance JSON.ToJSON SQL.UsageError where
+  toJSON (SQL.ConnectionError e) = JSON.object [
+    "code"    .= ConnectionErrorCode00,
     "message" .= ("Database connection error. Retrying the connection." :: Text),
-    "details" .= (toSL $ fromMaybe "" e :: Text)]
-  toJSON (P.SessionError e) = JSON.toJSON e -- H.Error
+    "details" .= (T.decodeUtf8With T.lenientDecode $ fromMaybe "" e :: Text),
+    "hint"    .= JSON.Null]
+  toJSON (SQL.SessionError e) = JSON.toJSON e -- SQL.Error
 
-instance JSON.ToJSON H.QueryError where
-  toJSON (H.QueryError _ _ e) = JSON.toJSON e
+instance JSON.ToJSON SQL.QueryError where
+  toJSON (SQL.QueryError _ _ e) = JSON.toJSON e
 
-instance JSON.ToJSON H.CommandError where
-  toJSON (H.ResultError (H.ServerError c m d h)) = case toS c of
-    'P':'T':_ -> JSON.object [
-        "details" .= (fmap toS d :: Maybe Text),
-        "hint"    .= (fmap toS h :: Maybe Text)]
+instance JSON.ToJSON SQL.CommandError where
+  toJSON (SQL.ResultError (SQL.ServerError c m d h)) = JSON.object [
+    "code"    .= (T.decodeUtf8 c      :: Text),
+    "message" .= (T.decodeUtf8 m      :: Text),
+    "details" .= (fmap T.decodeUtf8 d :: Maybe Text),
+    "hint"    .= (fmap T.decodeUtf8 h :: Maybe Text)]
 
-    _         -> JSON.object [
-        "code"    .= (toS c      :: Text),
-        "message" .= (toS m      :: Text),
-        "details" .= (fmap toS d :: Maybe Text),
-        "hint"    .= (fmap toS h :: Maybe Text)]
+  toJSON (SQL.ResultError resultError) = JSON.object [
+    "code"    .= InternalErrorCode00,
+    "message" .= (show resultError :: Text),
+    "details" .= JSON.Null,
+    "hint"    .= JSON.Null]
 
-  toJSON (H.ResultError (H.UnexpectedResult m)) = JSON.object [
-    "message" .= (m :: Text)]
-  toJSON (H.ResultError (H.RowError i H.EndOfInput)) = JSON.object [
-    "message" .= ("Row error: end of input" :: Text),
-    "details" .= ("Attempt to parse more columns than there are in the result" :: Text),
-    "hint"    .= (("Row number " <> show i) :: Text)]
-  toJSON (H.ResultError (H.RowError i H.UnexpectedNull)) = JSON.object [
-    "message" .= ("Row error: unexpected null" :: Text),
-    "details" .= ("Attempt to parse a NULL as some value." :: Text),
-    "hint"    .= (("Row number " <> show i) :: Text)]
-  toJSON (H.ResultError (H.RowError i (H.ValueError d))) = JSON.object [
-    "message" .= ("Row error: Wrong value parser used" :: Text),
-    "details" .= d,
-    "hint"    .= (("Row number " <> show i) :: Text)]
-  toJSON (H.ResultError (H.UnexpectedAmountOfRows i)) = JSON.object [
-    "message" .= ("Unexpected amount of rows" :: Text),
-    "details" .= i]
-  toJSON (H.ClientError d) = JSON.object [
+  toJSON (SQL.ClientError d) = JSON.object [
+    "code"    .= ConnectionErrorCode01,
     "message" .= ("Database client error. Retrying the connection." :: Text),
-    "details" .= (fmap toS d :: Maybe Text)]
+    "details" .= (fmap T.decodeUtf8 d :: Maybe Text),
+    "hint"    .= JSON.Null]
 
-pgErrorStatus :: Bool -> P.UsageError -> HT.Status
-pgErrorStatus _      (P.ConnectionError _)                                      = HT.status503
-pgErrorStatus _      (P.SessionError (H.QueryError _ _ (H.ClientError _)))      = HT.status503
-pgErrorStatus authed (P.SessionError (H.QueryError _ _ (H.ResultError rError))) =
+pgErrorStatus :: Bool -> SQL.UsageError -> HTTP.Status
+pgErrorStatus _      (SQL.ConnectionError _)                                      = HTTP.status503
+pgErrorStatus _      (SQL.SessionError (SQL.QueryError _ _ (SQL.ClientError _)))      = HTTP.status503
+pgErrorStatus authed (SQL.SessionError (SQL.QueryError _ _ (SQL.ResultError rError))) =
   case rError of
-    (H.ServerError c m _ _) ->
-      case toS c of
-        '0':'8':_ -> HT.status503 -- pg connection err
-        '0':'9':_ -> HT.status500 -- triggered action exception
-        '0':'L':_ -> HT.status403 -- invalid grantor
-        '0':'P':_ -> HT.status403 -- invalid role specification
-        "23503"   -> HT.status409 -- foreign_key_violation
-        "23505"   -> HT.status409 -- unique_violation
-        "25006"   -> HT.status405 -- read_only_sql_transaction
-        '2':'5':_ -> HT.status500 -- invalid tx state
-        '2':'8':_ -> HT.status403 -- invalid auth specification
-        '2':'D':_ -> HT.status500 -- invalid tx termination
-        '3':'8':_ -> HT.status500 -- external routine exception
-        '3':'9':_ -> HT.status500 -- external routine invocation
-        '3':'B':_ -> HT.status500 -- savepoint exception
-        '4':'0':_ -> HT.status500 -- tx rollback
-        '5':'3':_ -> HT.status503 -- insufficient resources
-        '5':'4':_ -> HT.status413 -- too complex
-        '5':'5':_ -> HT.status500 -- obj not on prereq state
-        '5':'7':_ -> HT.status500 -- operator intervention
-        '5':'8':_ -> HT.status500 -- system error
-        'F':'0':_ -> HT.status500 -- conf file error
-        'H':'V':_ -> HT.status500 -- foreign data wrapper error
-        "P0001"   -> HT.status400 -- default code for "raise"
-        'P':'0':_ -> HT.status500 -- PL/pgSQL Error
-        'X':'X':_ -> HT.status500 -- internal Error
-        "42883"   -> HT.status404 -- undefined function
-        "42P01"   -> HT.status404 -- undefined table
-        "42501"   -> if authed then HT.status403 else HT.status401 -- insufficient privilege
-        'P':'T':n -> fromMaybe HT.status500 (HT.mkStatus <$> readMaybe n <*> pure m)
-        _         -> HT.status400
+    (SQL.ServerError c m _ _) ->
+      case BS.unpack c of
+        '0':'8':_ -> HTTP.status503 -- pg connection err
+        '0':'9':_ -> HTTP.status500 -- triggered action exception
+        '0':'L':_ -> HTTP.status403 -- invalid grantor
+        '0':'P':_ -> HTTP.status403 -- invalid role specification
+        "23503"   -> HTTP.status409 -- foreign_key_violation
+        "23505"   -> HTTP.status409 -- unique_violation
+        "25006"   -> HTTP.status405 -- read_only_sql_transaction
+        '2':'5':_ -> HTTP.status500 -- invalid tx state
+        '2':'8':_ -> HTTP.status403 -- invalid auth specification
+        '2':'D':_ -> HTTP.status500 -- invalid tx termination
+        '3':'8':_ -> HTTP.status500 -- external routine exception
+        '3':'9':_ -> HTTP.status500 -- external routine invocation
+        '3':'B':_ -> HTTP.status500 -- savepoint exception
+        '4':'0':_ -> HTTP.status500 -- tx rollback
+        '5':'3':_ -> HTTP.status503 -- insufficient resources
+        '5':'4':_ -> HTTP.status413 -- too complex
+        '5':'5':_ -> HTTP.status500 -- obj not on prereq state
+        '5':'7':_ -> HTTP.status500 -- operator intervention
+        '5':'8':_ -> HTTP.status500 -- system error
+        'F':'0':_ -> HTTP.status500 -- conf file error
+        'H':'V':_ -> HTTP.status500 -- foreign data wrapper error
+        "P0001"   -> HTTP.status400 -- default code for "raise"
+        'P':'0':_ -> HTTP.status500 -- PL/pgSQL Error
+        'X':'X':_ -> HTTP.status500 -- internal Error
+        "42883"-> if BS.isPrefixOf "function xmlagg(" m
+          then HTTP.status406
+          else HTTP.status404 -- undefined function
+        "42P01"   -> HTTP.status404 -- undefined table
+        "42501"   -> if authed then HTTP.status403 else HTTP.status401 -- insufficient privilege
+        'P':'T':n -> fromMaybe HTTP.status500 (HTTP.mkStatus <$> readMaybe n <*> pure m)
+        _         -> HTTP.status400
 
-    _                       -> HT.status500
+    _                       -> HTTP.status500
 
 checkIsFatal :: PgError -> Maybe Text
-checkIsFatal (PgError _ (P.ConnectionError e))
+checkIsFatal (PgError _ (SQL.ConnectionError e))
   | isAuthFailureMessage = Just $ toS failureMessage
   | otherwise = Nothing
-  where isAuthFailureMessage = "FATAL:  password authentication failed" `isPrefixOf` toS failureMessage
-        failureMessage = fromMaybe mempty e
-checkIsFatal (PgError _ (P.SessionError (H.QueryError _ _ (H.ResultError serverError))))
+  where isAuthFailureMessage = "FATAL:  password authentication failed" `isPrefixOf` failureMessage
+        failureMessage = BS.unpack $ fromMaybe mempty e
+checkIsFatal (PgError _ (SQL.SessionError (SQL.QueryError _ _ (SQL.ResultError serverError))))
   = case serverError of
       -- Check for a syntax error (42601 is the pg code). This would mean the error is on our part somehow, so we treat it as fatal.
-      H.ServerError "42601" _ _ _
+      SQL.ServerError "42601" _ _ _
         -> Just "Hint: This is probably a bug in PostgREST, please report it at https://github.com/PostgREST/postgrest/issues"
       -- Check for a "prepared statement <name> already exists" error (Code 42P05: duplicate_prepared_statement).
       -- This would mean that a connection pooler in transaction mode is being used
       -- while prepared statements are enabled in the PostgREST configuration,
       -- both of which are incompatible with each other.
-      H.ServerError "42P05" _ _ _
+      SQL.ServerError "42P05" _ _ _
         -> Just "Hint: If you are using connection poolers in transaction mode, try setting db-prepared-statements to false."
       -- Check for a "transaction blocks not allowed in statement pooling mode" error (Code 08P01: protocol_violation).
       -- This would mean that a connection pooler in statement mode is being used which is not supported in PostgREST.
-      H.ServerError "08P01" "transaction blocks not allowed in statement pooling mode" _ _
+      SQL.ServerError "08P01" "transaction blocks not allowed in statement pooling mode" _ _
         -> Just "Hint: Connection poolers in statement mode are not supported."
       _ -> Nothing
 checkIsFatal _ = Nothing
 
 
 data Error
-  = GucHeadersError
+  = ApiRequestError ApiRequestError
+  | BinaryFieldError MediaType
+  | GucHeadersError
   | GucStatusError
-  | BinaryFieldError ContentType
-  | ConnectionLostError
-  | PutMatchingPkError
-  | PutRangeNotAllowedError
-  | JwtTokenMissing
   | JwtTokenInvalid Text
-  | SingularityError Integer
-  | NotFound
-  | ApiRequestError ApiRequestError
+  | JwtTokenMissing
+  | JwtTokenRequired
+  | NoSchemaCacheError
+  | OffLimitsChangesError Int64 Integer
   | PgErr PgError
+  | PutMatchingPkError
+  | SingularityError Integer
 
 instance PgrstError Error where
-  status GucHeadersError         = HT.status500
-  status GucStatusError          = HT.status500
-  status (BinaryFieldError _)    = HT.status406
-  status ConnectionLostError     = HT.status503
-  status PutMatchingPkError      = HT.status400
-  status PutRangeNotAllowedError = HT.status400
-  status JwtTokenMissing         = HT.status500
-  status (JwtTokenInvalid _)     = HT.unauthorized401
-  status (SingularityError _)    = HT.status406
-  status NotFound                = HT.status404
-  status (PgErr err)             = status err
   status (ApiRequestError err)   = status err
+  status BinaryFieldError{}      = HTTP.status406
+  status GucHeadersError         = HTTP.status500
+  status GucStatusError          = HTTP.status500
+  status JwtTokenInvalid{}       = HTTP.unauthorized401
+  status JwtTokenMissing         = HTTP.status500
+  status JwtTokenRequired        = HTTP.unauthorized401
+  status NoSchemaCacheError      = HTTP.status503
+  status OffLimitsChangesError{} = HTTP.status400
+  status (PgErr err)             = status err
+  status PutMatchingPkError      = HTTP.status400
+  status SingularityError{}      = HTTP.status406
 
-  headers (SingularityError _)     = [ContentType.toHeader CTSingularJSON]
-  headers (JwtTokenInvalid m)      = [ContentType.toHeader CTApplicationJSON, invalidTokenHeader m]
-  headers (PgErr err)              = headers err
-  headers (ApiRequestError err)    = headers err
-  headers _                        = [ContentType.toHeader CTApplicationJSON]
+  headers (ApiRequestError err)  = headers err
+  headers (JwtTokenInvalid m)    = [MediaType.toContentType MTApplicationJSON, invalidTokenHeader m]
+  headers JwtTokenRequired       = [MediaType.toContentType MTApplicationJSON, requiredTokenHeader]
+  headers (PgErr err)            = headers err
+  headers SingularityError{}     = [MediaType.toContentType MTSingularJSON]
+  headers _                      = [MediaType.toContentType MTApplicationJSON]
 
 instance JSON.ToJSON Error where
-  toJSON GucHeadersError           = JSON.object [
-    "message" .= ("response.headers guc must be a JSON array composed of objects with a single key and a string value" :: Text)]
-  toJSON GucStatusError           = JSON.object [
-    "message" .= ("response.status guc must be a valid status code" :: Text)]
-  toJSON (BinaryFieldError ct)          = JSON.object [
-    "message" .= ((toS (ContentType.toMime ct) <> " requested but more than one column was selected") :: Text)]
-  toJSON ConnectionLostError       = JSON.object [
-    "message" .= ("Database connection lost. Retrying the connection." :: Text)]
+  toJSON NoSchemaCacheError = JSON.object [
+      "code"    .= ConnectionErrorCode02,
+      "message" .= ("Could not query the database for the schema cache. Retrying." :: Text),
+      "details" .= JSON.Null,
+      "hint"    .= JSON.Null]
 
-  toJSON PutRangeNotAllowedError   = JSON.object [
-    "message" .= ("Range header and limit/offset querystring parameters are not allowed for PUT" :: Text)]
-  toJSON PutMatchingPkError        = JSON.object [
-    "message" .= ("Payload values do not match URL in primary key column(s)" :: Text)]
-
-  toJSON (SingularityError n)      = JSON.object [
-    "message" .= ("JSON object requested, multiple (or no) rows returned" :: Text),
-    "details" .= T.unwords ["Results contain", show n, "rows,", toS (ContentType.toMime CTSingularJSON), "requires 1 row"]]
-
-  toJSON JwtTokenMissing           = JSON.object [
-    "message" .= ("Server lacks JWT secret" :: Text)]
+  toJSON JwtTokenMissing = JSON.object [
+      "code"    .= JWTErrorCode00,
+      "message" .= ("Server lacks JWT secret" :: Text),
+      "details" .= JSON.Null,
+      "hint"    .= JSON.Null]
   toJSON (JwtTokenInvalid message) = JSON.object [
-    "message" .= (message :: Text)]
-  toJSON NotFound = JSON.object []
+      "code"    .= JWTErrorCode01,
+      "message" .= (message :: Text),
+      "details" .= JSON.Null,
+      "hint"    .= JSON.Null]
+  toJSON JwtTokenRequired = JSON.object [
+      "code"    .= JWTErrorCode02,
+      "message" .= ("Anonymous access is disabled" :: Text),
+      "details" .= JSON.Null,
+      "hint"    .= JSON.Null]
+
+  toJSON (OffLimitsChangesError n maxs) = JSON.object [
+      "code"    .= ApiRequestErrorCode10,
+      "message" .= ("The maximum number of rows allowed to change was surpassed" :: Text),
+      "details" .= T.unwords ["Results contain", show n, "rows changed but the maximum number allowed is", show maxs],
+      "hint"    .= JSON.Null]
+
+  toJSON GucHeadersError = JSON.object [
+    "code"    .= ApiRequestErrorCode11,
+    "message" .= ("response.headers guc must be a JSON array composed of objects with a single key and a string value" :: Text),
+    "details" .= JSON.Null,
+    "hint"    .= JSON.Null]
+  toJSON GucStatusError = JSON.object [
+    "code"    .= ApiRequestErrorCode12,
+    "message" .= ("response.status guc must be a valid status code" :: Text),
+    "details" .= JSON.Null,
+    "hint"    .= JSON.Null]
+  toJSON (BinaryFieldError ct) = JSON.object [
+    "code"    .= ApiRequestErrorCode13,
+    "message" .= ((T.decodeUtf8 (MediaType.toMime ct) <> " requested but more than one column was selected") :: Text),
+    "details" .= JSON.Null,
+    "hint"    .= JSON.Null]
+
+  toJSON PutMatchingPkError = JSON.object [
+    "code"    .= ApiRequestErrorCode15,
+    "message" .= ("Payload values do not match URL in primary key column(s)" :: Text),
+    "details" .= JSON.Null,
+    "hint"    .= JSON.Null]
+
+  toJSON (SingularityError n) = JSON.object [
+    "code"    .= ApiRequestErrorCode16,
+    "message" .= ("JSON object requested, multiple (or no) rows returned" :: Text),
+    "details" .= T.unwords ["Results contain", show n, "rows,", T.decodeUtf8 (MediaType.toMime MTSingularJSON), "requires 1 row"],
+    "hint"    .= JSON.Null]
+
   toJSON (PgErr err) = JSON.toJSON err
   toJSON (ApiRequestError err) = JSON.toJSON err
 
@@ -323,5 +419,86 @@ invalidTokenHeader :: Text -> Header
 invalidTokenHeader m =
   ("WWW-Authenticate", "Bearer error=\"invalid_token\", " <> "error_description=" <> encodeUtf8 (show m))
 
+requiredTokenHeader :: Header
+requiredTokenHeader = ("WWW-Authenticate", "Bearer")
+
 singularityError :: (Integral a) => a -> Error
 singularityError = SingularityError . toInteger
+
+-- Error codes are grouped by common modules or characteristics
+data ErrorCode
+  -- PostgreSQL connection errors
+  = ConnectionErrorCode00
+  | ConnectionErrorCode01
+  | ConnectionErrorCode02
+  -- API Request errors
+  | ApiRequestErrorCode00
+  | ApiRequestErrorCode01
+  | ApiRequestErrorCode02
+  | ApiRequestErrorCode03
+  | ApiRequestErrorCode04
+  | ApiRequestErrorCode05
+  | ApiRequestErrorCode06
+  | ApiRequestErrorCode07
+  | ApiRequestErrorCode08
+  | ApiRequestErrorCode09
+  | ApiRequestErrorCode10
+  | ApiRequestErrorCode11
+  | ApiRequestErrorCode12
+  | ApiRequestErrorCode13
+  | ApiRequestErrorCode14
+  | ApiRequestErrorCode15
+  | ApiRequestErrorCode16
+  | ApiRequestErrorCode17
+  -- Schema Cache errors
+  | SchemaCacheErrorCode00
+  | SchemaCacheErrorCode01
+  | SchemaCacheErrorCode02
+  | SchemaCacheErrorCode03
+  -- JWT authentication errors
+  | JWTErrorCode00
+  | JWTErrorCode01
+  | JWTErrorCode02
+  -- Internal errors related to the Hasql library
+  | InternalErrorCode00
+
+instance JSON.ToJSON ErrorCode where
+  toJSON e = JSON.toJSON (buildErrorCode e)
+
+-- New group of errors will be added at the end of all the groups and will have the next prefix in the sequence
+-- New errors are added at the end of the group they belong to and will have the next code in the sequence
+buildErrorCode :: ErrorCode -> Text
+buildErrorCode code = "PGRST" <> case code of
+  ConnectionErrorCode00  -> "000"
+  ConnectionErrorCode01  -> "001"
+  ConnectionErrorCode02  -> "002"
+
+  ApiRequestErrorCode00  -> "100"
+  ApiRequestErrorCode01  -> "101"
+  ApiRequestErrorCode02  -> "102"
+  ApiRequestErrorCode03  -> "103"
+  ApiRequestErrorCode04  -> "104"
+  ApiRequestErrorCode05  -> "105"
+  ApiRequestErrorCode06  -> "106"
+  ApiRequestErrorCode07  -> "107"
+  ApiRequestErrorCode08  -> "108"
+  ApiRequestErrorCode09  -> "109"
+  ApiRequestErrorCode10  -> "110"
+  ApiRequestErrorCode11  -> "111"
+  ApiRequestErrorCode12  -> "112"
+  ApiRequestErrorCode13  -> "113"
+  ApiRequestErrorCode14  -> "114"
+  ApiRequestErrorCode15  -> "115"
+  ApiRequestErrorCode16  -> "116"
+  ApiRequestErrorCode17  -> "117"
+
+  SchemaCacheErrorCode00 -> "200"
+  SchemaCacheErrorCode01 -> "201"
+  SchemaCacheErrorCode02 -> "202"
+  SchemaCacheErrorCode03 -> "203"
+
+  JWTErrorCode00         -> "300"
+  JWTErrorCode01         -> "301"
+  JWTErrorCode02         -> "302"
+
+  InternalErrorCode00    -> "X00"

src/PostgREST/GucHeader.hs

@@ -5,13 +5,13 @@ module PostgREST.GucHeader
   ) where
 
 import qualified Data.Aeson           as JSON
+import qualified Data.Aeson.Key       as K
+import qualified Data.Aeson.KeyMap    as KM
 import qualified Data.CaseInsensitive as CI
-import qualified Data.HashMap.Strict  as M
 
 import Network.HTTP.Types.Header (Header)
 
-import Protolude      hiding (toS)
-import Protolude.Conv (toS)
+import Protolude
 
 
 {-|
@@ -21,11 +21,11 @@ import Protolude.Conv (toS)
 newtype GucHeader = GucHeader (CI.CI ByteString, ByteString)
 
 instance JSON.FromJSON GucHeader where
-  parseJSON (JSON.Object o) = case headMay (M.toList o) of
-    Just (k, JSON.String s) | M.size o == 1 -> pure $ GucHeader (CI.mk $ toS k, toS s)
-                            | otherwise     -> mzero
-    _ -> mzero
-  parseJSON _          = mzero
+  parseJSON (JSON.Object o) =
+    case KM.toList o of
+      [(k, JSON.String s)] -> pure $ GucHeader (CI.mk $ toUtf8 $ K.toText k, toUtf8 s)
+      _ -> mzero
+  parseJSON _ = mzero
 
 unwrapGucHeader :: GucHeader -> Header
 unwrapGucHeader (GucHeader (k, v)) = (k, v)

src/PostgREST/Logger.hs

@@ -0,0 +1,30 @@
+{-|
+Module      : PostgREST.Logger
+Description : Wai Middleware to log requests to stdout.
+-}
+module PostgREST.Logger (middleware) where
+
+import qualified Network.Wai                          as Wai
+import qualified Network.Wai.Middleware.RequestLogger as Wai
+
+import Network.HTTP.Types.Status (status400, status500)
+import System.IO.Unsafe          (unsafePerformIO)
+
+import qualified PostgREST.Auth   as Auth
+import           PostgREST.Config (LogLevel (..))
+
+import Protolude
+
+middleware :: LogLevel -> Wai.Middleware
+middleware logLevel = case logLevel of
+  LogInfo  -> requestLogger (const True)
+  LogWarn  -> requestLogger (>= status400)
+  LogError -> requestLogger (>= status500)
+  LogCrit  -> requestLogger (const False)
+  where
+    requestLogger filterStatus = unsafePerformIO $ Wai.mkRequestLogger Wai.defaultRequestLoggerSettings
+      { Wai.outputFormat = Wai.ApacheWithSettings $
+          Wai.defaultApacheSettings
+            & Wai.setApacheRequestFilter (\_ res -> filterStatus $ Wai.responseStatus res)
+            & Wai.setApacheUserGetter (fmap encodeUtf8 . Auth.getRole)
+      }

src/PostgREST/MediaType.hs

@@ -0,0 +1,124 @@
+{-# LANGUAGE DuplicateRecordFields #-}
+
+module PostgREST.MediaType
+  ( MediaType(..)
+  , MTPlanOption (..)
+  , MTPlanFormat (..)
+  , MTPlanAttrs(..)
+  , toContentType
+  , toMime
+  , decodeMediaType
+  , getMediaType
+  ) where
+
+import qualified Data.ByteString          as BS
+import qualified Data.ByteString.Internal as BS (c2w)
+import           Data.Maybe               (fromJust)
+
+import Network.HTTP.Types.Header (Header, hContentType)
+
+import Protolude
+
+-- | Enumeration of currently supported media types
+data MediaType
+  = MTApplicationJSON
+  | MTSingularJSON
+  | MTGeoJSON
+  | MTTextCSV
+  | MTTextPlain
+  | MTTextXML
+  | MTOpenAPI
+  | MTUrlEncoded
+  | MTOctetStream
+  | MTAny
+  | MTOther ByteString
+  | MTPlan MTPlanAttrs
+  deriving Eq
+
+data MTPlanAttrs = MTPlanAttrs (Maybe MediaType) MTPlanFormat [MTPlanOption]
+instance Eq MTPlanAttrs where
+  MTPlanAttrs {} == MTPlanAttrs {} = True -- we don't care about the attributes when comparing two MTPlan media types
+
+data MTPlanOption
+  = PlanAnalyze | PlanVerbose | PlanSettings | PlanBuffers | PlanWAL
+
+data MTPlanFormat
+  = PlanJSON | PlanText
+
+-- | Convert MediaType to a Content-Type HTTP Header
+toContentType :: MediaType -> Header
+toContentType ct = (hContentType, toMime ct <> charset)
+  where
+    charset = case ct of
+      MTOctetStream -> mempty
+      MTOther _     -> mempty
+      _             -> "; charset=utf-8"
+
+-- | Convert from MediaType to a ByteString representing the mime type
+toMime :: MediaType -> ByteString
+toMime MTApplicationJSON = "application/json"
+toMime MTGeoJSON         = "application/geo+json"
+toMime MTTextCSV         = "text/csv"
+toMime MTTextPlain       = "text/plain"
+toMime MTTextXML         = "text/xml"
+toMime MTOpenAPI         = "application/openapi+json"
+toMime MTSingularJSON    = "application/vnd.pgrst.object+json"
+toMime MTUrlEncoded      = "application/x-www-form-urlencoded"
+toMime MTOctetStream     = "application/octet-stream"
+toMime MTAny             = "*/*"
+toMime (MTOther ct)      = ct
+toMime (MTPlan (MTPlanAttrs mt fmt opts)) =
+  "application/vnd.pgrst.plan+" <> toMimePlanFormat fmt <>
+  (if isNothing mt then mempty else "; for=\"" <> toMime (fromJust mt) <> "\"") <>
+  (if null opts then mempty else "; options=" <> BS.intercalate "|" (toMimePlanOption <$> opts))
+
+toMimePlanOption :: MTPlanOption -> ByteString
+toMimePlanOption PlanAnalyze  = "analyze"
+toMimePlanOption PlanVerbose  = "verbose"
+toMimePlanOption PlanSettings = "settings"
+toMimePlanOption PlanBuffers  = "buffers"
+toMimePlanOption PlanWAL      = "wal"
+
+toMimePlanFormat :: MTPlanFormat -> ByteString
+toMimePlanFormat PlanJSON = "json"
+toMimePlanFormat PlanText = "text"
+
+-- | Convert from ByteString to MediaType. Warning: discards MIME parameters
+decodeMediaType :: BS.ByteString -> MediaType
+decodeMediaType mt =
+  case BS.split (BS.c2w ';') mt of
+    "application/json":_                   -> MTApplicationJSON
+    "application/geo+json":_               -> MTGeoJSON
+    "text/csv":_                           -> MTTextCSV
+    "text/plain":_                         -> MTTextPlain
+    "text/xml":_                           -> MTTextXML
+    "application/openapi+json":_           -> MTOpenAPI
+    "application/vnd.pgrst.object+json":_  -> MTSingularJSON
+    "application/vnd.pgrst.object":_       -> MTSingularJSON
+    "application/x-www-form-urlencoded":_  -> MTUrlEncoded
+    "application/octet-stream":_           -> MTOctetStream
+    "application/vnd.pgrst.plan":rest      -> getPlan PlanText rest
+    "application/vnd.pgrst.plan+text":rest -> getPlan PlanText rest
+    "application/vnd.pgrst.plan+json":rest -> getPlan PlanJSON rest
+    "*/*":_                                -> MTAny
+    other:_                                -> MTOther other
+    _                                      -> MTAny
+  where
+    getPlan fmt rest =
+     let
+       opts         = BS.split (BS.c2w '|') $ fromMaybe mempty (BS.stripPrefix "options=" =<< find (BS.isPrefixOf "options=") rest)
+       inOpts str   = str `elem` opts
+       mtFor        = decodeMediaType . dropAround (== BS.c2w '"') <$> (BS.stripPrefix "for=" =<< find (BS.isPrefixOf "for=") rest)
+       dropAround p = BS.dropWhile p . BS.dropWhileEnd p in
+     MTPlan $ MTPlanAttrs mtFor fmt $
+      [PlanAnalyze  | inOpts "analyze" ] ++
+      [PlanVerbose  | inOpts "verbose" ] ++
+      [PlanSettings | inOpts "settings"] ++
+      [PlanBuffers  | inOpts "buffers" ] ++
+      [PlanWAL      | inOpts "wal"     ]
+
+getMediaType :: MediaType -> MediaType
+getMediaType mt = case mt of
+  MTPlan (MTPlanAttrs (Just mType) _ _) -> mType
+  MTPlan (MTPlanAttrs Nothing _ _)      -> MTApplicationJSON
+  other                                 -> other

src/PostgREST/Middleware.hs

@@ -2,170 +2,94 @@
 Module      : PostgREST.Middleware
 Description : Sets CORS policy. Also the PostgreSQL GUCs, role, search_path and pre-request function.
 -}
+{-# LANGUAGE BlockArguments  #-}
 {-# LANGUAGE RecordWildCards #-}
 module PostgREST.Middleware
   ( runPgLocals
-  , pgrstFormat
-  , pgrstMiddleware
-  , defaultCorsPolicy
-  , corsPolicy
   , optionalRollback
   ) where
 
-import qualified Data.Aeson                           as JSON
-import qualified Data.ByteString.Char8                as BS
-import qualified Data.CaseInsensitive                 as CI
-import qualified Data.HashMap.Strict                  as M
-import qualified Data.Text                            as T
-import qualified Hasql.Decoders                       as HD
-import qualified Hasql.DynamicStatements.Snippet      as H hiding
-                                                           (sql)
-import qualified Hasql.DynamicStatements.Statement    as H
-import qualified Hasql.Transaction                    as H
-import qualified Network.HTTP.Types.Header            as HTTP
-import qualified Network.Wai                          as Wai
-import qualified Network.Wai.Logger                   as Wai
-import qualified Network.Wai.Middleware.Cors          as Wai
-import qualified Network.Wai.Middleware.Gzip          as Wai
-import qualified Network.Wai.Middleware.RequestLogger as Wai
-import qualified Network.Wai.Middleware.Static        as Wai
+import qualified Data.Aeson                        as JSON
+import qualified Data.Aeson.Key                    as K
+import qualified Data.Aeson.KeyMap                 as KM
+import qualified Data.ByteString.Lazy.Char8        as LBS
+import qualified Data.HashMap.Strict               as HM
+import qualified Data.Text.Encoding                as T
+import qualified Hasql.Decoders                    as HD
+import qualified Hasql.DynamicStatements.Snippet   as SQL hiding (sql)
+import qualified Hasql.DynamicStatements.Statement as SQL
+import qualified Hasql.Transaction                 as SQL
+import qualified Network.Wai                       as Wai
 
-import Data.Function             (id)
-import Data.List                 (lookup)
-import Data.Scientific           (FPFormat (..), formatScientific,
-                                  isInteger)
-import Network.HTTP.Types.Status (Status, status400, status500,
-                                  statusCode)
-import System.IO.Unsafe          (unsafePerformIO)
-import System.Log.FastLogger     (toLogStr)
 
-import PostgREST.Config             (AppConfig (..), LogLevel (..))
+import Control.Arrow ((***))
+
+import Data.Scientific (FPFormat (..), formatScientific, isInteger)
+
+import PostgREST.Config             (AppConfig (..))
+import PostgREST.Config.PgVersion   (PgVersion (..), pgVersion140)
 import PostgREST.Error              (Error, errorResponseFor)
 import PostgREST.GucHeader          (addHeadersIfNotIncluded)
 import PostgREST.Query.SqlFragment  (fromQi, intercalateSnippet,
-                                     unknownEncoder)
+                                     pgFmtIdentList, unknownEncoder)
 import PostgREST.Request.ApiRequest (ApiRequest (..), Target (..))
 
 import PostgREST.Request.Preferences
 
-import Protolude      hiding (head, toS)
-import Protolude.Conv (toS)
+import Protolude
 
 -- | Runs local(transaction scoped) GUCs for every request, plus the pre-request function
-runPgLocals :: AppConfig   -> M.HashMap Text JSON.Value ->
-               (ApiRequest -> ExceptT Error H.Transaction Wai.Response) ->
-               ApiRequest  -> ByteString -> ExceptT Error H.Transaction Wai.Response
-runPgLocals conf claims app req jsonDbS = do
-  lift $ H.statement mempty $ H.dynamicallyParameterized
+runPgLocals :: AppConfig   -> KM.KeyMap JSON.Value -> Text ->
+               (ApiRequest -> ExceptT Error SQL.Transaction Wai.Response) ->
+               ApiRequest  -> ByteString -> PgVersion -> ExceptT Error SQL.Transaction Wai.Response
+runPgLocals conf claims role app req jsonDbS actualPgVersion = do
+  lift $ SQL.statement mempty $ SQL.dynamicallyParameterized
     ("select " <> intercalateSnippet ", " (searchPathSql : roleSql ++ claimsSql ++ [methodSql, pathSql] ++ headersSql ++ cookiesSql ++ appSettingsSql ++ specSql))
     HD.noResult (configDbPreparedStatements conf)
-  lift $ traverse_ H.sql preReqSql
+  lift $ traverse_ SQL.sql preReqSql
   app req
   where
     methodSql = setConfigLocal mempty ("request.method", iMethod req)
     pathSql = setConfigLocal mempty ("request.path", iPath req)
-    headersSql = setConfigLocal "request.header." <$> iHeaders req
-    cookiesSql = setConfigLocal "request.cookie." <$> iCookies req
-    claimsWithRole =
-      let anon = JSON.String . toS $ configDbAnonRole conf in -- role claim defaults to anon if not specified in jwt
-      M.union claims (M.singleton "role" anon)
-    claimsSql = setConfigLocal "request.jwt.claim." <$> [(toS c, toS $ unquoted v) | (c,v) <- M.toList claimsWithRole]
-    roleSql = maybeToList $ (\x -> setConfigLocal mempty ("role", toS $ unquoted x)) <$> M.lookup "role" claimsWithRole
-    appSettingsSql = setConfigLocal mempty <$> (join bimap toS <$> configAppSettings conf)
+    headersSql = if usesLegacyGucs
+                   then setConfigLocal "request.header." <$> iHeaders req
+                   else setConfigLocalJson "request.headers" (iHeaders req)
+    cookiesSql = if usesLegacyGucs
+                   then setConfigLocal "request.cookie." <$> iCookies req
+                   else setConfigLocalJson "request.cookies" (iCookies req)
+    claimsSql = if usesLegacyGucs
+                  then setConfigLocal "request.jwt.claim." <$> [(toUtf8 $ K.toText c, toUtf8 $ unquoted v) | (c,v) <- KM.toList claims]
+                  else [setConfigLocal mempty ("request.jwt.claims", LBS.toStrict $ JSON.encode claims)]
+    roleSql = [setConfigLocal mempty ("role", toUtf8 role)]
+    appSettingsSql = setConfigLocal mempty <$> (join bimap toUtf8 <$> configAppSettings conf)
     searchPathSql =
-      let schemas = T.intercalate ", " (iSchema req : configDbExtraSearchPath conf) in
-      setConfigLocal mempty ("search_path", toS schemas)
+      let schemas = pgFmtIdentList (iSchema req : configDbExtraSearchPath conf) in
+      setConfigLocal mempty ("search_path", schemas)
     preReqSql = (\f -> "select " <> fromQi f <> "();") <$> configDbPreRequest conf
     specSql = case iTarget req of
       TargetProc{tpIsRootSpec=True} -> [setConfigLocal mempty ("request.spec", jsonDbS)]
       _                             -> mempty
-    -- | Do a pg set_config(setting, value, true) call. This is equivalent to a SET LOCAL.
-    setConfigLocal :: ByteString -> (ByteString, ByteString) -> H.Snippet
-    setConfigLocal prefix (k, v) =
-      "set_config(" <> unknownEncoder (prefix <> k) <> ", " <> unknownEncoder v <> ", true)"
+    usesLegacyGucs = configDbUseLegacyGucs conf && actualPgVersion < pgVersion140
 
--- | Log in apache format. Only requests that have a status greater than minStatus are logged.
--- | There's no way to filter logs in the apache format on wai-extra: https://hackage.haskell.org/package/wai-extra-3.0.29.2/docs/Network-Wai-Middleware-RequestLogger.html#t:OutputFormat.
--- | So here we copy wai-logger apacheLogStr function: https://github.com/kazu-yamamoto/logger/blob/a4f51b909a099c51af7a3f75cf16e19a06f9e257/wai-logger/Network/Wai/Logger/Apache.hs#L45
--- | TODO: Add the ability to filter apache logs on wai-extra and remove this function.
-pgrstFormat :: Status -> Wai.OutputFormatter
-pgrstFormat minStatus date req status responseSize =
-  if status < minStatus
-    then mempty
-  else toLogStr (getSourceFromSocket req)
-    <> " - - ["
-    <> toLogStr date
-    <> "] \""
-    <> toLogStr (Wai.requestMethod req)
-    <> " "
-    <> toLogStr (Wai.rawPathInfo req <> Wai.rawQueryString req)
-    <> " "
-    <> toLogStr (show (Wai.httpVersion req)::Text)
-    <> "\" "
-    <> toLogStr (show (statusCode status)::Text)
-    <> " "
-    <> toLogStr (maybe "-" show responseSize::Text)
-    <> " \""
-    <> toLogStr (fromMaybe mempty $ Wai.requestHeaderReferer req)
-    <> "\" \""
-    <> toLogStr (fromMaybe mempty $ Wai.requestHeaderUserAgent req)
-    <> "\"\n"
-  where
-    getSourceFromSocket = BS.pack . Wai.showSockAddr . Wai.remoteHost
-
-pgrstMiddleware :: LogLevel -> Wai.Application -> Wai.Application
-pgrstMiddleware logLevel =
-    logger
-  . Wai.cors corsPolicy
-  . Wai.staticPolicy (Wai.only [("favicon.ico", "static/favicon.ico")])
-  where
-    logger = case logLevel of
-      LogCrit  -> id
-      LogError -> unsafePerformIO $ Wai.mkRequestLogger Wai.def { Wai.outputFormat = Wai.CustomOutputFormat $ pgrstFormat status500}
-      LogWarn  -> unsafePerformIO $ Wai.mkRequestLogger Wai.def { Wai.outputFormat = Wai.CustomOutputFormat $ pgrstFormat status400}
-      LogInfo  -> Wai.logStdout
-
-defaultCorsPolicy :: Wai.CorsResourcePolicy
-defaultCorsPolicy =  Wai.CorsResourcePolicy Nothing
-  ["GET", "POST", "PATCH", "PUT", "DELETE", "OPTIONS"] ["Authorization"] Nothing
-  (Just $ 60*60*24) False False True
-
--- | CORS policy to be used in by Wai Cors middleware
-corsPolicy :: Wai.Request -> Maybe Wai.CorsResourcePolicy
-corsPolicy req = case lookup "origin" headers of
-  Just origin -> Just defaultCorsPolicy {
-      Wai.corsOrigins = Just ([origin], True)
-    , Wai.corsRequestHeaders = "Authentication" : accHeaders
-    , Wai.corsExposedHeaders = Just [
-        "Content-Encoding", "Content-Location", "Content-Range", "Content-Type"
-      , "Date", "Location", "Server", "Transfer-Encoding", "Range-Unit"
-      ]
-    }
-  Nothing -> Nothing
-  where
-    headers = Wai.requestHeaders req
-    accHeaders = case lookup "access-control-request-headers" headers of
-      Just hdrs -> map (CI.mk . toS . T.strip . toS) $ BS.split ',' hdrs
-      Nothing -> []
-
-unquoted :: JSON.Value -> Text
-unquoted (JSON.String t) = t
-unquoted (JSON.Number n) =
-  toS $ formatScientific Fixed (if isInteger n then Just 0 else Nothing) n
-unquoted (JSON.Bool b) = show b
-unquoted v = toS $ JSON.encode v
+    unquoted :: JSON.Value -> Text
+    unquoted (JSON.String t) = t
+    unquoted (JSON.Number n) =
+      toS $ formatScientific Fixed (if isInteger n then Just 0 else Nothing) n
+    unquoted (JSON.Bool b) = show b
+    unquoted v = T.decodeUtf8 . LBS.toStrict $ JSON.encode v
 
 -- | Set a transaction to eventually roll back if requested and set respective
 -- headers on the response.
 optionalRollback
   :: AppConfig
   -> ApiRequest
-  -> ExceptT Error H.Transaction Wai.Response
-  -> ExceptT Error H.Transaction Wai.Response
+  -> ExceptT Error SQL.Transaction Wai.Response
+  -> ExceptT Error SQL.Transaction Wai.Response
 optionalRollback AppConfig{..} ApiRequest{..} transaction = do
   resp <- catchError transaction $ return . errorResponseFor
-  when (shouldRollback || (configDbTxRollbackAll && not shouldCommit))
-    (lift H.condemn)
+  when (shouldRollback || (configDbTxRollbackAll && not shouldCommit)) $ lift do
+    SQL.sql "SET CONSTRAINTS ALL IMMEDIATE"
+    SQL.condemn
   return $ Wai.mapResponseHeaders preferenceApplied resp
   where
     shouldCommit =
@@ -175,9 +99,24 @@ optionalRollback AppConfig{..} ApiRequest{..} transaction = do
     preferenceApplied
       | shouldCommit =
           addHeadersIfNotIncluded
-            [(HTTP.hPreferenceApplied, BS.pack (show Commit))]
+            [toAppliedHeader Commit]
       | shouldRollback =
           addHeadersIfNotIncluded
-            [(HTTP.hPreferenceApplied, BS.pack (show Rollback))]
+            [toAppliedHeader Rollback]
       | otherwise =
           identity
+
+-- | Do a pg set_config(setting, value, true) call. This is equivalent to a SET LOCAL.
+setConfigLocal :: ByteString -> (ByteString, ByteString) -> SQL.Snippet
+setConfigLocal prefix (k, v) =
+  "set_config(" <> unknownEncoder (prefix <> k) <> ", " <> unknownEncoder v <> ", true)"
+
+-- | Starting from PostgreSQL v14, some characters are not allowed for config names (mostly affecting headers with "-").
+-- | A JSON format string is used to avoid this problem. See https://github.com/PostgREST/postgrest/issues/1857
+setConfigLocalJson :: ByteString -> [(ByteString, ByteString)] -> [SQL.Snippet]
+setConfigLocalJson prefix keyVals = [setConfigLocal mempty (prefix, gucJsonVal keyVals)]
+  where
+    gucJsonVal :: [(ByteString, ByteString)] -> ByteString
+    gucJsonVal = LBS.toStrict . JSON.encode . HM.fromList . arrayByteStringToText
+    arrayByteStringToText :: [(ByteString, ByteString)] -> [(Text,Text)]
+    arrayByteStringToText keyVal = (T.decodeUtf8 *** T.decodeUtf8) <$> keyVal

src/PostgREST/OpenAPI.hs

@@ -3,15 +3,16 @@ Module      : PostgREST.OpenAPI
 Description : Generates the OpenAPI output
 -}
 {-# LANGUAGE LambdaCase      #-}
-{-# LANGUAGE NamedFieldPuns  #-}
 {-# LANGUAGE RecordWildCards #-}
 module PostgREST.OpenAPI (encode) where
 
-import qualified Data.Aeson           as JSON
-import qualified Data.ByteString.Lazy as LBS
-import qualified Data.HashMap.Strict  as HashMap
-import qualified Data.HashSet.InsOrd  as Set
-import qualified Data.Text            as T
+import qualified Data.Aeson            as JSON
+import qualified Data.ByteString.Char8 as BS
+import qualified Data.ByteString.Lazy  as LBS
+import qualified Data.HashMap.Strict   as HM
+import qualified Data.HashSet.InsOrd   as Set
+import qualified Data.Text             as T
+import qualified Data.Text.Encoding    as T
 
 import Control.Arrow              ((&&&))
 import Data.HashMap.Strict.InsOrd (InsOrdHashMap, fromList)
@@ -25,76 +26,89 @@ import Data.Swagger
 
 import PostgREST.Config                   (AppConfig (..), Proxy (..),
                                            isMalformedProxyUri, toURI)
-import PostgREST.DbStructure              (DbStructure (..),
-                                           tableCols, tablePKCols)
-import PostgREST.DbStructure.Proc         (PgArg (..),
-                                           ProcDescription (..))
+import PostgREST.DbStructure              (DbStructure (..))
+import PostgREST.DbStructure.Identifiers  (QualifiedIdentifier (..))
+import PostgREST.DbStructure.Proc         (ProcDescription (..),
+                                           ProcParam (..))
 import PostgREST.DbStructure.Relationship (Cardinality (..),
-                                           PrimaryKey (..),
-                                           Relationship (..))
-import PostgREST.DbStructure.Table        (Column (..), Table (..))
+                                           Relationship (..),
+                                           RelationshipsMap)
+import PostgREST.DbStructure.Table        (Column (..), Table (..),
+                                           TablesMap)
 import PostgREST.Version                  (docsVersion, prettyVersion)
 
-import PostgREST.ContentType
+import PostgREST.MediaType
 
-import Protolude      hiding (Proxy, get, toS)
-import Protolude.Conv (toS)
+import Protolude hiding (Proxy, get)
 
-encode :: AppConfig -> DbStructure -> [Table] -> HashMap.HashMap k [ProcDescription] -> Maybe Text -> LBS.ByteString
+encode :: AppConfig -> DbStructure -> TablesMap -> HM.HashMap k [ProcDescription] -> Maybe Text -> LBS.ByteString
 encode conf dbStructure tables procs schemaDescription =
   JSON.encode $
     postgrestSpec
       (dbRelationships dbStructure)
-      (concat $ HashMap.elems procs)
-      (openApiTableInfo dbStructure <$> tables)
+      (concat $ HM.elems procs)
+      (snd <$> HM.toList tables)
       (proxyUri conf)
       schemaDescription
-      (dbPrimaryKeys dbStructure)
+      (configOpenApiSecurityActive conf)
 
-makeMimeList :: [ContentType] -> MimeList
-makeMimeList cs = MimeList $ fmap (fromString . toS . toMime) cs
+makeMimeList :: [MediaType] -> MimeList
+makeMimeList cs = MimeList $ fmap (fromString . BS.unpack . toMime) cs
 
-toSwaggerType :: Text -> SwaggerType t
-toSwaggerType "character varying" = SwaggerString
-toSwaggerType "character"         = SwaggerString
-toSwaggerType "text"              = SwaggerString
-toSwaggerType "boolean"           = SwaggerBoolean
-toSwaggerType "smallint"          = SwaggerInteger
-toSwaggerType "integer"           = SwaggerInteger
-toSwaggerType "bigint"            = SwaggerInteger
-toSwaggerType "numeric"           = SwaggerNumber
-toSwaggerType "real"              = SwaggerNumber
-toSwaggerType "double precision"  = SwaggerNumber
-toSwaggerType _                   = SwaggerString
+toSwaggerType :: Text -> Maybe (SwaggerType t)
+toSwaggerType "character varying" = Just SwaggerString
+toSwaggerType "character"         = Just SwaggerString
+toSwaggerType "text"              = Just SwaggerString
+toSwaggerType "boolean"           = Just SwaggerBoolean
+toSwaggerType "smallint"          = Just SwaggerInteger
+toSwaggerType "integer"           = Just SwaggerInteger
+toSwaggerType "bigint"            = Just SwaggerInteger
+toSwaggerType "numeric"           = Just SwaggerNumber
+toSwaggerType "real"              = Just SwaggerNumber
+toSwaggerType "double precision"  = Just SwaggerNumber
+toSwaggerType "ARRAY"             = Just SwaggerArray
+toSwaggerType "json"              = Nothing
+toSwaggerType "jsonb"             = Nothing
+toSwaggerType _                   = Just SwaggerString
 
-makeTableDef :: [Relationship] -> [PrimaryKey] -> (Table, [Column], [Text]) -> (Text, Schema)
-makeTableDef rels pks (t, cs, _) =
+parseDefault :: Text -> Text -> Text
+parseDefault colType colDefault =
+  case toSwaggerType colType of
+    Just SwaggerString -> wrapInQuotations $ case T.stripSuffix ("::" <> colType) colDefault of
+      Just def -> T.dropAround (=='\'')  def
+      Nothing  -> colDefault
+    _ -> colDefault
+  where
+    wrapInQuotations text = "\"" <> text <> "\""
+
+makeTableDef :: RelationshipsMap -> Table -> (Text, Schema)
+makeTableDef rels t =
   let tn = tableName t in
       (tn, (mempty :: Schema)
         & description .~ tableDescription t
         & type_ ?~ SwaggerObject
-        & properties .~ fromList (fmap (makeProperty rels pks) cs)
-        & required .~ fmap colName (filter (not . colNullable) cs))
+        & properties .~ fromList (makeProperty t rels <$> tableColumns t)
+        & required .~ fmap colName (filter (not . colNullable) $ tableColumns t))
 
-makeProperty :: [Relationship] -> [PrimaryKey] -> Column -> (Text, Referenced Schema)
-makeProperty rels pks c = (colName c, Inline s)
+makeProperty :: Table -> RelationshipsMap -> Column -> (Text, Referenced Schema)
+makeProperty tbl rels col = (colName col, Inline s)
   where
-    e = if null $ colEnum c then Nothing else JSON.decode $ JSON.encode $ colEnum c
+    e = if null $ colEnum col then Nothing else JSON.decode $ JSON.encode $ colEnum col
     fk :: Maybe Text
     fk =
       let
         -- Finds the relationship that has a single column foreign key
         rel = find (\case
-          Relationship{relColumns, relCardinality=M2O _} -> [c] == relColumns
-          _                                                 -> False
-          ) rels
-        fCol = colName <$> (headMay . relForeignColumns =<< rel)
-        fTbl = tableName . relForeignTable <$> rel
+          Relationship{relCardinality=(M2O _ relColumns)} -> [colName col] == (fst <$> relColumns)
+          _                                               -> False
+          ) $ fromMaybe mempty $ HM.lookup (QualifiedIdentifier (tableSchema tbl) (tableName tbl), tableSchema tbl) rels
+        fCol = (headMay . (\r -> snd <$> relColumns (relCardinality r)) =<< rel)
+        fTbl = qiName . relForeignTable <$> rel
         fTblCol = (,) <$> fTbl <*> fCol
       in
         (\(a, b) -> T.intercalate "" ["This is a Foreign Key to `", a, ".", b, "`.<fk table='", a, "' column='", b, "'/>"]) <$> fTblCol
     pk :: Bool
-    pk = any (\p -> pkTable p == colTable c && pkName p == colName c) pks
+    pk = colName col `elem` tablePKCols tbl
     n = catMaybes
       [ Just "Note:"
       , if pk then Just "This is a Primary Key.<pk/>" else Nothing
@@ -102,31 +116,31 @@ makeProperty rels pks c = (colName c, Inline s)
       ]
     d =
       if length n > 1 then
-        Just $ T.append (maybe "" (`T.append` "\n\n") $ colDescription c) (T.intercalate "\n" n)
+        Just $ T.append (maybe "" (`T.append` "\n\n") $ colDescription col) (T.intercalate "\n" n)
       else
-        colDescription c
+        colDescription col
     s =
       (mempty :: Schema)
-        & default_ .~ (JSON.decode . toS =<< colDefault c)
+        & default_ .~ (JSON.decode . toUtf8Lazy . parseDefault (colType col) =<< colDefault col)
         & description .~ d
         & enum_ .~ e
-        & format ?~ colType c
-        & maxLength .~ (fromIntegral <$> colMaxLen c)
-        & type_ ?~ toSwaggerType (colType c)
+        & format ?~ colType col
+        & maxLength .~ (fromIntegral <$> colMaxLen col)
+        & type_ .~ toSwaggerType (colType col)
 
 makeProcSchema :: ProcDescription -> Schema
 makeProcSchema pd =
   (mempty :: Schema)
   & description .~ pdDescription pd
   & type_ ?~ SwaggerObject
-  & properties .~ fromList (fmap makeProcProperty (pdArgs pd))
-  & required .~ fmap pgaName (filter pgaReq (pdArgs pd))
+  & properties .~ fromList (fmap makeProcProperty (pdParams pd))
+  & required .~ fmap ppName (filter ppReq (pdParams pd))
 
-makeProcProperty :: PgArg -> (Text, Referenced Schema)
-makeProcProperty (PgArg n t _ _) = (n, Inline s)
+makeProcProperty :: ProcParam -> (Text, Referenced Schema)
+makeProcProperty (ProcParam n t _ _) = (n, Inline s)
   where
     s = (mempty :: Schema)
-          & type_ ?~ toSwaggerType t
+          & type_ .~ toSwaggerType t
           & format ?~ t
 
 makePreferParam :: [Text] -> Param
@@ -149,7 +163,7 @@ makeProcParam pd =
   , Ref $ Reference "preferParams"
   ]
 
-makeParamDefs :: [(Table, [Column], [Text])] -> [(Text, Param)]
+makeParamDefs :: [Table] -> [(Text, Param)]
 makeParamDefs ti =
   [ ("preferParams", makePreferParam ["params=single-object"])
   , ("preferReturn", makePreferParam ["return=representation", "return=minimal", "return=none"])
@@ -205,8 +219,8 @@ makeParamDefs ti =
         & in_ .~ ParamQuery
         & type_ ?~ SwaggerString))
   ]
-  <> concat [ makeObjectBody (tableName t) : makeRowFilters (tableName t) cs
-            | (t, cs, _) <- ti
+  <> concat [ makeObjectBody (tableName t) : makeRowFilters (tableName t) (tableColumns t)
+            | t <- ti
             ]
 
 makeObjectBody :: Text -> (Text, Param)
@@ -231,8 +245,8 @@ makeRowFilter tn c =
 makeRowFilters :: Text -> [Column] -> [(Text, Param)]
 makeRowFilters tn = fmap (makeRowFilter tn)
 
-makePathItem :: (Table, [Column], [Text]) -> (FilePath, PathItem)
-makePathItem (t, cs, _) = ("/" ++ T.unpack tn, p $ tableInsertable t || tableUpdatable t || tableDeletable t)
+makePathItem :: Table -> (FilePath, PathItem)
+makePathItem t = ("/" ++ T.unpack tn, p $ tableInsertable t || tableUpdatable t || tableDeletable t)
   where
     -- Use first line of table description as summary; rest as description (if present)
     -- We strip leading newlines from description so that users can include a blank line between summary and description
@@ -266,7 +280,7 @@ makePathItem (t, cs, _) = ("/" ++ T.unpack tn, p $ tableInsertable t || tableUpd
     p False = pr
     p True  = pw
     tn = tableName t
-    rs = [ T.intercalate "." ["rowFilter", tn, colName c ] | c <- cs ]
+    rs = [ T.intercalate "." ["rowFilter", tn, colName c ] | c <- tableColumns t ]
     ref = Ref . Reference
 
 makeProcPathItem :: ProcDescription -> (FilePath, PathItem)
@@ -281,7 +295,7 @@ makeProcPathItem pd = ("/rpc/" ++ toS (pdName pd), pe)
       & description .~ mfilter (/="") pDesc
       & parameters .~ makeProcParam pd
       & tags .~ Set.fromList ["(rpc) " <> pdName pd]
-      & produces ?~ makeMimeList [CTApplicationJSON, CTSingularJSON]
+      & produces ?~ makeMimeList [MTApplicationJSON, MTSingularJSON]
       & at 200 ?~ "OK"
     pe = (mempty :: PathItem) & post ?~ postOp
 
@@ -291,15 +305,23 @@ makeRootPathItem = ("/", p)
     getOp = (mempty :: Operation)
       & tags .~ Set.fromList ["Introspection"]
       & summary ?~ "OpenAPI description (this document)"
-      & produces ?~ makeMimeList [CTOpenAPI, CTApplicationJSON]
+      & produces ?~ makeMimeList [MTOpenAPI, MTApplicationJSON]
       & at 200 ?~ "OK"
     pr = (mempty :: PathItem) & get ?~ getOp
     p = pr
 
-makePathItems :: [ProcDescription] -> [(Table, [Column], [Text])] -> InsOrdHashMap FilePath PathItem
+makePathItems :: [ProcDescription] -> [Table] -> InsOrdHashMap FilePath PathItem
 makePathItems pds ti = fromList $ makeRootPathItem :
   fmap makePathItem ti ++ fmap makeProcPathItem pds
 
+makeSecurityDefinitions :: Text -> Bool -> SecurityDefinitions
+makeSecurityDefinitions secName allow
+  | allow = SecurityDefinitions (fromList [(secName, SecurityScheme secSchType secSchDescription)])
+  | otherwise    = mempty
+  where
+    secSchType = SecuritySchemeApiKey (ApiKeyParams "Authorization" ApiKeyHeader)
+    secSchDescription = Just "Add the token prepending \"Bearer \" (without quotes) to it"
+
 escapeHostName :: Text -> Text
 escapeHostName "*"  = "0.0.0.0"
 escapeHostName "*4" = "0.0.0.0"
@@ -308,27 +330,30 @@ escapeHostName "*6" = "0.0.0.0"
 escapeHostName "!6" = "0.0.0.0"
 escapeHostName h    = h
 
-postgrestSpec :: [Relationship] -> [ProcDescription] -> [(Table, [Column], [Text])] -> (Text, Text, Integer, Text) -> Maybe Text -> [PrimaryKey] -> Swagger
-postgrestSpec rels pds ti (s, h, p, b) sd pks = (mempty :: Swagger)
+postgrestSpec :: RelationshipsMap -> [ProcDescription] -> [Table] -> (Text, Text, Integer, Text) -> Maybe Text -> Bool -> Swagger
+postgrestSpec rels pds ti (s, h, p, b) sd allowSecurityDef = (mempty :: Swagger)
   & basePath ?~ T.unpack b
   & schemes ?~ [s']
   & info .~ ((mempty :: Info)
-      & version .~ prettyVersion
+      & version .~ T.decodeUtf8 prettyVersion
       & title .~ "PostgREST API"
       & description ?~ d)
   & externalDocs ?~ ((mempty :: ExternalDocs)
     & description ?~ "PostgREST Documentation"
     & url .~ URL ("https://postgrest.org/en/" <> docsVersion <> "/api.html"))
   & host .~ h'
-  & definitions .~ fromList (makeTableDef rels pks <$> ti)
+  & definitions .~ fromList (makeTableDef rels <$> ti)
   & parameters .~ fromList (makeParamDefs ti)
   & paths .~ makePathItems pds ti
-  & produces .~ makeMimeList [CTApplicationJSON, CTSingularJSON, CTTextCSV]
-  & consumes .~ makeMimeList [CTApplicationJSON, CTSingularJSON, CTTextCSV]
+  & produces .~ makeMimeList [MTApplicationJSON, MTSingularJSON, MTTextCSV]
+  & consumes .~ makeMimeList [MTApplicationJSON, MTSingularJSON, MTTextCSV]
+  & securityDefinitions .~ makeSecurityDefinitions securityDefName allowSecurityDef
+  & security .~ [SecurityRequirement (fromList [(securityDefName, [])]) | allowSecurityDef]
     where
       s' = if s == "http" then Http else Https
       h' = Just $ Host (T.unpack $ escapeHostName h) (Just (fromInteger p))
       d = fromMaybe "This is a dynamic API generated by PostgREST" sd
+      securityDefName = "JWT"
 
 pickProxy :: Maybe Text -> Maybe Proxy
 pickProxy proxy
@@ -366,10 +391,3 @@ proxyUri AppConfig{..} =
       (proxyScheme, proxyHost, proxyPort, proxyPath)
     Nothing ->
       ("http", configServerHost, toInteger configServerPort, "/")
-
-openApiTableInfo :: DbStructure -> Table -> (Table, [Column], [Text])
-openApiTableInfo dbStructure table =
-  ( table
-  , tableCols dbStructure (tableSchema table) (tableName table)
-  , tablePKCols dbStructure (tableSchema table) (tableName table)
-  )

src/PostgREST/Query/QueryBuilder.hs

@@ -1,4 +1,5 @@
 {-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE NamedFieldPuns        #-}
 {-|
 Module      : PostgREST.Query.QueryBuilder
 Description : PostgREST SQL queries generating functions.
@@ -17,68 +18,79 @@ module PostgREST.Query.QueryBuilder
 
 import qualified Data.ByteString.Char8           as BS
 import qualified Data.Set                        as S
-import qualified Hasql.DynamicStatements.Snippet as H
+import qualified Hasql.DynamicStatements.Snippet as SQL
 
 import Data.Tree (Tree (..))
 
-import PostgREST.DbStructure.Identifiers  (FieldName,
-                                           QualifiedIdentifier (..))
-import PostgREST.DbStructure.Proc         (PgArg (..))
+import PostgREST.DbStructure.Identifiers  (QualifiedIdentifier (..))
+import PostgREST.DbStructure.Proc         (ProcParam (..))
 import PostgREST.DbStructure.Relationship (Cardinality (..),
+                                           Junction (..),
                                            Relationship (..))
-import PostgREST.DbStructure.Table        (Table (..))
-import PostgREST.Request.ApiRequest       (PayloadJSON (..))
-import PostgREST.Request.Preferences      (PreferParameters (..),
-                                           PreferResolution (..))
+import PostgREST.Request.Preferences      (PreferResolution (..))
 
 import PostgREST.Query.SqlFragment
+import PostgREST.RangeQuery          (allRange)
+import PostgREST.Request.MutateQuery
+import PostgREST.Request.ReadQuery
 import PostgREST.Request.Types
 
 import Protolude
 
-readRequestToQuery :: ReadRequest -> H.Snippet
-readRequestToQuery (Node (Select colSelects mainQi tblAlias implJoins logicForest joinConditions_ ordts range, _) forest) =
+readRequestToQuery :: ReadRequest -> SQL.Snippet
+readRequestToQuery (Node (Select colSelects mainQi tblAlias logicForest joinConditions_ ordts range, (_, rel, _, _, _, _)) forest) =
   "SELECT " <>
-  intercalateSnippet ", " ((pgFmtSelectItem qi <$> colSelects) ++ selects) <>
-  "FROM " <> H.sql (BS.intercalate ", " (tabl : implJs)) <> " " <>
+  intercalateSnippet ", " ((pgFmtSelectItem qi <$> colSelects) ++ selects) <> " " <>
+  fromFrag <> " " <>
   intercalateSnippet " " joins <> " " <>
-  (if null logicForest && null joinConditions_ then mempty else "WHERE " <> intercalateSnippet " AND " (map (pgFmtLogicTree qi) logicForest ++ map pgFmtJoinCondition joinConditions_))
-  <> " " <>
-  (if null ordts then mempty else "ORDER BY " <> intercalateSnippet ", " (map (pgFmtOrderTerm qi) ordts)) <> " " <>
+  (if null logicForest && null joinConditions_
+    then mempty
+    else "WHERE " <> intercalateSnippet " AND " (map (pgFmtLogicTree qi) logicForest ++ map pgFmtJoinCondition joinConditions_)) <> " " <>
+  orderF qi ordts <> " " <>
   limitOffsetF range
   where
-    implJs = fromQi <$> implJoins
-    tabl = fromQi mainQi <> maybe mempty (\a -> " AS " <> pgFmtIdent a) tblAlias
-    qi = maybe mainQi (QualifiedIdentifier mempty) tblAlias
-    (joins, selects) = foldr getJoinsSelects ([],[]) forest
+    fromFrag = fromF rel mainQi tblAlias
+    qi = getQualifiedIdentifier rel mainQi tblAlias
+    (selects, joins) = foldr getSelectsJoins ([],[]) forest
 
-getJoinsSelects :: ReadRequest -> ([H.Snippet], [H.Snippet]) -> ([H.Snippet], [H.Snippet])
-getJoinsSelects rr@(Node (_, (name, Just Relationship{relCardinality=card,relTable=Table{tableName=table}}, alias, _, _)) _) (j,s) =
-  let subquery = readRequestToQuery rr in
-  case card of
-    M2O _ ->
-      let aliasOrName = fromMaybe name alias
-          localTableName = pgFmtIdent $ table <> "_" <> aliasOrName
-          sel = H.sql ("row_to_json(" <> localTableName <> ".*) AS " <> pgFmtIdent aliasOrName)
-          joi = " LEFT JOIN LATERAL( " <> subquery <> " ) AS " <> H.sql localTableName <> " ON TRUE " in
-      (joi:j,sel:s)
-    _ ->
-      let sel = "COALESCE (("
-             <> "SELECT json_agg(" <> H.sql (pgFmtIdent table) <> ".*) "
-             <> "FROM (" <> subquery <> ") " <> H.sql (pgFmtIdent table) <> " "
-             <> "), '[]') AS " <> H.sql (pgFmtIdent (fromMaybe name alias)) in
-      (j,sel:s)
-getJoinsSelects (Node (_, (_, Nothing, _, _, _)) _) _ = ([], [])
+getSelectsJoins :: ReadRequest -> ([SQL.Snippet], [SQL.Snippet]) -> ([SQL.Snippet], [SQL.Snippet])
+getSelectsJoins (Node (_, (_, Nothing, _, _, _, _)) _) _ = ([], [])
+getSelectsJoins rr@(Node (_, (name, Just rel, alias, _, joinType, _)) _) (selects,joins) =
+  let
+    subquery = readRequestToQuery rr
+    aliasOrName = fromMaybe name alias
+    locTblName = qiName (relTable rel) <> "_" <> aliasOrName
+    localTableName = pgFmtIdent locTblName
+    internalTableName = pgFmtIdent $ "_" <> locTblName
+    correlatedSubquery sub al cond =
+      (if joinType == Just JTInner then "INNER" else "LEFT") <> " JOIN LATERAL ( " <> sub <> " ) AS " <> SQL.sql al <> " ON " <> cond
+    isToOne = case rel of
+      Relationship{relCardinality=M2O _ _} -> True
+      Relationship{relCardinality=O2O _ _} -> True
+      ComputedRelationship{relToOne=True}  -> True
+      _                                    -> False
+    (sel, joi) = if isToOne
+      then
+        ( SQL.sql ("row_to_json(" <> localTableName <> ".*) AS " <> pgFmtIdent aliasOrName)
+        , correlatedSubquery subquery localTableName "TRUE")
+      else
+        ( SQL.sql $ "COALESCE( " <> localTableName <> "." <> internalTableName <> ", '[]') AS " <> pgFmtIdent aliasOrName
+        , correlatedSubquery (
+            "SELECT json_agg(" <> SQL.sql internalTableName <> ") AS " <> SQL.sql internalTableName <>
+            "FROM (" <> subquery <> " ) AS " <> SQL.sql internalTableName
+          ) localTableName $ if joinType == Just JTInner then SQL.sql localTableName <> " IS NOT NULL" else "TRUE")
+  in
+  (sel:selects, joi:joins)
 
-mutateRequestToQuery :: MutateRequest -> H.Snippet
+mutateRequestToQuery :: MutateRequest -> SQL.Snippet
 mutateRequestToQuery (Insert mainQi iCols body onConflct putConditions returnings) =
   "WITH " <> normalizedBody body <> " " <>
-  "INSERT INTO " <> H.sql (fromQi mainQi) <> H.sql (if S.null iCols then " " else "(" <> cols <> ") ") <>
-  "SELECT " <> H.sql cols <> " " <>
-  H.sql ("FROM json_populate_recordset (null::" <> fromQi mainQi <> ", " <> selectBody <> ") _ ") <>
+  "INSERT INTO " <> SQL.sql (fromQi mainQi) <> SQL.sql (if S.null iCols then " " else "(" <> cols <> ") ") <>
+  "SELECT " <> SQL.sql cols <> " " <>
+  SQL.sql ("FROM json_populate_recordset (null::" <> fromQi mainQi <> ", " <> selectBody <> ") _ ") <>
   -- Only used for PUT
   (if null putConditions then mempty else "WHERE " <> intercalateSnippet " AND " (pgFmtLogicTree (QualifiedIdentifier mempty "_") <$> putConditions)) <>
-  H.sql (BS.unwords [
+  SQL.sql (BS.unwords [
     maybe "" (\(oncDo, oncCols) ->
       if null oncCols then
         mempty
@@ -95,61 +107,96 @@ mutateRequestToQuery (Insert mainQi iCols body onConflct putConditions returning
     ])
   where
     cols = BS.intercalate ", " $ pgFmtIdent <$> S.toList iCols
-mutateRequestToQuery (Update mainQi uCols body logicForest returnings) =
-  if S.null uCols
+
+-- An update without a limit is always filtered with a WHERE
+mutateRequestToQuery (Update mainQi uCols body logicForest range ordts returnings)
+  | S.null uCols =
     -- if there are no columns we cannot do UPDATE table SET {empty}, it'd be invalid syntax
     -- selecting an empty resultset from mainQi gives us the column names to prevent errors when using &select=
     -- the select has to be based on "returnings" to make computed overloaded functions not throw
-    then H.sql ("SELECT " <> emptyBodyReturnedColumns <> " FROM " <> fromQi mainQi <> " WHERE false")
-    else
-      "WITH " <> normalizedBody body <> " " <>
-      "UPDATE " <> H.sql (fromQi mainQi) <> " SET " <> H.sql cols <> " " <>
-      "FROM (SELECT * FROM json_populate_recordset (null::" <> H.sql (fromQi mainQi) <> " , " <> H.sql selectBody <> " )) _ " <>
-      (if null logicForest then mempty else "WHERE " <> intercalateSnippet " AND " (pgFmtLogicTree mainQi <$> logicForest)) <> " " <>
-      H.sql (returningF mainQi returnings)
-  where
-    cols = BS.intercalate ", " (pgFmtIdent <> const " = _." <> pgFmtIdent <$> S.toList uCols)
-    emptyBodyReturnedColumns :: SqlFragment
-    emptyBodyReturnedColumns
-      | null returnings = "NULL"
-      | otherwise       = BS.intercalate ", " (pgFmtColumn (QualifiedIdentifier mempty $ qiName mainQi) <$> returnings)
-mutateRequestToQuery (Delete mainQi logicForest returnings) =
-  "DELETE FROM " <> H.sql (fromQi mainQi) <> " " <>
-  (if null logicForest then mempty else "WHERE " <> intercalateSnippet " AND " (map (pgFmtLogicTree mainQi) logicForest)) <> " " <>
-  H.sql (returningF mainQi returnings)
+    SQL.sql $ "SELECT " <> emptyBodyReturnedColumns <> " FROM " <> fromQi mainQi <> " WHERE false"
 
-requestToCallProcQuery :: QualifiedIdentifier -> [PgArg] -> Maybe PayloadJSON -> Bool -> Maybe PreferParameters -> [FieldName] -> H.Snippet
-requestToCallProcQuery qi pgArgs pj returnsScalar preferParams returnings =
-  argsCTE <> sourceBody
-  where
-    body = pjRaw <$> pj
-    paramsAsSingleObject    = preferParams == Just SingleObject
-    paramsAsMultipleObjects = preferParams == Just MultipleObjects
+  | range == allRange =
+    "WITH " <> normalizedBody body <> " " <>
+    "UPDATE " <> mainTbl <> " SET " <> SQL.sql nonRangeCols <> " " <>
+    "FROM (SELECT * FROM json_populate_recordset (null::" <> mainTbl <> " , " <> SQL.sql selectBody <> " )) _ " <>
+    whereLogic <> " " <>
+    SQL.sql (returningF mainQi returnings)
 
-    (argsCTE, args)
-      | null pgArgs = (mempty, mempty)
-      | paramsAsSingleObject = ("WITH pgrst_args AS (SELECT NULL)", jsonPlaceHolder body)
-      | otherwise = (
-          "WITH " <> normalizedBody body <> ", " <>
-          H.sql (
+  | otherwise =
+    "WITH " <> normalizedBody body <> ", " <>
+    "pgrst_update_body AS (SELECT * FROM json_populate_recordset (null::" <> mainTbl <> " , " <> SQL.sql selectBody <> " ) LIMIT 1), " <>
+    "pgrst_affected_rows AS (" <>
+      "SELECT " <> SQL.sql rangeIdF <> " FROM " <> mainTbl <>
+      whereLogic <> " " <>
+      orderF mainQi ordts <> " " <>
+      limitOffsetF range <>
+    ") " <>
+    "UPDATE " <> mainTbl <> " SET " <> SQL.sql rangeCols <>
+    "FROM pgrst_affected_rows " <>
+    "WHERE " <> SQL.sql whereRangeIdF <> " " <>
+    SQL.sql (returningF mainQi returnings)
+
+  where
+    whereLogic = if null logicForest then mempty else " WHERE " <> intercalateSnippet " AND " (pgFmtLogicTree mainQi <$> logicForest)
+    mainTbl = SQL.sql (fromQi mainQi)
+    emptyBodyReturnedColumns = if null returnings then "NULL" else BS.intercalate ", " (pgFmtColumn (QualifiedIdentifier mempty $ qiName mainQi) <$> returnings)
+    nonRangeCols = BS.intercalate ", " (pgFmtIdent <> const " = _." <> pgFmtIdent <$> S.toList uCols)
+    rangeCols = BS.intercalate ", " ((\col -> pgFmtIdent col <> " = (SELECT " <> pgFmtIdent col <> " FROM pgrst_update_body) ") <$> S.toList uCols)
+    (whereRangeIdF, rangeIdF) = mutRangeF mainQi (fst . otTerm <$> ordts)
+
+mutateRequestToQuery (Delete mainQi logicForest range ordts returnings)
+  | range == allRange =
+    "DELETE FROM " <> SQL.sql (fromQi mainQi) <> " " <>
+    whereLogic <> " " <>
+    SQL.sql (returningF mainQi returnings)
+
+  | otherwise =
+    "WITH " <>
+    "pgrst_affected_rows AS (" <>
+      "SELECT " <> SQL.sql rangeIdF <> " FROM " <> SQL.sql (fromQi mainQi) <>
+       whereLogic <> " " <>
+      orderF mainQi ordts <> " " <>
+      limitOffsetF range <>
+    ") " <>
+    "DELETE FROM " <> SQL.sql (fromQi mainQi) <> " " <>
+    "USING pgrst_affected_rows " <>
+    "WHERE " <> SQL.sql whereRangeIdF <> " " <>
+    SQL.sql (returningF mainQi returnings)
+
+  where
+    whereLogic = if null logicForest then mempty else " WHERE " <> intercalateSnippet " AND " (pgFmtLogicTree mainQi <$> logicForest)
+    (whereRangeIdF, rangeIdF) = mutRangeF mainQi (fst . otTerm <$> ordts)
+
+requestToCallProcQuery :: CallRequest -> SQL.Snippet
+requestToCallProcQuery (FunctionCall qi params args returnsScalar multipleCall returnings) =
+  prmsCTE <> argsBody
+  where
+    (prmsCTE, argFrag) = case params of
+      OnePosParam prm -> ("WITH pgrst_args AS (SELECT NULL)", singleParameter args (encodeUtf8 $ ppType prm))
+      KeyParams []    -> (mempty, mempty)
+      KeyParams prms  -> (
+          "WITH " <> normalizedBody args <> ", " <>
+          SQL.sql (
             BS.unwords [
             "pgrst_args AS (",
-              "SELECT * FROM json_to_recordset(" <> selectBody <> ") AS _(" <> fmtArgs (const mempty) (\a -> " " <> encodeUtf8 (pgaType a)) <> ")",
+              "SELECT * FROM json_to_recordset(" <> selectBody <> ") AS _(" <> fmtParams prms (const mempty) (\a -> " " <> encodeUtf8 (ppType a)) <> ")",
             ")"])
-         , H.sql $ if paramsAsMultipleObjects
-             then fmtArgs varadicPrefix (\a -> " := pgrst_args." <> pgFmtIdent (pgaName a))
-             else fmtArgs varadicPrefix (\a -> " := (SELECT " <> pgFmtIdent (pgaName a) <> " FROM pgrst_args LIMIT 1)")
+         , SQL.sql $ if multipleCall
+             then fmtParams prms varadicPrefix (\a -> " := pgrst_args." <> pgFmtIdent (ppName a))
+             else fmtParams prms varadicPrefix (\a -> " := (SELECT " <> pgFmtIdent (ppName a) <> " FROM pgrst_args LIMIT 1)")
         )
 
-    fmtArgs :: (PgArg -> SqlFragment) -> (PgArg -> SqlFragment) -> SqlFragment
-    fmtArgs argFragPre argFragSuf = BS.intercalate ", " ((\a -> argFragPre a <> pgFmtIdent (pgaName a) <> argFragSuf a) <$> pgArgs)
+    fmtParams :: [ProcParam] -> (ProcParam -> SqlFragment) -> (ProcParam -> SqlFragment) -> SqlFragment
+    fmtParams prms prmFragPre prmFragSuf = BS.intercalate ", "
+      ((\a -> prmFragPre a <> pgFmtIdent (ppName a) <> prmFragSuf a) <$> prms)
 
-    varadicPrefix :: PgArg -> SqlFragment
-    varadicPrefix a = if pgaVar a then "VARIADIC " else mempty
+    varadicPrefix :: ProcParam -> SqlFragment
+    varadicPrefix a = if ppVar a then "VARIADIC " else mempty
 
-    sourceBody :: H.Snippet
-    sourceBody
-      | paramsAsMultipleObjects =
+    argsBody :: SQL.Snippet
+    argsBody
+      | multipleCall =
           if returnsScalar
             then "SELECT " <> callIt <> " AS pgrst_scalar FROM pgrst_args"
             else "SELECT pgrst_lat_args.* FROM pgrst_args, " <>
@@ -159,23 +206,60 @@ requestToCallProcQuery qi pgArgs pj returnsScalar preferParams returnings =
             then "SELECT " <> callIt <> " AS pgrst_scalar"
             else "SELECT " <> returnedColumns <> " FROM " <> callIt
 
-    callIt :: H.Snippet
-    callIt = H.sql (fromQi qi) <> "(" <> args <> ")"
+    callIt :: SQL.Snippet
+    callIt = SQL.sql (fromQi qi) <> "(" <> argFrag <> ")"
 
-    returnedColumns :: H.Snippet
+    returnedColumns :: SQL.Snippet
     returnedColumns
       | null returnings = "*"
-      | otherwise       = H.sql $ BS.intercalate ", " (pgFmtColumn (QualifiedIdentifier mempty $ qiName qi) <$> returnings)
+      | otherwise       = SQL.sql $ BS.intercalate ", " (pgFmtColumn (QualifiedIdentifier mempty $ qiName qi) <$> returnings)
 
 
 -- | SQL query meant for COUNTing the root node of the Tree.
 -- It only takes WHERE into account and doesn't include LIMIT/OFFSET because it would reduce the COUNT.
 -- SELECT 1 is done instead of SELECT * to prevent doing expensive operations(like functions based on the columns)
 -- inside the FROM target.
-readRequestToCountQuery :: ReadRequest -> H.Snippet
-readRequestToCountQuery (Node (Select{from=qi, where_=logicForest}, _) _) =
- "SELECT 1 " <> "FROM " <> H.sql (fromQi qi) <> " " <>
- if null logicForest then mempty else "WHERE " <> intercalateSnippet " AND " (map (pgFmtLogicTree qi) logicForest)
+-- If the request contains INNER JOINs, then the COUNT of the root node will change.
+-- For this case, we use a WHERE EXISTS instead of an INNER JOIN on the count query.
+-- See https://github.com/PostgREST/postgrest/issues/2009#issuecomment-977473031
+-- Only for the nodes that have an INNER JOIN linked to the root level.
+readRequestToCountQuery :: ReadRequest -> SQL.Snippet
+readRequestToCountQuery (Node (Select{from=mainQi, fromAlias=tblAlias, where_=logicForest, joinConditions=joinConditions_}, (_, rel, _, _, _, _)) forest) =
+  "SELECT 1 " <> fromFrag <>
+  (if null logicForest && null joinConditions_ && null subQueries
+    then mempty
+    else " WHERE " ) <>
+  intercalateSnippet " AND " (
+    map (pgFmtLogicTree qi) logicForest ++
+    map pgFmtJoinCondition joinConditions_ ++
+    subQueries
+  )
+  where
+    qi = getQualifiedIdentifier rel mainQi tblAlias
+    fromFrag = fromF rel mainQi tblAlias
+    subQueries = foldr existsSubquery [] forest
+    existsSubquery :: ReadRequest -> [SQL.Snippet] -> [SQL.Snippet]
+    existsSubquery readReq@(Node (_, (_, _, _, _, joinType, _)) _) rest =
+      if joinType == Just JTInner
+        then ("EXISTS (" <> readRequestToCountQuery readReq <> " )"):rest
+        else rest
 
-limitedQuery :: H.Snippet -> Maybe Integer -> H.Snippet
-limitedQuery query maxRows = query <> H.sql (maybe mempty (\x -> " LIMIT " <> BS.pack (show x)) maxRows)
+limitedQuery :: SQL.Snippet -> Maybe Integer -> SQL.Snippet
+limitedQuery query maxRows = query <> SQL.sql (maybe mempty (\x -> " LIMIT " <> BS.pack (show x)) maxRows)
+
+-- TODO refactor so this function is uneeded and ComputedRelationship QualifiedIdentifier comes from the ReadQuery type
+getQualifiedIdentifier :: Maybe Relationship -> QualifiedIdentifier -> Maybe Alias -> QualifiedIdentifier
+getQualifiedIdentifier rel mainQi tblAlias = case rel of
+  Just ComputedRelationship{relFunction} -> QualifiedIdentifier mempty $ fromMaybe (qiName relFunction) tblAlias
+  _                                      -> maybe mainQi (QualifiedIdentifier mempty) tblAlias
+
+-- FROM clause plus implicit joins
+fromF :: Maybe Relationship -> QualifiedIdentifier -> Maybe Alias -> SQL.Snippet
+fromF rel mainQi tblAlias = SQL.sql $ "FROM " <>
+  (case rel of
+    Just ComputedRelationship{relFunction,relTable} -> fromQi relFunction <> "(" <> pgFmtIdent (qiName relTable) <> ")"
+    _                                               -> fromQi mainQi) <>
+  maybe mempty (\a -> " AS " <> pgFmtIdent a) tblAlias <>
+  (case rel of
+    Just Relationship{relCardinality=M2M Junction{junTable=jt}} -> ", " <> fromQi jt
+    _                                                           -> mempty)

src/PostgREST/Query/SqlFragment.hs

@@ -11,18 +11,20 @@ module PostgREST.Query.SqlFragment
   , SqlFragment
   , asBinaryF
   , asCsvF
+  , asGeoJsonF
   , asJsonF
   , asJsonSingleF
+  , asXmlF
   , countF
   , fromQi
-  , ftsOperators
-  , jsonPlaceHolder
   , limitOffsetF
   , locationF
+  , mutRangeF
   , normalizedBody
-  , operators
+  , orderF
   , pgFmtColumn
   , pgFmtIdent
+  , pgFmtIdentList
   , pgFmtJoinCondition
   , pgFmtLogicTree
   , pgFmtOrderTerm
@@ -31,36 +33,45 @@ module PostgREST.Query.SqlFragment
   , responseStatusF
   , returningF
   , selectBody
+  , singleParameter
   , sourceCTEName
   , unknownEncoder
   , intercalateSnippet
+  , explainF
   ) where
 
 import qualified Data.ByteString.Char8           as BS
-import qualified Data.ByteString.Lazy            as BL
-import qualified Data.HashMap.Strict             as HM
+import qualified Data.ByteString.Lazy            as LBS
 import qualified Data.Text                       as T
-import qualified Hasql.DynamicStatements.Snippet as H
+import qualified Hasql.DynamicStatements.Snippet as SQL
 import qualified Hasql.Encoders                  as HE
 
 import Data.Foldable                 (foldr1)
 import Text.InterpolatedString.Perl6 (qc)
 
-import PostgREST.Config.PgVersion        (PgVersion, pgVersion96)
 import PostgREST.DbStructure.Identifiers (FieldName,
                                           QualifiedIdentifier (..))
+import PostgREST.MediaType               (MTPlanFormat (..),
+                                          MTPlanOption (..))
 import PostgREST.RangeQuery              (NonnegRange, allRange,
                                           rangeLimit, rangeOffset)
+import PostgREST.Request.ReadQuery       (SelectItem)
 import PostgREST.Request.Types           (Alias, Field, Filter (..),
+                                          FtsOperator (..),
                                           JoinCondition (..),
                                           JsonOperand (..),
                                           JsonOperation (..),
-                                          JsonPath, LogicTree (..),
-                                          OpExpr (..), Operation (..),
-                                          OrderTerm (..), SelectItem)
+                                          JsonPath,
+                                          LogicOperator (..),
+                                          LogicTree (..), OpExpr (..),
+                                          Operation (..),
+                                          OrderDirection (..),
+                                          OrderNulls (..),
+                                          OrderTerm (..),
+                                          SimpleOperator (..),
+                                          TrileanVal (..))
 
-import Protolude      hiding (cast, toS)
-import Protolude.Conv (toS)
+import Protolude hiding (cast)
 
 
 -- | A part of a SQL query that cannot be executed independently
@@ -72,43 +83,43 @@ noLocationF = "array[]::text[]"
 sourceCTEName :: SqlFragment
 sourceCTEName = "pgrst_source"
 
-operators :: HM.HashMap Text SqlFragment
-operators = HM.union (HM.fromList [
-  ("eq", "="),
-  ("gte", ">="),
-  ("gt", ">"),
-  ("lte", "<="),
-  ("lt", "<"),
-  ("neq", "<>"),
-  ("like", "LIKE"),
-  ("ilike", "ILIKE"),
-  ("in", "IN"),
-  ("is", "IS"),
-  ("cs", "@>"),
-  ("cd", "<@"),
-  ("ov", "&&"),
-  ("sl", "<<"),
-  ("sr", ">>"),
-  ("nxr", "&<"),
-  ("nxl", "&>"),
-  ("adj", "-|-")]) ftsOperators
+singleValOperator :: SimpleOperator -> SqlFragment
+singleValOperator = \case
+  OpEqual            -> "="
+  OpGreaterThanEqual -> ">="
+  OpGreaterThan      -> ">"
+  OpLessThanEqual    -> "<="
+  OpLessThan         -> "<"
+  OpNotEqual         -> "<>"
+  OpLike             -> "like"
+  OpILike            -> "ilike"
+  OpContains         -> "@>"
+  OpContained        -> "<@"
+  OpOverlap          -> "&&"
+  OpStrictlyLeft     -> "<<"
+  OpStrictlyRight    -> ">>"
+  OpNotExtendsRight  -> "&<"
+  OpNotExtendsLeft   -> "&>"
+  OpAdjacent         -> "-|-"
+  OpMatch            -> "~"
+  OpIMatch           -> "~*"
 
-ftsOperators :: HM.HashMap Text SqlFragment
-ftsOperators = HM.fromList [
-  ("fts", "@@ to_tsquery"),
-  ("plfts", "@@ plainto_tsquery"),
-  ("phfts", "@@ phraseto_tsquery"),
-  ("wfts", "@@ websearch_to_tsquery")
-  ]
+ftsOperator :: FtsOperator -> SqlFragment
+ftsOperator = \case
+  FilterFts          -> "@@ to_tsquery"
+  FilterFtsPlain     -> "@@ plainto_tsquery"
+  FilterFtsPhrase    -> "@@ phraseto_tsquery"
+  FilterFtsWebsearch -> "@@ websearch_to_tsquery"
 
 -- |
 -- These CTEs convert a json object into a json array, this way we can use json_populate_recordset for all json payloads
 -- Otherwise we'd have to use json_populate_record for json objects and json_populate_recordset for json arrays
 -- We do this in SQL to avoid processing the JSON in application code
-normalizedBody :: Maybe BL.ByteString -> H.Snippet
+-- TODO: At this stage there shouldn't be a Maybe since ApiRequest should ensure that an INSERT/UPDATE has a body
+normalizedBody :: Maybe LBS.ByteString -> SQL.Snippet
 normalizedBody body =
-  "pgrst_payload AS (SELECT " <> jsonPlaceHolder body <> " AS json_data), " <>
-  H.sql (BS.unwords [
+  "pgrst_payload AS (SELECT " <> jsonPlaceHolder <> " AS json_data), " <>
+  SQL.sql (BS.unwords [
     "pgrst_body AS (",
       "SELECT",
         "CASE WHEN json_typeof(json_data) = 'array'",
@@ -116,24 +127,31 @@ normalizedBody body =
           "ELSE json_build_array(json_data)",
         "END AS val",
       "FROM pgrst_payload)"])
+  where
+    jsonPlaceHolder = SQL.encoderAndParam (HE.nullable HE.unknown) (LBS.toStrict <$> body) <> "::json"
 
--- | Equivalent to "$1::json"
--- | TODO: At this stage there shouldn't be a Maybe since ApiRequest should ensure that an INSERT/UPDATE has a body
-jsonPlaceHolder :: Maybe BL.ByteString -> H.Snippet
-jsonPlaceHolder body =
-  H.encoderAndParam (HE.nullable HE.unknown) (toS <$> body) <> "::json"
+singleParameter :: Maybe LBS.ByteString -> ByteString -> SQL.Snippet
+singleParameter body typ =
+  if typ == "bytea"
+    -- TODO: Hasql fails when using HE.unknown with bytea(pg tries to utf8 encode).
+    then SQL.encoderAndParam (HE.nullable HE.bytea) (LBS.toStrict <$> body)
+    else SQL.encoderAndParam (HE.nullable HE.unknown) (LBS.toStrict <$> body) <> "::" <> SQL.sql typ
 
 selectBody :: SqlFragment
 selectBody = "(SELECT val FROM pgrst_body)"
 
-pgFmtLit :: Text -> SqlFragment
-pgFmtLit x =
- let trimmed = trimNullChars x
-     escaped = "'" <> T.replace "'" "''" trimmed <> "'"
-     slashed = T.replace "\\" "\\\\" escaped in
- encodeUtf8 $ if "\\" `T.isInfixOf` escaped
-   then "E" <> slashed
-   else slashed
+-- Here we build the pg array literal, e.g '{"Hebdon, John","Other","Another"}', manually.
+-- This is necessary to pass an "unknown" array and let pg infer the type.
+-- There are backslashes here, but since this value is parametrized and is not a string constant
+-- https://www.postgresql.org/docs/current/sql-syntax-lexical.html#SQL-SYNTAX-STRINGS
+-- we don't need to use the E'string' form for C-style escapes
+-- https://www.postgresql.org/docs/current/sql-syntax-lexical.html#SQL-SYNTAX-STRINGS-ESCAPE
+pgBuildArrayLiteral :: [Text] -> Text
+pgBuildArrayLiteral vals =
+ let trimmed = trimNullChars
+     slashed = T.replace "\\" "\\\\" . trimmed
+     escaped x = "\"" <> T.replace "\"" "\\\"" (slashed x) <> "\"" in
+ "{" <> T.intercalate "," (escaped <$> vals) <> "}"
 
 -- TODO: refactor by following https://github.com/PostgREST/postgrest/pull/1631#issuecomment-711070833
 pgFmtIdent :: Text -> SqlFragment
@@ -142,6 +160,14 @@ pgFmtIdent x = encodeUtf8 $ "\"" <> T.replace "\"" "\"\"" (trimNullChars x) <> "
 trimNullChars :: Text -> Text
 trimNullChars = T.takeWhile (/= '\x0')
 
+-- |
+-- Format a list of identifiers and separate them by commas.
+--
+-- >>> pgFmtIdentList ["schema_1", "schema_2", "SPECIAL \"@/\\#~_-"]
+-- "\"schema_1\", \"schema_2\", \"SPECIAL \"\"@/\\#~_-\""
+pgFmtIdentList :: [Text] -> SqlFragment
+pgFmtIdentList schemas = BS.intercalate ", " $ pgFmtIdent <$> schemas
+
 asCsvF :: SqlFragment
 asCsvF = asCsvHeaderF <> " || '\n' || " <> asCsvBodyF
   where
@@ -161,10 +187,16 @@ asJsonF returnsScalar
   | returnsScalar = "coalesce(json_agg(_postgrest_t.pgrst_scalar), '[]')::character varying"
   | otherwise     = "coalesce(json_agg(_postgrest_t), '[]')::character varying"
 
-asJsonSingleF :: Bool -> SqlFragment --TODO! unsafe when the query actually returns multiple rows, used only on inserting and returning single element
+asJsonSingleF :: Bool -> SqlFragment
 asJsonSingleF returnsScalar
-  | returnsScalar = "coalesce(string_agg(to_json(_postgrest_t.pgrst_scalar)::text, ','), 'null')::character varying"
-  | otherwise     = "coalesce(string_agg(to_json(_postgrest_t)::text, ','), '')::character varying"
+  | returnsScalar = "coalesce((json_agg(_postgrest_t.pgrst_scalar)->0)::text, 'null')"
+  | otherwise     = "coalesce((json_agg(_postgrest_t)->0)::text, 'null')"
+
+asXmlF :: FieldName -> SqlFragment
+asXmlF fieldName = "coalesce(xmlagg(_postgrest_t." <> pgFmtIdent fieldName <> "), '')"
+
+asGeoJsonF ::  SqlFragment
+asGeoJsonF = "json_build_object('type', 'FeatureCollection', 'features', coalesce(json_agg(ST_AsGeoJSON(_postgrest_t)::json), '[]'))"
 
 asBinaryF :: FieldName -> SqlFragment
 asBinaryF fieldName = "coalesce(string_agg(_postgrest_t." <> pgFmtIdent fieldName <> ", ''), '')"
@@ -189,67 +221,80 @@ pgFmtColumn :: QualifiedIdentifier -> Text -> SqlFragment
 pgFmtColumn table "*" = fromQi table <> ".*"
 pgFmtColumn table c   = fromQi table <> "." <> pgFmtIdent c
 
-pgFmtField :: QualifiedIdentifier -> Field -> H.Snippet
-pgFmtField table (c, jp) = H.sql (pgFmtColumn table c) <> pgFmtJsonPath jp
+pgFmtField :: QualifiedIdentifier -> Field -> SQL.Snippet
+pgFmtField table (c, []) = SQL.sql (pgFmtColumn table c)
+-- Using to_jsonb instead of to_json to avoid missing operator errors when filtering:
+-- "operator does not exist: json = unknown"
+pgFmtField table (c, jp) = SQL.sql ("to_jsonb(" <> pgFmtColumn table c <> ")") <> pgFmtJsonPath jp
 
-pgFmtSelectItem :: QualifiedIdentifier -> SelectItem -> H.Snippet
-pgFmtSelectItem table (f@(fName, jp), Nothing, alias, _) = pgFmtField table f <> H.sql (pgFmtAs fName jp alias)
+pgFmtSelectItem :: QualifiedIdentifier -> SelectItem -> SQL.Snippet
+pgFmtSelectItem table (f@(fName, jp), Nothing, alias, _, _) = pgFmtField table f <> SQL.sql (pgFmtAs fName jp alias)
 -- Ideally we'd quote the cast with "pgFmtIdent cast". However, that would invalidate common casts such as "int", "bigint", etc.
 -- Try doing: `select 1::"bigint"` - it'll err, using "int8" will work though. There's some parser magic that pg does that's invalidated when quoting.
 -- Not quoting should be fine, we validate the input on Parsers.
-pgFmtSelectItem table (f@(fName, jp), Just cast, alias, _) = "CAST (" <> pgFmtField table f <> " AS " <> H.sql (encodeUtf8 cast) <> " )" <> H.sql (pgFmtAs fName jp alias)
+pgFmtSelectItem table (f@(fName, jp), Just cast, alias, _, _) = "CAST (" <> pgFmtField table f <> " AS " <> SQL.sql (encodeUtf8 cast) <> " )" <> SQL.sql (pgFmtAs fName jp alias)
 
-pgFmtOrderTerm :: QualifiedIdentifier -> OrderTerm -> H.Snippet
+pgFmtOrderTerm :: QualifiedIdentifier -> OrderTerm -> SQL.Snippet
 pgFmtOrderTerm qi ot =
   pgFmtField qi (otTerm ot) <> " " <>
-  H.sql (BS.unwords [
-    BS.pack $ maybe mempty show $ otDirection ot,
-    BS.pack $ maybe mempty show $ otNullOrder ot])
+  SQL.sql (BS.unwords [
+    maybe mempty direction $ otDirection ot,
+    maybe mempty nullOrder $ otNullOrder ot])
+  where
+    direction OrderAsc  = "ASC"
+    direction OrderDesc = "DESC"
 
-pgFmtFilter :: QualifiedIdentifier -> Filter -> H.Snippet
+    nullOrder OrderNullsFirst = "NULLS FIRST"
+    nullOrder OrderNullsLast  = "NULLS LAST"
+
+
+pgFmtFilter :: QualifiedIdentifier -> Filter -> SQL.Snippet
 pgFmtFilter table (Filter fld (OpExpr hasNot oper)) = notOp <> " " <> case oper of
    Op op val  -> pgFmtFieldOp op <> " " <> case op of
-     "like"  -> unknownLiteral (T.map star val)
-     "ilike" -> unknownLiteral (T.map star val)
-     "is"    -> isAllowed val
+     OpLike  -> unknownLiteral (T.map star val)
+     OpILike -> unknownLiteral (T.map star val)
      _       -> unknownLiteral val
 
+   -- IS cannot be prepared. `PREPARE boolplan AS SELECT * FROM projects where id IS $1` will give a syntax error.
+   -- The above can be fixed by using `PREPARE boolplan AS SELECT * FROM projects where id IS NOT DISTINCT FROM $1;`
+   -- However that would not accept the TRUE/FALSE/NULL/UNKNOWN keywords. See: https://stackoverflow.com/questions/6133525/proper-way-to-set-preparedstatement-parameter-to-null-under-postgres.
+   -- This is why `IS` operands are whitelisted at the Parsers.hs level
+   Is triVal -> pgFmtField table fld <> " IS " <> case triVal of
+     TriTrue    -> "TRUE"
+     TriFalse   -> "FALSE"
+     TriNull    -> "NULL"
+     TriUnknown -> "UNKNOWN"
+
    -- We don't use "IN", we use "= ANY". IN has the following disadvantages:
    -- + No way to use an empty value on IN: "col IN ()" is invalid syntax. With ANY we can do "= ANY('{}')"
    -- + Can invalidate prepared statements: multiple parameters on an IN($1, $2, $3) will lead to using different prepared statements and not take advantage of caching.
-   In vals -> pgFmtField table fld <> " " <>
-    case vals of
+   In vals -> pgFmtField table fld <> " " <> case vals of
       [""] -> "= ANY('{}') "
-      -- Here we build the pg array, e.g '{"Hebdon, John","Other","Another"}', manually. We quote the values to prevent the "," being treated as an element separator.
-      -- TODO: Ideally this would be done on Hasql with an encoder, but the "array unknown" is not working(Hasql doesn't pass any value).
-      _    -> "= ANY (" <> unknownLiteral ("{" <> T.intercalate "," ((\x -> "\"" <> x <> "\"") <$> vals) <> "}") <> ")"
+      _    -> "= ANY (" <> unknownLiteral (pgBuildArrayLiteral vals) <> ") "
 
    Fts op lang val ->
-     pgFmtFieldOp op <> "(" <> ftsLang lang <> unknownLiteral val <> ") "
+     pgFmtFieldFts op <> "(" <> ftsLang lang <> unknownLiteral val <> ") "
  where
    ftsLang = maybe mempty (\l -> unknownLiteral l <> ", ")
-   pgFmtFieldOp op = pgFmtField table fld <> " " <> sqlOperator op
-   sqlOperator o = H.sql $ HM.lookupDefault "=" o operators
+   pgFmtFieldOp op = pgFmtField table fld <> " " <> SQL.sql (singleValOperator op)
+   pgFmtFieldFts op = pgFmtField table fld <> " " <> SQL.sql (ftsOperator op)
    notOp = if hasNot then "NOT" else mempty
    star c = if c == '*' then '%' else c
-   -- IS cannot be prepared. `PREPARE boolplan AS SELECT * FROM projects where id IS $1` will give a syntax error.
-   -- The above can be fixed by using `PREPARE boolplan AS SELECT * FROM projects where id IS NOT DISTINCT FROM $1;`
-   -- However that would not accept the TRUE/FALSE/NULL keywords. See: https://stackoverflow.com/questions/6133525/proper-way-to-set-preparedstatement-parameter-to-null-under-postgres.
-   isAllowed :: Text -> H.Snippet
-   isAllowed v = H.sql $ maybe
-     (pgFmtLit v <> "::unknown") encodeUtf8
-     (find ((==) . T.toLower $ v) ["null","true","false"])
 
-pgFmtJoinCondition :: JoinCondition -> H.Snippet
+pgFmtJoinCondition :: JoinCondition -> SQL.Snippet
 pgFmtJoinCondition (JoinCondition (qi1, col1) (qi2, col2)) =
-  H.sql $ pgFmtColumn qi1 col1 <> " = " <> pgFmtColumn qi2 col2
+  SQL.sql $ pgFmtColumn qi1 col1 <> " = " <> pgFmtColumn qi2 col2
 
-pgFmtLogicTree :: QualifiedIdentifier -> LogicTree -> H.Snippet
-pgFmtLogicTree qi (Expr hasNot op forest) = H.sql notOp <> " (" <> intercalateSnippet (" " <> BS.pack (show op) <> " ") (pgFmtLogicTree qi <$> forest) <> ")"
-  where notOp =  if hasNot then "NOT" else mempty
+pgFmtLogicTree :: QualifiedIdentifier -> LogicTree -> SQL.Snippet
+pgFmtLogicTree qi (Expr hasNot op forest) = SQL.sql notOp <> " (" <> intercalateSnippet (opSql op) (pgFmtLogicTree qi <$> forest) <> ")"
+  where
+    notOp =  if hasNot then "NOT" else mempty
+
+    opSql And = " AND "
+    opSql Or  = " OR "
 pgFmtLogicTree qi (Stmnt flt) = pgFmtFilter qi flt
 
-pgFmtJsonPath :: JsonPath -> H.Snippet
+pgFmtJsonPath :: JsonPath -> SQL.Snippet
 pgFmtJsonPath = \case
   []             -> mempty
   (JArrow x:xs)  -> "->" <> pgFmtJsonOperand x <> pgFmtJsonPath xs
@@ -270,7 +315,7 @@ pgFmtAs fName jp Nothing = case jOp <$> lastMay jp of
   Nothing -> mempty
 pgFmtAs _ _ (Just alias) = " AS " <> pgFmtIdent alias
 
-countF :: H.Snippet -> Bool -> (H.Snippet, SqlFragment)
+countF :: SQL.Snippet -> Bool -> (SQL.Snippet, SqlFragment)
 countF countQuery shouldCount =
   if shouldCount
     then (
@@ -286,37 +331,58 @@ returningF qi returnings =
     then "RETURNING 1" -- For mutation cases where there's no ?select, we return 1 to know how many rows were modified
     else "RETURNING " <> BS.intercalate ", " (pgFmtColumn qi <$> returnings)
 
-limitOffsetF :: NonnegRange -> H.Snippet
+limitOffsetF :: NonnegRange -> SQL.Snippet
 limitOffsetF range =
   if range == allRange then mempty else "LIMIT " <> limit <> " OFFSET " <> offset
   where
     limit = maybe "ALL" (\l -> unknownEncoder (BS.pack $ show l)) $ rangeLimit range
     offset = unknownEncoder (BS.pack . show $ rangeOffset range)
 
-responseHeadersF :: PgVersion -> SqlFragment
-responseHeadersF pgVer =
-  if pgVer >= pgVersion96
-    then currentSettingF "response.headers"
-    else "null"
+responseHeadersF :: SqlFragment
+responseHeadersF = currentSettingF "response.headers"
 
-responseStatusF :: PgVersion -> SqlFragment
-responseStatusF pgVer =
-  if pgVer >= pgVersion96
-    then currentSettingF "response.status"
-    else "null"
+responseStatusF :: SqlFragment
+responseStatusF = currentSettingF "response.status"
 
-currentSettingF :: Text -> SqlFragment
+currentSettingF :: SqlFragment -> SqlFragment
 currentSettingF setting =
   -- nullif is used because of https://gist.github.com/steve-chavez/8d7033ea5655096903f3b52f8ed09a15
-  "nullif(current_setting(" <> pgFmtLit setting <> ", true), '')"
+  "nullif(current_setting('" <> setting <> "', true), '')"
+
+mutRangeF :: QualifiedIdentifier -> [FieldName] -> (SqlFragment, SqlFragment)
+mutRangeF mainQi rangeId =
+  (
+    BS.intercalate " AND " $ (\col -> pgFmtColumn mainQi col <> " = " <> pgFmtColumn (QualifiedIdentifier mempty "pgrst_affected_rows") col) <$> rangeId
+  , BS.intercalate ", " (pgFmtColumn mainQi <$> rangeId)
+  )
+
+orderF :: QualifiedIdentifier -> [OrderTerm] -> SQL.Snippet
+orderF _ []    = mempty
+orderF qi ordts = "ORDER BY " <> intercalateSnippet ", " (pgFmtOrderTerm qi <$> ordts)
 
 -- Hasql Snippet utilities
-unknownEncoder :: ByteString -> H.Snippet
-unknownEncoder = H.encoderAndParam (HE.nonNullable HE.unknown)
+unknownEncoder :: ByteString -> SQL.Snippet
+unknownEncoder = SQL.encoderAndParam (HE.nonNullable HE.unknown)
 
-unknownLiteral :: Text -> H.Snippet
+unknownLiteral :: Text -> SQL.Snippet
 unknownLiteral = unknownEncoder . encodeUtf8
 
-intercalateSnippet :: ByteString -> [H.Snippet] -> H.Snippet
+intercalateSnippet :: ByteString -> [SQL.Snippet] -> SQL.Snippet
 intercalateSnippet _ [] = mempty
-intercalateSnippet frag snippets = foldr1 (\a b -> a <> H.sql frag <> b) snippets
+intercalateSnippet frag snippets = foldr1 (\a b -> a <> SQL.sql frag <> b) snippets
+
+explainF :: MTPlanFormat -> [MTPlanOption] -> SQL.Snippet -> SQL.Snippet
+explainF fmt opts snip =
+  "EXPLAIN (" <>
+    SQL.sql (BS.intercalate ", " (fmtPlanFmt fmt : (fmtPlanOpt <$> opts))) <>
+  ") " <> snip
+  where
+    fmtPlanOpt :: MTPlanOption -> BS.ByteString
+    fmtPlanOpt PlanAnalyze  = "ANALYZE"
+    fmtPlanOpt PlanVerbose  = "VERBOSE"
+    fmtPlanOpt PlanSettings = "SETTINGS"
+    fmtPlanOpt PlanBuffers  = "BUFFERS"
+    fmtPlanOpt PlanWAL      = "WAL"
+
+    fmtPlanFmt PlanJSON = "FORMAT JSON"
+    fmtPlanFmt PlanText = "FORMAT TEXT"

src/PostgREST/Query/Statements.hs

@@ -6,67 +6,82 @@ This module constructs single SQL statements that can be parametrized and prepar
 
 - It consumes the SqlQuery types generated by the QueryBuilder module.
 - It generates the body format and some headers of the final HTTP response.
-
-TODO: Currently, createReadStatement is not using prepared statements. See https://github.com/PostgREST/postgrest/issues/718.
 -}
 module PostgREST.Query.Statements
-  ( createWriteStatement
-  , createReadStatement
-  , callProcStatement
-  , createExplainStatement
+  ( prepareWrite
+  , prepareRead
+  , prepareCall
+  , preparePlanRows
+  , ResultSet (..)
   ) where
 
 import qualified Data.Aeson                        as JSON
 import qualified Data.Aeson.Lens                   as L
 import qualified Data.ByteString.Char8             as BS
+import qualified Data.ByteString.Lazy              as LBS
 import qualified Hasql.Decoders                    as HD
-import qualified Hasql.DynamicStatements.Snippet   as H
-import qualified Hasql.DynamicStatements.Statement as H
-import qualified Hasql.Statement                   as H
+import qualified Hasql.DynamicStatements.Snippet   as SQL
+import qualified Hasql.DynamicStatements.Statement as SQL
+import qualified Hasql.Statement                   as SQL
 
 import Control.Lens              ((^?))
 import Data.Maybe                (fromJust)
 import Data.Text.Read            (decimal)
 import Network.HTTP.Types.Status (Status)
 
-import PostgREST.Config.PgVersion (PgVersion)
-import PostgREST.Error            (Error (..))
-import PostgREST.GucHeader        (GucHeader)
+import PostgREST.Error     (Error (..))
+import PostgREST.GucHeader (GucHeader)
 
 import PostgREST.DbStructure.Identifiers (FieldName)
+import PostgREST.MediaType               (MTPlanAttrs (..),
+                                          MTPlanFormat (..),
+                                          MediaType (..),
+                                          getMediaType)
 import PostgREST.Query.SqlFragment
 import PostgREST.Request.Preferences
 
-import Protolude      hiding (toS)
-import Protolude.Conv (toS)
+import Protolude
 
-{-| The generic query result format used by API responses. The location header
-    is represented as a list of strings containing variable bindings like
-    @"k1=eq.42"@, or the empty list if there is no location header.
--}
-type ResultsWithCount = (Maybe Int64, Int64, [BS.ByteString], BS.ByteString, Either Error [GucHeader], Either Error (Maybe Status))
+-- | Standard result set format used for all queries
+data ResultSet
+  = RSStandard
+  { rsTableTotal :: Maybe Int64
+  -- ^ count of all the table rows
+  , rsQueryTotal :: Int64
+  -- ^ count of the query rows
+  , rsLocation   :: [(BS.ByteString, BS.ByteString)]
+  -- ^ The Location header(only used for inserts) is represented as a list of strings containing
+  -- variable bindings like @"k1=eq.42"@, or the empty list if there is no location header.
+  , rsBody       :: BS.ByteString
+  -- ^ the aggregated body of the query
+  , rsGucHeaders :: Either Error [GucHeader]
+  -- ^ the HTTP headers to be added to the response
+  , rsGucStatus  :: Either Error (Maybe Status)
+  -- ^ the HTTP status to be added to the response
+  }
+  | RSPlan BS.ByteString -- ^ the plan of the query
 
-createWriteStatement :: H.Snippet -> H.Snippet -> Bool -> Bool -> Bool ->
-                        PreferRepresentation -> [Text] -> PgVersion -> Bool ->
-                        H.Statement () ResultsWithCount
-createWriteStatement selectQuery mutateQuery wantSingle isInsert asCsv rep pKeys pgVer =
-  H.dynamicallyParameterized snippet decodeStandard
+
+prepareWrite :: SQL.Snippet -> SQL.Snippet -> Bool -> MediaType ->
+                PreferRepresentation -> [Text] -> Bool -> SQL.Statement () ResultSet
+prepareWrite selectQuery mutateQuery isInsert mt rep pKeys =
+  SQL.dynamicallyParameterized (mtSnippet mt snippet) decodeIt
  where
   snippet =
-    "WITH " <> H.sql sourceCTEName <> " AS (" <> mutateQuery <> ") " <>
-    H.sql (
+    "WITH " <> SQL.sql sourceCTEName <> " AS (" <> mutateQuery <> ") " <>
+    SQL.sql (
     "SELECT " <>
       "'' AS total_result_set, " <>
       "pg_catalog.count(_postgrest_t) AS page_total, " <>
       locF <> " AS header, " <>
       bodyF <> " AS body, " <>
-      responseHeadersF pgVer <> " AS response_headers, " <>
-      responseStatusF pgVer  <> " AS response_status "
+      responseHeadersF <> " AS response_headers, " <>
+      responseStatusF  <> " AS response_status "
     ) <>
     "FROM (" <> selectF <> ") _postgrest_t"
 
   locF =
-    if isInsert && rep `elem` [Full, HeadersOnly]
+    if isInsert && rep == HeadersOnly
       then BS.unwords [
         "CASE WHEN pg_catalog.count(_postgrest_t) = 1",
           "THEN coalesce(" <> locationF pKeys <> ", " <> noLocationF <> ")",
@@ -75,121 +90,120 @@ createWriteStatement selectQuery mutateQuery wantSingle isInsert asCsv rep pKeys
       else noLocationF
 
   bodyF
-    | rep `elem` [None, HeadersOnly] = "''"
-    | asCsv = asCsvF
-    | wantSingle = asJsonSingleF False
-    | otherwise = asJsonF False
+    | rep /= Full                       = "''"
+    | getMediaType mt == MTTextCSV      = asCsvF
+    | getMediaType mt == MTGeoJSON      = asGeoJsonF
+    | getMediaType mt == MTSingularJSON = asJsonSingleF False
+    | otherwise                         = asJsonF False
 
   selectF
     -- prevent using any of the column names in ?select= when no response is returned from the CTE
-    | rep `elem` [None, HeadersOnly] = H.sql ("SELECT * FROM " <> sourceCTEName)
-    | otherwise                      = selectQuery
+    | rep /= Full = SQL.sql ("SELECT * FROM " <> sourceCTEName)
+    | otherwise   = selectQuery
 
-  decodeStandard :: HD.Result ResultsWithCount
-  decodeStandard =
-   fromMaybe (Nothing, 0, [], mempty, Right [], Right Nothing) <$> HD.rowMaybe standardRow
+  decodeIt :: HD.Result ResultSet
+  decodeIt = case mt of
+    MTPlan{} -> planRow
+    _        -> fromMaybe (RSStandard Nothing 0 mempty mempty (Right []) (Right Nothing)) <$> HD.rowMaybe (standardRow False)
 
-createReadStatement :: H.Snippet -> H.Snippet -> Bool -> Bool -> Bool -> Maybe FieldName -> PgVersion -> Bool ->
-                       H.Statement () ResultsWithCount
-createReadStatement selectQuery countQuery isSingle countTotal asCsv binaryField pgVer =
-  H.dynamicallyParameterized snippet decodeStandard
+prepareRead :: SQL.Snippet -> SQL.Snippet -> Bool -> MediaType -> Maybe FieldName -> Bool -> SQL.Statement () ResultSet
+prepareRead selectQuery countQuery countTotal mt binaryField =
+  SQL.dynamicallyParameterized (mtSnippet mt snippet) decodeIt
  where
   snippet =
     "WITH " <>
-    H.sql sourceCTEName <> " AS ( " <> selectQuery <> " ) " <>
+    SQL.sql sourceCTEName <> " AS ( " <> selectQuery <> " ) " <>
     countCTEF <> " " <>
-    H.sql ("SELECT " <>
+    SQL.sql ("SELECT " <>
       countResultF <> " AS total_result_set, " <>
       "pg_catalog.count(_postgrest_t) AS page_total, " <>
-      noLocationF <> " AS header, " <>
       bodyF <> " AS body, " <>
-      responseHeadersF pgVer <> " AS response_headers, " <>
-      responseStatusF pgVer <> " AS response_status " <>
+      responseHeadersF <> " AS response_headers, " <>
+      responseStatusF <> " AS response_status " <>
     "FROM ( SELECT * FROM " <> sourceCTEName <> " ) _postgrest_t")
 
   (countCTEF, countResultF) = countF countQuery countTotal
 
   bodyF
-    | asCsv = asCsvF
-    | isSingle = asJsonSingleF False
-    | isJust binaryField = asBinaryF $ fromJust binaryField
-    | otherwise = asJsonF False
+    | getMediaType mt == MTTextCSV                       = asCsvF
+    | getMediaType mt == MTSingularJSON                  = asJsonSingleF False
+    | getMediaType mt == MTGeoJSON                       = asGeoJsonF
+    | isJust binaryField && getMediaType mt == MTTextXML = asXmlF $ fromJust binaryField
+    | isJust binaryField                                 = asBinaryF $ fromJust binaryField
+    | otherwise                                          = asJsonF False
 
-  decodeStandard :: HD.Result ResultsWithCount
-  decodeStandard =
-    HD.singleRow standardRow
+  decodeIt :: HD.Result ResultSet
+  decodeIt = case mt of
+    MTPlan{} -> planRow
+    _        -> HD.singleRow $ standardRow True
 
-{-| Read and Write api requests use a similar response format which includes
-    various record counts and possible location header. This is the decoder
-    for that common type of query.
--}
-standardRow :: HD.Row ResultsWithCount
-standardRow = (,,,,,) <$> nullableColumn HD.int8 <*> column HD.int8
-                      <*> arrayColumn HD.bytea <*> column HD.bytea
-                      <*> (fromMaybe (Right []) <$> nullableColumn decodeGucHeaders)
-                      <*> (fromMaybe (Right Nothing) <$> nullableColumn decodeGucStatus)
-
-type ProcResults = (Maybe Int64, Int64, ByteString, Either Error [GucHeader], Either Error (Maybe Status))
-
-callProcStatement :: Bool -> Bool -> H.Snippet -> H.Snippet -> H.Snippet -> Bool ->
-                     Bool -> Bool -> Bool -> Maybe FieldName -> PgVersion -> Bool ->
-                     H.Statement () ProcResults
-callProcStatement returnsScalar returnsSingle callProcQuery selectQuery countQuery countTotal asSingle asCsv multObjects binaryField pgVer =
-  H.dynamicallyParameterized snippet decodeProc
+prepareCall :: Bool -> Bool -> SQL.Snippet -> SQL.Snippet -> SQL.Snippet -> Bool ->
+               MediaType -> Bool -> Maybe FieldName -> Bool ->
+               SQL.Statement () ResultSet
+prepareCall returnsScalar returnsSingle callProcQuery selectQuery countQuery countTotal mt multObjects binaryField =
+  SQL.dynamicallyParameterized (mtSnippet mt snippet) decodeIt
   where
     snippet =
-      "WITH " <> H.sql sourceCTEName <> " AS (" <> callProcQuery <> ") " <>
+      "WITH " <> SQL.sql sourceCTEName <> " AS (" <> callProcQuery <> ") " <>
       countCTEF <>
-      H.sql (
+      SQL.sql (
       "SELECT " <>
         countResultF <> " AS total_result_set, " <>
         "pg_catalog.count(_postgrest_t) AS page_total, " <>
         bodyF <> " AS body, " <>
-        responseHeadersF pgVer <> " AS response_headers, " <>
-        responseStatusF pgVer <> " AS response_status ") <>
+        responseHeadersF <> " AS response_headers, " <>
+        responseStatusF <> " AS response_status ") <>
       "FROM (" <> selectQuery <> ") _postgrest_t"
 
     (countCTEF, countResultF) = countF countQuery countTotal
 
     bodyF
-     | asSingle           = asJsonSingleF returnsScalar
-     | asCsv              = asCsvF
-     | isJust binaryField = asBinaryF $ fromJust binaryField
-     | returnsSingle
-       && not multObjects = asJsonSingleF returnsScalar
-     | otherwise          = asJsonF returnsScalar
+     | getMediaType mt == MTSingularJSON                  = asJsonSingleF returnsScalar
+     | getMediaType mt == MTTextCSV                       = asCsvF
+     | getMediaType mt == MTGeoJSON                       = asGeoJsonF
+     | isJust binaryField && getMediaType mt == MTTextXML = asXmlF $ fromJust binaryField
+     | isJust binaryField                                 = asBinaryF $ fromJust binaryField
+     | returnsSingle && not multObjects                   = asJsonSingleF returnsScalar
+     | otherwise                                          = asJsonF returnsScalar
 
-    decodeProc :: HD.Result ProcResults
-    decodeProc =
-      fromMaybe (Just 0, 0, mempty, defGucHeaders, defGucStatus) <$> HD.rowMaybe procRow
-      where
-        defGucHeaders = Right []
-        defGucStatus  = Right Nothing
-        procRow = (,,,,) <$> nullableColumn HD.int8 <*> column HD.int8
-                         <*> column HD.bytea
-                         <*> (fromMaybe defGucHeaders <$> nullableColumn decodeGucHeaders)
-                         <*> (fromMaybe defGucStatus <$> nullableColumn decodeGucStatus)
+    decodeIt :: HD.Result ResultSet
+    decodeIt = case mt of
+      MTPlan{} -> planRow
+      _        -> fromMaybe (RSStandard (Just 0) 0 mempty mempty (Right []) (Right Nothing)) <$> HD.rowMaybe (standardRow True)
 
-createExplainStatement :: H.Snippet -> Bool -> H.Statement () (Maybe Int64)
-createExplainStatement countQuery =
-  H.dynamicallyParameterized snippet decodeExplain
+preparePlanRows :: SQL.Snippet -> Bool -> SQL.Statement () (Maybe Int64)
+preparePlanRows countQuery =
+  SQL.dynamicallyParameterized snippet decodeIt
   where
-    snippet = "EXPLAIN (FORMAT JSON) " <> countQuery
-    -- |
-    -- An `EXPLAIN (FORMAT JSON) select * from items;` output looks like this:
-    -- [{
-    --   "Plan": {
-    --     "Node Type": "Seq Scan", "Parallel Aware": false, "Relation Name": "items",
-    --     "Alias": "items", "Startup Cost": 0.00, "Total Cost": 32.60,
-    --     "Plan Rows": 2260,"Plan Width": 8} }]
-    -- We only obtain the Plan Rows here.
-    decodeExplain :: HD.Result (Maybe Int64)
-    decodeExplain =
+    snippet = explainF PlanJSON mempty countQuery
+    decodeIt :: HD.Result (Maybe Int64)
+    decodeIt =
       let row = HD.singleRow $ column HD.bytea in
       (^? L.nth 0 . L.key "Plan" .  L.key "Plan Rows" . L._Integral) <$> row
 
+standardRow :: Bool -> HD.Row ResultSet
+standardRow noLocation =
+  RSStandard <$> nullableColumn HD.int8 <*> column HD.int8
+             <*> (if noLocation then pure mempty else fmap splitKeyValue <$> arrayColumn HD.bytea) <*> column HD.bytea
+             <*> (fromMaybe (Right []) <$> nullableColumn decodeGucHeaders)
+             <*> (fromMaybe (Right Nothing) <$> nullableColumn decodeGucStatus)
+  where
+    splitKeyValue :: ByteString -> (ByteString, ByteString)
+    splitKeyValue kv =
+      let (k, v) = BS.break (== '=') kv in
+      (k, BS.tail v)
+
+mtSnippet :: MediaType -> SQL.Snippet -> SQL.Snippet
+mtSnippet mediaType snippet = case mediaType of
+  MTPlan (MTPlanAttrs _ fmt opts) -> explainF fmt opts snippet
+  _                               -> snippet
+
+-- | We use rowList because when doing EXPLAIN (FORMAT TEXT), the result comes as many rows. FORMAT JSON comes as one.
+planRow :: HD.Result ResultSet
+planRow = RSPlan . BS.unlines <$> HD.rowList (column HD.bytea)
+
 decodeGucHeaders :: HD.Value (Either Error [GucHeader])
-decodeGucHeaders = first (const GucHeadersError) . JSON.eitherDecode . toS <$> HD.bytea
+decodeGucHeaders = first (const GucHeadersError) . JSON.eitherDecode . LBS.fromStrict <$> HD.bytea
 
 decodeGucStatus :: HD.Value (Either Error (Maybe Status))
 decodeGucStatus = first (const GucStatusError) . fmap (Just . toEnum . fst) . decimal <$> HD.text

src/PostgREST/RangeQuery.hs

@@ -10,6 +10,8 @@ module PostgREST.RangeQuery (
 , restrictRange
 , rangeGeq
 , allRange
+, limitZeroRange
+, hasLimitZero
 , NonnegRange
 , rangeStatusHeader
 , contentRangeH
@@ -26,8 +28,7 @@ import Data.Ranged.Ranges
 import Network.HTTP.Types.Header
 import Network.HTTP.Types.Status
 
-import Protolude      hiding (toS)
-import Protolude.Conv (toS)
+import Protolude
 
 type NonnegRange = Range Integer
 
@@ -35,13 +36,14 @@ rangeParse :: BS.ByteString -> NonnegRange
 rangeParse range = do
   let rangeRegex = "^([0-9]+)-([0-9]*)$" :: BS.ByteString
 
-  case listToMaybe (range =~ rangeRegex :: [[BS.ByteString]]) of
-    Just parsedRange ->
-      let [_, mLower, mUpper] = readMaybe . toS <$> parsedRange
-          lower         = maybe emptyRange rangeGeq mLower
-          upper         = maybe allRange rangeLeq mUpper in
+  case range =~ rangeRegex :: [[BS.ByteString]] of
+    [[_, l, u]] ->
+      let lower  = maybe emptyRange rangeGeq (readInteger l)
+          upper  = maybe allRange rangeLeq (readInteger u) in
       rangeIntersection lower upper
-    Nothing -> allRange
+    _ -> allRange
+  where
+    readInteger = readMaybe . BS.unpack
 
 rangeRequested :: RequestHeaders -> NonnegRange
 rangeRequested headers = maybe allRange rangeParse $ lookup hRange headers
@@ -75,6 +77,15 @@ rangeLeq :: Integer -> NonnegRange
 rangeLeq n =
   Range BoundaryBelowAll (BoundaryAbove n)
 
+-- Special case to allow limit 0 queries
+-- https://github.com/PostgREST/postgrest/issues/1121
+-- 0 <= x <= -1
+limitZeroRange :: Range Integer
+limitZeroRange = Range (BoundaryBelow 0) (BoundaryAbove (-1))
+
+hasLimitZero :: Range Integer -> Bool
+hasLimitZero r = rangeUpper r == rangeUpper limitZeroRange
+
 rangeStatusHeader :: NonnegRange -> Int64 -> Maybe Int64 -> (Status, Header)
 rangeStatusHeader topLevelRange queryTotal tableTotal =
   let lower = rangeOffset topLevelRange

src/PostgREST/Request/ApiRequest.hs

@@ -3,113 +3,115 @@ Module      : PostgREST.Request.ApiRequest
 Description : PostgREST functions to translate HTTP request to a domain type called ApiRequest.
 -}
 {-# LANGUAGE LambdaCase      #-}
-{-# LANGUAGE MultiWayIf      #-}
 {-# LANGUAGE NamedFieldPuns  #-}
 {-# LANGUAGE RecordWildCards #-}
 
 module PostgREST.Request.ApiRequest
   ( ApiRequest(..)
   , InvokeMethod(..)
-  , ContentType(..)
+  , Mutation(..)
+  , MediaType(..)
   , Action(..)
   , Target(..)
-  , PayloadJSON(..)
+  , Payload(..)
   , userApiRequest
   ) where
 
-import qualified Data.Aeson           as JSON
-import qualified Data.ByteString      as BS
-import qualified Data.ByteString.Lazy as BL
-import qualified Data.CaseInsensitive as CI
-import qualified Data.Csv             as CSV
-import qualified Data.HashMap.Strict  as M
-import qualified Data.List            as L
-import qualified Data.Set             as S
-import qualified Data.Text            as T
-import qualified Data.Vector          as V
+import qualified Data.Aeson            as JSON
+import qualified Data.Aeson.Key        as K
+import qualified Data.Aeson.KeyMap     as KM
+import qualified Data.ByteString.Char8 as BS
+import qualified Data.ByteString.Lazy  as LBS
+import qualified Data.CaseInsensitive  as CI
+import qualified Data.Csv              as CSV
+import qualified Data.HashMap.Strict   as HM
+import qualified Data.List             as L
+import qualified Data.List.NonEmpty    as NonEmptyList
+import qualified Data.Map.Strict       as M
+import qualified Data.Set              as S
+import qualified Data.Text.Encoding    as T
+import qualified Data.Vector           as V
 
 import Control.Arrow             ((***))
 import Data.Aeson.Types          (emptyArray, emptyObject)
-import Data.List                 (last, lookup, partition, union)
-import Data.List.NonEmpty        (head)
+import Data.List                 (lookup, union)
 import Data.Maybe                (fromJust)
-import Data.Ranged.Boundaries    (Boundary (..))
-import Data.Ranged.Ranges        (Range (..), emptyRange,
-                                  rangeIntersection)
-import Network.HTTP.Base         (urlEncodeVars)
-import Network.HTTP.Types.Header (hAuthorization, hCookie)
-import Network.HTTP.Types.URI    (parseQueryReplacePlus,
-                                  parseSimpleQuery)
+import Data.Ranged.Ranges        (emptyRange, rangeIntersection)
+import Network.HTTP.Types.Header (hCookie)
+import Network.HTTP.Types.URI    (parseSimpleQuery)
 import Network.Wai               (Request (..))
 import Network.Wai.Parse         (parseHttpAccept)
 import Web.Cookie                (parseCookies)
 
 import PostgREST.Config                  (AppConfig (..),
                                           OpenAPIMode (..))
-import PostgREST.ContentType             (ContentType (..))
 import PostgREST.DbStructure             (DbStructure (..))
 import PostgREST.DbStructure.Identifiers (FieldName,
                                           QualifiedIdentifier (..),
                                           Schema)
-import PostgREST.DbStructure.Proc        (PgArg (..),
-                                          ProcDescription (..),
-                                          ProcsMap)
-import PostgREST.Error                   (ApiRequestError (..))
-import PostgREST.Query.SqlFragment       (ftsOperators, operators)
+import PostgREST.DbStructure.Proc        (ProcDescription (..),
+                                          ProcParam (..), ProcsMap)
+import PostgREST.MediaType               (MTPlanAttrs (..),
+                                          MTPlanFormat (..),
+                                          MediaType (..))
 import PostgREST.RangeQuery              (NonnegRange, allRange,
-                                          rangeGeq, rangeLimit,
-                                          rangeOffset, rangeRequested,
-                                          restrictRange)
-import PostgREST.Request.Parsers         (pRequestColumns)
+                                          hasLimitZero,
+                                          limitZeroRange,
+                                          rangeRequested)
 import PostgREST.Request.Preferences     (PreferCount (..),
                                           PreferParameters (..),
                                           PreferRepresentation (..),
                                           PreferResolution (..),
                                           PreferTransaction (..))
+import PostgREST.Request.QueryParams     (QueryParams (..))
+import PostgREST.Request.Types           (ApiRequestError (..))
 
-import qualified PostgREST.ContentType as ContentType
+import qualified PostgREST.MediaType           as MediaType
+import qualified PostgREST.Request.Preferences as Preferences
+import qualified PostgREST.Request.QueryParams as QueryParams
 
-import Protolude      hiding (head, toS)
-import Protolude.Conv (toS)
+import Protolude
 
 
-type RequestBody = BL.ByteString
+type RequestBody = LBS.ByteString
 
-data PayloadJSON
+data Payload
   = ProcessedJSON -- ^ Cached attributes of a JSON payload
-      { pjRaw  :: BL.ByteString
+      { payRaw  :: LBS.ByteString
       -- ^ This is the raw ByteString that comes from the request body.  We
       -- cache this instead of an Aeson Value because it was detected that for
       -- large payloads the encoding had high memory usage, see
       -- https://github.com/PostgREST/postgrest/pull/1005 for more details
-      , pjKeys :: S.Set Text
+      , payKeys :: S.Set Text
       -- ^ Keys of the object or if it's an array these keys are guaranteed to
       -- be the same across all its objects
       }
-  | RawJSON { pjRaw  :: BL.ByteString }
+  | RawJSON { payRaw  :: LBS.ByteString }
+  | RawPay  { payRaw  :: LBS.ByteString }
 
 data InvokeMethod = InvHead | InvGet | InvPost deriving Eq
+data Mutation = MutationCreate | MutationDelete | MutationSingleUpsert | MutationUpdate deriving Eq
+
 -- | Types of things a user wants to do to tables/views/procs
-data Action = ActionCreate       | ActionRead{isHead :: Bool}
-            | ActionUpdate       | ActionDelete
-            | ActionSingleUpsert | ActionInvoke InvokeMethod
-            | ActionInfo         | ActionInspect{isHead :: Bool}
-            deriving Eq
+data Action
+  = ActionMutate Mutation
+  | ActionRead {isHead :: Bool}
+  | ActionInvoke InvokeMethod
+  | ActionInfo
+  | ActionInspect {isHead :: Bool}
+  deriving Eq
 -- | The path info that will be mapped to a target (used to handle validations and errors before defining the Target)
-data Path
+data PathInfo
   = PathInfo
-      { pSchema        :: Schema,
-        pName          :: Text,
-        pHasRpc        :: Bool,
-        pIsDefaultSpec :: Bool,
-        pIsRootSpec    :: Bool
+      { pathName       :: Text
+      , pathIsProc     :: Bool
+      , pathIsDefSpec  :: Bool
+      , pathIsRootSpec :: Bool
       }
-  | PathUnknown
 -- | The target db object of a user action
 data Target = TargetIdent QualifiedIdentifier
             | TargetProc{tProc :: ProcDescription, tpIsRootSpec :: Bool}
             | TargetDefaultSpec{tdsSchema :: Schema} -- The default spec offered at root "/"
-            | TargetUnknown
 
 -- | RPC query param value `/rpc/func?v=<value>`, used for VARIADIC functions on form-urlencoded POST and GETs
 -- | It can be fixed `?v=1` or repeated `?v=1&v=2&v=3.
@@ -119,25 +121,25 @@ instance JSON.ToJSON RpcParamValue where
   toJSON (Variadic v) = JSON.toJSON v
 
 toRpcParamValue :: ProcDescription -> (Text, Text) -> (Text, RpcParamValue)
-toRpcParamValue proc (k, v) | argIsVariadic k = (k, Variadic [v])
+toRpcParamValue proc (k, v) | prmIsVariadic k = (k, Variadic [v])
                             | otherwise       = (k, Fixed v)
   where
-    argIsVariadic arg = isJust $ find (\PgArg{pgaName, pgaVar} -> pgaName == arg && pgaVar) $ pdArgs proc
+    prmIsVariadic prm = isJust $ find (\ProcParam{ppName, ppVar} -> ppName == prm && ppVar) $ pdParams proc
 
 -- | Convert rpc params `/rpc/func?a=val1&b=val2` to json `{"a": "val1", "b": "val2"}
-jsonRpcParams :: ProcDescription -> [(Text, Text)] -> PayloadJSON
+jsonRpcParams :: ProcDescription -> [(Text, Text)] -> Payload
 jsonRpcParams proc prms =
-  if not $ pdHasVariadic proc then -- if proc has no variadic arg, save steps and directly convert to json
-    ProcessedJSON (JSON.encode $ M.fromList $ second JSON.toJSON <$> prms) (S.fromList $ fst <$> prms)
+  if not $ pdHasVariadic proc then -- if proc has no variadic param, save steps and directly convert to json
+    ProcessedJSON (JSON.encode $ HM.fromList $ second JSON.toJSON <$> prms) (S.fromList $ fst <$> prms)
   else
-    let paramsMap = M.fromListWith mergeParams $ toRpcParamValue proc <$> prms in
-    ProcessedJSON (JSON.encode paramsMap) (S.fromList $ M.keys paramsMap)
+    let paramsMap = HM.fromListWith mergeParams $ toRpcParamValue proc <$> prms in
+    ProcessedJSON (JSON.encode paramsMap) (S.fromList $ HM.keys paramsMap)
   where
     mergeParams :: RpcParamValue -> RpcParamValue -> RpcParamValue
     mergeParams (Variadic a) (Variadic b) = Variadic $ b ++ a
-    mergeParams v _                       = v -- repeated params for non-variadic arguments are not merged
+    mergeParams v _                       = v -- repeated params for non-variadic parameters are not merged
 
-targetToJsonRpcParams :: Maybe Target -> [(Text, Text)] -> Maybe PayloadJSON
+targetToJsonRpcParams :: Maybe Target -> [(Text, Text)] -> Maybe Payload
 targetToJsonRpcParams target params =
   case target of
     Just TargetProc{tProc} -> Just $ jsonRpcParams tProc params
@@ -151,43 +153,77 @@ targetToJsonRpcParams target params =
   if it is an action we are able to perform.
 -}
 data ApiRequest = ApiRequest {
-    iAction               :: Action                           -- ^ Similar but not identical to HTTP verb, e.g. Create/Invoke both POST
-  , iRange                :: M.HashMap ByteString NonnegRange -- ^ Requested range of rows within response
+    iAction               :: Action                           -- ^ Similar but not identical to HTTP method, e.g. Create/Invoke both POST
+  , iRange                :: HM.HashMap Text NonnegRange      -- ^ Requested range of rows within response
   , iTopLevelRange        :: NonnegRange                      -- ^ Requested range of rows from the top level
   , iTarget               :: Target                           -- ^ The target, be it calling a proc or accessing a table
-  , iPayload              :: Maybe PayloadJSON                -- ^ Data sent by client and used for mutation actions
+  , iPayload              :: Maybe Payload                    -- ^ Data sent by client and used for mutation actions
   , iPreferRepresentation :: PreferRepresentation             -- ^ If client wants created items echoed back
   , iPreferParameters     :: Maybe PreferParameters           -- ^ How to pass parameters to a stored procedure
   , iPreferCount          :: Maybe PreferCount                -- ^ Whether the client wants a result count
   , iPreferResolution     :: Maybe PreferResolution           -- ^ Whether the client wants to UPSERT or ignore records on PK conflict
   , iPreferTransaction    :: Maybe PreferTransaction          -- ^ Whether the clients wants to commit or rollback the transaction
-  , iFilters              :: [(Text, Text)]                   -- ^ Filters on the result ("id", "eq.10")
-  , iLogic                :: [(Text, Text)]                   -- ^ &and and &or parameters used for complex boolean logic
-  , iSelect               :: Maybe Text                       -- ^ &select parameter used to shape the response
-  , iOnConflict           :: Maybe Text                       -- ^ &on_conflict parameter used to upsert on specific unique keys
+  , iQueryParams          :: QueryParams.QueryParams
   , iColumns              :: S.Set FieldName                  -- ^ parsed colums from &columns parameter and payload
-  , iOrder                :: [(Text, Text)]                   -- ^ &order parameters for each level
-  , iCanonicalQS          :: ByteString                       -- ^ Alphabetized (canonical) request query string for response URLs
-  , iJWT                  :: Text                             -- ^ JSON Web Token
   , iHeaders              :: [(ByteString, ByteString)]       -- ^ HTTP request headers
   , iCookies              :: [(ByteString, ByteString)]       -- ^ Request Cookies
   , iPath                 :: ByteString                       -- ^ Raw request path
   , iMethod               :: ByteString                       -- ^ Raw request method
   , iProfile              :: Maybe Schema                     -- ^ The request profile for enabling use of multiple schemas. Follows the spec in hhttps://www.w3.org/TR/dx-prof-conneg/ttps://www.w3.org/TR/dx-prof-conneg/.
   , iSchema               :: Schema                           -- ^ The request schema. Can vary depending on iProfile.
-  , iAcceptContentType    :: ContentType
+  , iAcceptMediaType      :: MediaType
   }
 
 -- | Examines HTTP request and translates it into user intent.
 userApiRequest :: AppConfig -> DbStructure -> Request -> RequestBody -> Either ApiRequestError ApiRequest
-userApiRequest conf@AppConfig{..} dbStructure req reqBody
+userApiRequest conf dbStructure req reqBody = do
+  qPrms <- first QueryParamError $ QueryParams.parse $ rawQueryString req
+  pInfo <- getPathInfo conf $ pathInfo req
+  act <- getAction pInfo $ requestMethod req
+  apiRequest conf dbStructure req reqBody qPrms pInfo act
+
+getPathInfo :: AppConfig -> [Text] -> Either ApiRequestError PathInfo
+getPathInfo AppConfig{configOpenApiMode, configDbRootSpec} path =
+  case path of
+    []             -> case configDbRootSpec of
+                        Just (QualifiedIdentifier _ pathName)     -> Right $ PathInfo pathName True False True
+                        Nothing | configOpenApiMode == OADisabled -> Left NotFound
+                                | otherwise                       -> Right $ PathInfo mempty False True False
+    [table]        -> Right $ PathInfo table False False False
+    ["rpc", pName] -> Right $ PathInfo pName True False False
+    _              -> Left NotFound
+
+getAction :: PathInfo -> ByteString -> Either ApiRequestError Action
+getAction PathInfo{pathIsProc, pathIsDefSpec} method =
+  if pathIsProc && method `notElem` ["HEAD", "GET", "POST", "OPTIONS"]
+    then Left $ InvalidRpcMethod method
+    else case method of
+      -- The HEAD method is identical to GET except that the server MUST NOT return a message-body in the response
+      -- From https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.4
+      "HEAD"     | pathIsDefSpec -> Right $ ActionInspect{isHead=True}
+                 | pathIsProc    -> Right $ ActionInvoke InvHead
+                 | otherwise     -> Right $ ActionRead{isHead=True}
+      "GET"      | pathIsDefSpec -> Right $ ActionInspect{isHead=False}
+                 | pathIsProc    -> Right $ ActionInvoke InvGet
+                 | otherwise     -> Right $ ActionRead{isHead=False}
+      "POST"     | pathIsProc    -> Right $ ActionInvoke InvPost
+                 | otherwise     -> Right $ ActionMutate MutationCreate
+      "PATCH"                    -> Right $ ActionMutate MutationUpdate
+      "PUT"                      -> Right $ ActionMutate MutationSingleUpsert
+      "DELETE"                   -> Right $ ActionMutate MutationDelete
+      "OPTIONS"                  -> Right ActionInfo
+      _                          -> Left $ UnsupportedMethod method
+
+apiRequest :: AppConfig -> DbStructure -> Request -> RequestBody -> QueryParams.QueryParams -> PathInfo -> Action -> Either ApiRequestError ApiRequest
+apiRequest conf@AppConfig{..} dbStructure req reqBody queryparams@QueryParams{..} path@PathInfo{pathName, pathIsProc, pathIsRootSpec, pathIsDefSpec} action
   | isJust profile && fromJust profile `notElem` configDbSchemas = Left $ UnacceptableSchema $ toList configDbSchemas
-  | isTargetingProc && method `notElem` ["HEAD", "GET", "POST"] = Left ActionInappropriate
-  | topLevelRange == emptyRange = Left InvalidRange
-  | shouldParsePayload && isLeft payload = either (Left . InvalidBody . toS) witness payload
-  | isLeft parsedColumns = either Left witness parsedColumns
+  | isInvalidRange = Left InvalidRange
+  | shouldParsePayload && isLeft payload = either (Left . InvalidBody) witness payload
+  | not expectParams && not (L.null qsParams) = Left $ ParseRequestError "Unexpected param or filter missing operator" ("Failed to parse " <> show qsParams)
+  | method `elem` ["PATCH", "DELETE"] && not (null qsRanges) && null qsOrder = Left LimitNoOrderError
+  | method == "PUT" && topLevelRange /= allRange = Left PutRangeNotAllowedError
   | otherwise = do
-     acceptContentType <- findAcceptContentType conf action path accepts
+     acceptMediaType <- findAcceptMediaType conf action path accepts
      checkedTarget <- target
      return ApiRequest {
       iAction = action
@@ -195,214 +231,133 @@ userApiRequest conf@AppConfig{..} dbStructure req reqBody
       , iRange = ranges
       , iTopLevelRange = topLevelRange
       , iPayload = relevantPayload
-      , iPreferRepresentation = representation
-      , iPreferParameters  = if | hasPrefer (show SingleObject)     -> Just SingleObject
-                                | hasPrefer (show MultipleObjects)  -> Just MultipleObjects
-                                | otherwise                         -> Nothing
-      , iPreferCount       = if | hasPrefer (show ExactCount)       -> Just ExactCount
-                                | hasPrefer (show PlannedCount)     -> Just PlannedCount
-                                | hasPrefer (show EstimatedCount)   -> Just EstimatedCount
-                                | otherwise                         -> Nothing
-      , iPreferResolution  = if | hasPrefer (show MergeDuplicates)  -> Just MergeDuplicates
-                                | hasPrefer (show IgnoreDuplicates) -> Just IgnoreDuplicates
-                                | otherwise                         -> Nothing
-      , iPreferTransaction = if | hasPrefer (show Commit)           -> Just Commit
-                                | hasPrefer (show Rollback)         -> Just Rollback
-                                | otherwise                         -> Nothing
-      , iFilters = filters
-      , iLogic = [(toS k, toS $ fromJust v) | (k,v) <- qParams, isJust v, endingIn ["and", "or"] k ]
-      , iSelect = toS <$> join (lookup "select" qParams)
-      , iOnConflict = toS <$> join (lookup "on_conflict" qParams)
+      , iPreferRepresentation = fromMaybe None preferRepresentation
+      , iPreferParameters = preferParameters
+      , iPreferCount = preferCount
+      , iPreferResolution = preferResolution
+      , iPreferTransaction = preferTransaction
+      , iQueryParams = queryparams
       , iColumns = payloadColumns
-      , iOrder = [(toS k, toS $ fromJust v) | (k,v) <- qParams, isJust v, endingIn ["order"] k ]
-      , iCanonicalQS = toS $ urlEncodeVars
-        . L.sortOn fst
-        . map (join (***) toS . second (fromMaybe BS.empty))
-        $ qString
-      , iJWT = tokenStr
       , iHeaders = [ (CI.foldedCase k, v) | (k,v) <- hdrs, k /= hCookie]
       , iCookies = maybe [] parseCookies $ lookupHeader "Cookie"
       , iPath = rawPathInfo req
       , iMethod = method
       , iProfile = profile
       , iSchema = schema
-      , iAcceptContentType = acceptContentType
+      , iAcceptMediaType = acceptMediaType
       }
  where
-  accepts = maybe [CTAny] (map ContentType.decodeContentType . parseHttpAccept) $ lookupHeader "accept"
-  -- queryString with '+' converted to ' '(space)
-  qString = parseQueryReplacePlus True $ rawQueryString req
-  -- rpcQParams = Rpc query params e.g. /rpc/name?param1=val1, similar to filter but with no operator(eq, lt..)
-  (filters, rpcQParams) =
-    case action of
-      ActionInvoke InvGet  -> partitionFlts
-      ActionInvoke InvHead -> partitionFlts
-      _                    -> (flts, [])
-  partitionFlts = partition (liftM2 (||) (isEmbedPath . fst) (hasOperator . snd)) flts
-  flts =
-    [ (toS k, toS $ fromJust v) |
-      (k,v) <- qParams, isJust v,
-      k `notElem` ["select", "columns"],
-      not (endingIn ["order", "limit", "offset", "and", "or"] k) ]
-  hasOperator val = any (`T.isPrefixOf` val) $
-                      ((<> ".") <$> "not":M.keys operators) ++
-                      ((<> "(") <$> M.keys ftsOperators)
-  isEmbedPath = T.isInfixOf "."
-  isTargetingProc = case path of
-    PathInfo{pHasRpc, pIsRootSpec} -> pHasRpc || pIsRootSpec
-    _                              -> False
-  isTargetingDefaultSpec = case path of
-    PathInfo{pIsDefaultSpec=True} -> True
-    _                             -> False
-  contentType = ContentType.decodeContentType . fromMaybe "application/json" $ lookupHeader "content-type"
-  columns
-    | action `elem` [ActionCreate, ActionUpdate, ActionInvoke InvPost] = toS <$> join (lookup "columns" qParams)
-    | otherwise = Nothing
-  parsedColumns = pRequestColumns columns
+  accepts = maybe [MTAny] (map MediaType.decodeMediaType . parseHttpAccept) $ lookupHeader "accept"
+
+  expectParams = pathIsProc && method /= "POST"
+
+  contentMediaType = maybe MTApplicationJSON MediaType.decodeMediaType $ lookupHeader "content-type"
+
+  columns = case action of
+    ActionMutate MutationCreate -> qsColumns
+    ActionMutate MutationUpdate -> qsColumns
+    ActionInvoke InvPost        -> qsColumns
+    _                           -> Nothing
+
   payloadColumns =
-    case (contentType, action) of
-      (_, ActionInvoke InvGet)  -> S.fromList $ fst <$> rpcQParams
-      (_, ActionInvoke InvHead) -> S.fromList $ fst <$> rpcQParams
-      (CTUrlEncoded, _)         -> S.fromList $ map (toS . fst) $ parseSimpleQuery $ toS reqBody
-      _ -> case (relevantPayload, fromRight Nothing parsedColumns) of
-        (Just ProcessedJSON{pjKeys}, _) -> pjKeys
-        (Just RawJSON{}, Just cls)      -> cls
-        _                               -> S.empty
-  payload = case contentType of
-    CTApplicationJSON ->
+    case (contentMediaType, action) of
+      (_, ActionInvoke InvGet)  -> S.fromList $ fst <$> qsParams
+      (_, ActionInvoke InvHead) -> S.fromList $ fst <$> qsParams
+      (MTUrlEncoded, _)         -> S.fromList $ map (T.decodeUtf8 . fst) $ parseSimpleQuery $ LBS.toStrict reqBody
+      _ -> case (relevantPayload, columns) of
+        (Just ProcessedJSON{payKeys}, _) -> payKeys
+        (Just RawJSON{}, Just cls)       -> cls
+        _                                -> S.empty
+  payload :: Either ByteString Payload
+  payload = case (contentMediaType, pathIsProc) of
+    (MTApplicationJSON, _) ->
       if isJust columns
         then Right $ RawJSON reqBody
         else note "All object keys must match" . payloadAttributes reqBody
-               =<< if BL.null reqBody && isTargetingProc
+               =<< if LBS.null reqBody && pathIsProc
                      then Right emptyObject
-                     else JSON.eitherDecode reqBody
-    CTTextCSV -> do
-      json <- csvToJson <$> CSV.decodeByName reqBody
+                     else first BS.pack $ JSON.eitherDecode reqBody
+    (MTTextCSV, _) -> do
+      json <- csvToJson <$> first BS.pack (CSV.decodeByName reqBody)
       note "All lines must have same number of fields" $ payloadAttributes (JSON.encode json) json
-    CTUrlEncoded ->
-      let paramsMap = M.fromList $ (toS *** JSON.String . toS) <$> parseSimpleQuery (toS reqBody) in
-      Right $ ProcessedJSON (JSON.encode paramsMap) $ S.fromList (M.keys paramsMap)
-    ct ->
-      Left $ toS $ "Content-Type not acceptable: " <> ContentType.toMime ct
-  topLevelRange = fromMaybe allRange $ M.lookup "limit" ranges -- if no limit is specified, get all the request rows
-  action =
-    case method of
-      -- The HEAD method is identical to GET except that the server MUST NOT return a message-body in the response
-      -- From https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.4
-      "HEAD"     | isTargetingDefaultSpec -> ActionInspect{isHead=True}
-                 | isTargetingProc        -> ActionInvoke InvHead
-                 | otherwise              -> ActionRead{isHead=True}
-      "GET"      | isTargetingDefaultSpec -> ActionInspect{isHead=False}
-                 | isTargetingProc        -> ActionInvoke InvGet
-                 | otherwise              -> ActionRead{isHead=False}
-      "POST"    -> if isTargetingProc
-                    then ActionInvoke InvPost
-                    else ActionCreate
-      "PATCH"   -> ActionUpdate
-      "PUT"     -> ActionSingleUpsert
-      "DELETE"  -> ActionDelete
-      "OPTIONS" -> ActionInfo
-      _         -> ActionInspect{isHead=False}
+    (MTUrlEncoded, _) ->
+      let paramsMap = HM.fromList $ (T.decodeUtf8 *** JSON.String . T.decodeUtf8) <$> parseSimpleQuery (LBS.toStrict reqBody) in
+      Right $ ProcessedJSON (JSON.encode paramsMap) $ S.fromList (HM.keys paramsMap)
+    (MTTextPlain, True) -> Right $ RawPay reqBody
+    (MTTextXML, True) -> Right $ RawPay reqBody
+    (MTOctetStream, True) -> Right $ RawPay reqBody
+    (ct, _) -> Left $ "Content-Type not acceptable: " <> MediaType.toMime ct
+  topLevelRange = fromMaybe allRange $ HM.lookup "limit" ranges -- if no limit is specified, get all the request rows
 
-  defaultSchema = head configDbSchemas
+  defaultSchema = NonEmptyList.head configDbSchemas
   profile
     | length configDbSchemas <= 1 -- only enable content negotiation by profile when there are multiple schemas specified in the config
       = Nothing
-    | otherwise = case action of
+    | otherwise = case method of
         -- POST/PATCH/PUT/DELETE don't use the same header as per the spec
-        ActionCreate         -> contentProfile
-        ActionUpdate         -> contentProfile
-        ActionSingleUpsert   -> contentProfile
-        ActionDelete         -> contentProfile
-        ActionInvoke InvPost -> contentProfile
-        _                    -> acceptProfile
+        "DELETE" -> contentProfile
+        "PATCH"  -> contentProfile
+        "POST"   -> contentProfile
+        "PUT"    -> contentProfile
+        _        -> acceptProfile
     where
-      contentProfile = Just $ maybe defaultSchema toS $ lookupHeader "Content-Profile"
-      acceptProfile = Just $ maybe defaultSchema toS $ lookupHeader "Accept-Profile"
-  schema = fromMaybe defaultSchema profile
-  target =
-    let
-      callFindProc procSch procNam = findProc (QualifiedIdentifier procSch procNam) payloadColumns (hasPrefer (show SingleObject)) $ dbProcs dbStructure
-    in
-    case path of
-      PathInfo{pSchema, pName, pHasRpc, pIsRootSpec, pIsDefaultSpec}
-        | pHasRpc || pIsRootSpec -> (`TargetProc` pIsRootSpec) <$> callFindProc pSchema pName
-        | pIsDefaultSpec         -> Right $ TargetDefaultSpec pSchema
-        | otherwise              -> Right $ TargetIdent $ QualifiedIdentifier pSchema pName
-      PathUnknown -> Right TargetUnknown
+      contentProfile = Just $ maybe defaultSchema T.decodeUtf8 $ lookupHeader "Content-Profile"
+      acceptProfile = Just $ maybe defaultSchema T.decodeUtf8 $ lookupHeader "Accept-Profile"
 
-  shouldParsePayload = case (contentType, action) of
-    (CTUrlEncoded, ActionInvoke InvPost) -> False
-    (_, act)                             -> act `elem` [ActionCreate, ActionUpdate, ActionSingleUpsert, ActionInvoke InvPost]
-  relevantPayload = case (contentType, action) of
+  schema = fromMaybe defaultSchema profile
+
+  target
+    | pathIsProc    = (`TargetProc` pathIsRootSpec) <$> callFindProc schema pathName
+    | pathIsDefSpec = Right $ TargetDefaultSpec schema
+    | otherwise     = Right $ TargetIdent $ QualifiedIdentifier schema pathName
+    where
+      callFindProc procSch procNam = findProc
+        (QualifiedIdentifier procSch procNam) payloadColumns (preferParameters == Just SingleObject) (dbProcs dbStructure)
+        contentMediaType (action == ActionInvoke InvPost)
+
+  shouldParsePayload = case (action, contentMediaType) of
+    (ActionMutate MutationCreate, _)       -> True
+    (ActionInvoke InvPost, MTUrlEncoded)   -> False
+    (ActionInvoke InvPost, _)              -> True
+    (ActionMutate MutationSingleUpsert, _) -> True
+    (ActionMutate MutationUpdate, _)       -> True
+    _                                      -> False
+  relevantPayload = case (contentMediaType, action) of
     -- Though ActionInvoke GET/HEAD doesn't really have a payload, we use the payload variable as a way
     -- to store the query string arguments to the function.
-    (_, ActionInvoke InvGet)             -> targetToJsonRpcParams (rightToMaybe target) rpcQParams
-    (_, ActionInvoke InvHead)            -> targetToJsonRpcParams (rightToMaybe target) rpcQParams
-    (CTUrlEncoded, ActionInvoke InvPost) -> targetToJsonRpcParams (rightToMaybe target) $ (toS *** toS) <$> parseSimpleQuery (toS reqBody)
+    (_, ActionInvoke InvGet)             -> targetToJsonRpcParams (rightToMaybe target) qsParams
+    (_, ActionInvoke InvHead)            -> targetToJsonRpcParams (rightToMaybe target) qsParams
+    (MTUrlEncoded, ActionInvoke InvPost) -> targetToJsonRpcParams (rightToMaybe target) $ (T.decodeUtf8 *** T.decodeUtf8) <$> parseSimpleQuery (LBS.toStrict reqBody)
     _ | shouldParsePayload               -> rightToMaybe payload
       | otherwise                        -> Nothing
-  path =
-    case pathInfo req of
-      []             -> case configDbRootSpec of
-                          Just (QualifiedIdentifier pSch pName)     -> PathInfo (if pSch == mempty then schema else pSch) pName False False True
-                          Nothing | configOpenApiMode == OADisabled -> PathUnknown
-                                  | otherwise                       -> PathInfo schema "" False True False
-      [table]        -> PathInfo schema table False False False
-      ["rpc", pName] -> PathInfo schema pName True False False
-      _              -> PathUnknown
   method          = requestMethod req
   hdrs            = requestHeaders req
-  qParams         = [(toS k, v)|(k,v) <- qString]
   lookupHeader    = flip lookup hdrs
-  hasPrefer :: Text -> Bool
-  hasPrefer val   = any (\(h,v) -> h == "Prefer" && val `elem` split v) hdrs
-    where
-        split :: BS.ByteString -> [Text]
-        split = map T.strip . T.split (==',') . toS
-  representation
-    | hasPrefer (show Full)        = Full
-    | hasPrefer (show None)        = None
-    | hasPrefer (show HeadersOnly) = HeadersOnly
-    | otherwise                    = None
-  auth = fromMaybe "" $ lookupHeader hAuthorization
-  tokenStr = case T.split (== ' ') (toS auth) of
-    ("Bearer" : t : _) -> t
-    ("bearer" : t : _) -> t
-    _                  -> ""
-  endingIn:: [Text] -> Text -> Bool
-  endingIn xx key = lastWord `elem` xx
-    where lastWord = last $ T.split (=='.') key
-
+  Preferences.Preferences{..} = Preferences.fromHeaders hdrs
   headerRange = rangeRequested hdrs
-  replaceLast x s = T.intercalate "." $ L.init (T.split (=='.') s) ++ [x]
-  limitParams :: M.HashMap ByteString NonnegRange
-  limitParams  = M.fromList [(toS (replaceLast "limit" k), restrictRange (readMaybe . toS =<< v) allRange) | (k,v) <- qParams, isJust v, endingIn ["limit"] k]
-  offsetParams :: M.HashMap ByteString NonnegRange
-  offsetParams = M.fromList [(toS (replaceLast "limit" k), maybe allRange rangeGeq (readMaybe . toS =<< v)) | (k,v) <- qParams, isJust v, endingIn ["offset"] k]
+  limitRange = fromMaybe allRange (HM.lookup "limit" qsRanges)
+  headerAndLimitRange = rangeIntersection headerRange limitRange
 
-  urlRange = M.unionWith f limitParams offsetParams
-    where
-      f rl ro = Range (BoundaryBelow o) (BoundaryAbove $ o + l - 1)
-        where
-          l = fromMaybe 0 $ rangeLimit rl
-          o = rangeOffset ro
-  ranges = M.insert "limit" (rangeIntersection headerRange (fromMaybe allRange (M.lookup "limit" urlRange))) urlRange
+  -- Bypass all the ranges and send only the limit zero range (0 <= x <= -1) if
+  -- limit=0 is present in the query params (not allowed for the Range header)
+  ranges = HM.insert "limit" (if hasLimitZero limitRange then limitZeroRange else headerAndLimitRange) qsRanges
+  -- The only emptyRange allowed is the limit zero range
+  isInvalidRange = topLevelRange == emptyRange && not (hasLimitZero limitRange)
 
 {-|
-  Find the best match from a list of content types accepted by the
+  Find the best match from a list of media types accepted by the
   client in order of decreasing preference and a list of types
   producible by the server.  If there is no match but the client
   accepts */* then return the top server pick.
 -}
-mutuallyAgreeable :: [ContentType] -> [ContentType] -> Maybe ContentType
+mutuallyAgreeable :: [MediaType] -> [MediaType] -> Maybe MediaType
 mutuallyAgreeable sProduces cAccepts =
   let exact = listToMaybe $ L.intersect cAccepts sProduces in
-  if isNothing exact && CTAny `elem` cAccepts
+  if isNothing exact && MTAny `elem` cAccepts
      then listToMaybe sProduces
      else exact
 
-type CsvData = V.Vector (M.HashMap Text BL.ByteString)
+type CsvData = V.Vector (M.Map Text LBS.ByteString)
 
 {-|
   Converts CSV like
@@ -420,23 +375,23 @@ csvToJson :: (CSV.Header, CsvData) -> JSON.Value
 csvToJson (_, vals) =
   JSON.Array $ V.map rowToJsonObj vals
  where
-  rowToJsonObj = JSON.Object .
+  rowToJsonObj = JSON.Object . KM.fromMapText .
     M.map (\str ->
         if str == "NULL"
           then JSON.Null
-          else JSON.String $ toS str
+          else JSON.String . T.decodeUtf8 $ LBS.toStrict str
       )
 
-payloadAttributes :: RequestBody -> JSON.Value -> Maybe PayloadJSON
+payloadAttributes :: RequestBody -> JSON.Value -> Maybe Payload
 payloadAttributes raw json =
   -- Test that Array contains only Objects having the same keys
   case json of
     JSON.Array arr ->
       case arr V.!? 0 of
         Just (JSON.Object o) ->
-          let canonicalKeys = S.fromList $ M.keys o
+          let canonicalKeys = S.fromList $ K.toText <$> KM.keys o
               areKeysUniform = all (\case
-                JSON.Object x -> S.fromList (M.keys x) == canonicalKeys
+                JSON.Object x -> S.fromList (K.toText <$> KM.keys x) == canonicalKeys
                 _ -> False) arr in
           if areKeysUniform
             then Just $ ProcessedJSON raw canonicalKeys
@@ -444,73 +399,90 @@ payloadAttributes raw json =
         Just _ -> Nothing
         Nothing -> Just emptyPJArray
 
-    JSON.Object o -> Just $ ProcessedJSON raw (S.fromList $ M.keys o)
+    JSON.Object o -> Just $ ProcessedJSON raw (S.fromList $ K.toText <$> KM.keys o)
 
     -- truncate everything else to an empty array.
     _ -> Just emptyPJArray
   where
     emptyPJArray = ProcessedJSON (JSON.encode emptyArray) S.empty
 
-findAcceptContentType :: AppConfig -> Action -> Path -> [ContentType] -> Either ApiRequestError ContentType
-findAcceptContentType conf action path accepts =
-  case mutuallyAgreeable (requestContentTypes conf action path) accepts of
+findAcceptMediaType :: AppConfig -> Action -> PathInfo -> [MediaType] -> Either ApiRequestError MediaType
+findAcceptMediaType conf action path accepts =
+  case mutuallyAgreeable (requestMediaTypes conf action path) accepts of
     Just ct ->
       Right ct
     Nothing ->
-      Left . ContentTypeError $ map ContentType.toMime accepts
+      Left . MediaTypeError $ map MediaType.toMime accepts
 
-requestContentTypes :: AppConfig -> Action -> Path -> [ContentType]
-requestContentTypes conf action path =
+requestMediaTypes :: AppConfig -> Action -> PathInfo -> [MediaType]
+requestMediaTypes conf action path =
   case action of
-    ActionRead _    -> defaultContentTypes ++ rawContentTypes conf
-    ActionInvoke _  -> invokeContentTypes
-    ActionInspect _ -> [CTOpenAPI, CTApplicationJSON]
-    ActionInfo      -> [CTTextCSV]
-    _               -> defaultContentTypes
+    ActionRead _    -> defaultMediaTypes ++ rawMediaTypes
+    ActionInvoke _  -> invokeMediaTypes
+    ActionInspect _ -> [MTOpenAPI, MTApplicationJSON]
+    ActionInfo      -> [MTTextCSV]
+    _               -> defaultMediaTypes
   where
-    invokeContentTypes =
-      defaultContentTypes
-        ++ rawContentTypes conf
-        ++ [CTOpenAPI | pIsRootSpec path]
-    defaultContentTypes =
-      [CTApplicationJSON, CTSingularJSON, CTTextCSV]
-
-rawContentTypes :: AppConfig -> [ContentType]
-rawContentTypes AppConfig{..} =
-  (ContentType.decodeContentType <$> configRawMediaTypes) `union` [CTOctetStream, CTTextPlain]
+    invokeMediaTypes =
+      defaultMediaTypes
+        ++ rawMediaTypes
+        ++ [MTOpenAPI | pathIsRootSpec path]
+    defaultMediaTypes =
+      [MTApplicationJSON, MTSingularJSON, MTGeoJSON, MTTextCSV] ++
+      [MTPlan $ MTPlanAttrs Nothing PlanJSON mempty | configDbPlanEnabled conf]
+    rawMediaTypes = configRawMediaTypes conf `union` [MTOctetStream, MTTextPlain, MTTextXML]
 
 {-|
-  Search a pg procedure by its parameters. Since a function can be overloaded, the name is not enough to find it.
-  An overloaded function can have a different volatility or even a different return type.
+  Search a pg proc by matching name and arguments keys to parameters. Since a function can be overloaded,
+  the name is not enough to find it. An overloaded function can have a different volatility or even a different return type.
 -}
-findProc :: QualifiedIdentifier -> S.Set Text -> Bool -> ProcsMap -> Either ApiRequestError ProcDescription
-findProc qi payloadKeys paramsAsSingleObject allProcs =
-  case bestMatch of
-    []     -> Left $ NoRpc (qiSchema qi) (qiName qi) (S.toList payloadKeys) paramsAsSingleObject
-    [proc] -> Right proc
-    procs  -> Left $ AmbiguousRpc (toList procs)
+findProc :: QualifiedIdentifier -> S.Set Text -> Bool -> ProcsMap -> MediaType -> Bool -> Either ApiRequestError ProcDescription
+findProc qi argumentsKeys paramsAsSingleObject allProcs contentMediaType isInvPost =
+  case matchProc of
+    ([], [])     -> Left $ NoRpc (qiSchema qi) (qiName qi) (S.toList argumentsKeys) paramsAsSingleObject contentMediaType isInvPost
+    -- If there are no functions with named arguments, fallback to the single unnamed argument function
+    ([], [proc]) -> Right proc
+    ([], procs)  -> Left $ AmbiguousRpc (toList procs)
+    -- Matches the functions with named arguments
+    ([proc], _)  -> Right proc
+    (procs, _)   -> Left $ AmbiguousRpc (toList procs)
   where
-    bestMatch =
-      case M.lookup qi allProcs of
-        Nothing     -> []
-        Just [proc] -> [proc | matches proc]
-        Just procs  -> filter matches procs
-    -- Find the exact arguments match
-    matches proc
-      | paramsAsSingleObject = case pdArgs proc of
-                               [arg] -> pgaType arg `elem` ["json", "jsonb"]
-                               _     -> False
-      | otherwise            = case pdArgs proc of
-                               []   -> null payloadKeys
-                               args -> matchesArg args
-    matchesArg args =
-      -- The function's required arguments are separated from the ones with a default value assigned.
-      -- The set of names of those arguments is compared to the set of keys supplied by the client
-      -- 1. If only required arguments are found, the keys must be exactly the same as those arguments
-      -- 2. If only optional arguments are found, the keys must be a subset of those arguments
-      -- 3. If both required and optional arguments are found, the result of taking away the optional arguments
-      --    from the keys must be exactly the same as the required arguments
-      case L.partition pgaReq args of
-        (reqArgs, [])      -> payloadKeys == S.fromList (pgaName <$> reqArgs)
-        ([], defArgs)      -> payloadKeys `S.isSubsetOf` S.fromList (pgaName <$> defArgs)
-        (reqArgs, defArgs) -> payloadKeys `S.difference` S.fromList (pgaName <$> defArgs) == S.fromList (pgaName <$> reqArgs)
+    matchProc = overloadedProcPartition $ HM.lookupDefault mempty qi allProcs -- first find the proc by name
+    -- The partition obtained has the form (overloadedProcs,fallbackProcs)
+    -- where fallbackProcs are functions with a single unnamed parameter
+    overloadedProcPartition = foldr select ([],[])
+    select proc ~(ts,fs)
+      | matchesParams proc         = (proc:ts,fs)
+      | hasSingleUnnamedParam proc = (ts,proc:fs)
+      | otherwise                  = (ts,fs)
+    -- If the function is called with post and has a single unnamed parameter
+    -- it can be called depending on content type and the parameter type
+    hasSingleUnnamedParam ProcDescription{pdParams=[ProcParam{ppType}]} = isInvPost && case (contentMediaType, ppType) of
+      (MTApplicationJSON, "json")  -> True
+      (MTApplicationJSON, "jsonb") -> True
+      (MTTextPlain, "text")        -> True
+      (MTTextXML, "xml")           -> True
+      (MTOctetStream, "bytea")     -> True
+      _                            -> False
+    hasSingleUnnamedParam _ = False
+    matchesParams proc =
+      let
+        params = pdParams proc
+        firstType = (ppType <$> headMay params)
+      in
+      -- exceptional case for Prefer: params=single-object
+      if paramsAsSingleObject
+        then length params == 1 && (firstType == Just "json" || firstType == Just "jsonb")
+      -- If the function has no parameters, the arguments keys must be empty as well
+      else if null params
+        then null argumentsKeys && not (isInvPost && contentMediaType `elem` [MTOctetStream, MTTextPlain, MTTextXML])
+      -- A function has optional and required parameters. Optional parameters have a default value and
+      -- don't require arguments for the function to be executed, required parameters must have an argument present.
+      else case L.partition ppReq params of
+      -- If the function only has required parameters, the arguments keys must match those parameters
+        (reqParams, [])        -> argumentsKeys == S.fromList (ppName <$> reqParams)
+      -- If the function only has optional parameters, the arguments keys can match none or any of them(a subset)
+        ([], optParams)        -> argumentsKeys `S.isSubsetOf` S.fromList (ppName <$> optParams)
+      -- If the function has required and optional parameters, the arguments keys have to match the required parameters
+      -- and can match any or none of the default parameters.
+        (reqParams, optParams) -> argumentsKeys `S.difference` S.fromList (ppName <$> optParams) == S.fromList (ppName <$> reqParams)

src/PostgREST/Request/DbRequestBuilder.hs

@@ -18,330 +18,339 @@ resource.
 module PostgREST.Request.DbRequestBuilder
   ( readRequest
   , mutateRequest
-  , returningCols
+  , callRequest
   ) where
 
-import qualified Data.HashMap.Strict as M
+import qualified Data.HashMap.Strict as HM
 import qualified Data.Set            as S
 
-import Control.Arrow           ((***))
 import Data.Either.Combinators (mapLeft)
 import Data.List               (delete)
-import Data.Text               (isInfixOf)
 import Data.Tree               (Tree (..))
 
 import PostgREST.DbStructure.Identifiers  (FieldName,
                                            QualifiedIdentifier (..),
                                            Schema, TableName)
+import PostgREST.DbStructure.Proc         (ProcDescription (..),
+                                           ProcParam (..),
+                                           procReturnsScalar)
 import PostgREST.DbStructure.Relationship (Cardinality (..),
                                            Junction (..),
-                                           Relationship (..))
-import PostgREST.DbStructure.Table        (Column (..), Table (..),
-                                           tableQi)
-import PostgREST.Error                    (ApiRequestError (..),
-                                           Error (..))
+                                           Relationship (..),
+                                           RelationshipsMap)
+import PostgREST.Error                    (Error (..))
 import PostgREST.Query.SqlFragment        (sourceCTEName)
 import PostgREST.RangeQuery               (NonnegRange, allRange,
                                            restrictRange)
 import PostgREST.Request.ApiRequest       (Action (..),
                                            ApiRequest (..),
-                                           PayloadJSON (..))
+                                           InvokeMethod (..),
+                                           Mutation (..),
+                                           Payload (..))
 
-import PostgREST.Request.Parsers
+import PostgREST.Request.MutateQuery
 import PostgREST.Request.Preferences
+import PostgREST.Request.ReadQuery   as ReadQuery
 import PostgREST.Request.Types
 
-import qualified PostgREST.DbStructure.Relationship as Relationship
+import qualified PostgREST.Request.QueryParams as QueryParams
 
 import Protolude hiding (from)
 
 -- | Builds the ReadRequest tree on a number of stages.
 -- | Adds filters, order, limits on its respective nodes.
 -- | Adds joins conditions obtained from resource embedding.
-readRequest :: Schema -> TableName -> Maybe Integer -> [Relationship] -> ApiRequest -> Either Error ReadRequest
+readRequest :: Schema -> TableName -> Maybe Integer -> RelationshipsMap -> ApiRequest -> Either Error ReadRequest
 readRequest schema rootTableName maxRows allRels apiRequest  =
   mapLeft ApiRequestError $
-  treeRestrictRange maxRows =<<
-  augmentRequestWithJoin schema rootRels =<<
-  (addFiltersOrdersRanges apiRequest . initReadRequest rootName =<< pRequestSelect sel)
+  treeRestrictRange maxRows (iAction apiRequest) =<<
+  augmentRequestWithJoin schema allRels =<<
+  addLogicTrees apiRequest =<<
+  addRanges apiRequest =<<
+  addOrders apiRequest =<<
+  addFilters apiRequest (initReadRequest rootName rootAlias qsSelect)
   where
-    sel = fromMaybe "*" $ iSelect apiRequest -- default to all columns requested (SELECT *) for a non existent ?select querystring param
-    (rootName, rootRels) = rootWithRels schema rootTableName allRels (iAction apiRequest)
-
--- Get the root table name with its relationships according to the Action type.
--- This is done because of the shape of the final SQL Query. The mutation cases
--- are wrapped in a WITH {sourceCTEName}(see Statements.hs).  So we need a FROM
--- {sourceCTEName} instead of FROM {tableName}.
-rootWithRels :: Schema -> TableName -> [Relationship] -> Action -> (QualifiedIdentifier, [Relationship])
-rootWithRels schema rootTableName allRels action = case action of
-  ActionRead _ -> (QualifiedIdentifier schema rootTableName, allRels) -- normal read case
-  _            -> (QualifiedIdentifier mempty _sourceCTEName, mapMaybe toSourceRel allRels ++ allRels) -- mutation cases and calling proc
-  where
-    _sourceCTEName = decodeUtf8 sourceCTEName
-    -- To enable embedding in the sourceCTEName cases we need to replace the
-    -- foreign key tableName in the Relationship with {sourceCTEName}. This way
-    -- findRel can find relationships with sourceCTEName.
-    toSourceRel :: Relationship -> Maybe Relationship
-    toSourceRel r@Relationship{relTable=t}
-      | rootTableName == tableName t = Just $ r {relTable=t {tableName=_sourceCTEName}}
-      | otherwise                    = Nothing
+    QueryParams.QueryParams{..} = iQueryParams apiRequest
+    (rootName, rootAlias) = case iAction apiRequest of
+      ActionRead _ -> (QualifiedIdentifier schema rootTableName, Nothing)
+      -- the CTE we use for non-read cases has a sourceCTEName(see Statements.hs) as the WITH name so we use the table name as an alias so findRel can find the right relationship
+      _ -> (QualifiedIdentifier mempty $ decodeUtf8 sourceCTEName, Just rootTableName)
 
 -- Build the initial tree with a Depth attribute so when a self join occurs we
 -- can differentiate the parent and child tables by having an alias like
 -- "table_depth", this is related to
 -- http://github.com/PostgREST/postgrest/issues/987.
-initReadRequest :: QualifiedIdentifier -> [Tree SelectItem] -> ReadRequest
-initReadRequest rootQi =
+initReadRequest :: QualifiedIdentifier -> Maybe Alias -> [Tree SelectItem] -> ReadRequest
+initReadRequest rootQi rootAlias =
   foldr (treeEntry rootDepth) initial
   where
     rootDepth = 0
     rootSchema = qiSchema rootQi
     rootName = qiName rootQi
-    initial = Node (Select [] rootQi Nothing [] [] [] [] allRange, (rootName, Nothing, Nothing, Nothing, rootDepth)) []
+    initial = Node (Select [] rootQi rootAlias [] [] [] allRange, (rootName, Nothing, Nothing, Nothing, Nothing, rootDepth)) []
     treeEntry :: Depth -> Tree SelectItem -> ReadRequest -> ReadRequest
-    treeEntry depth (Node fld@((fn, _),_,alias, embedHint) fldForest) (Node (q, i) rForest) =
+    treeEntry depth (Node fld@((fn, _),_,alias, hint, joinType) fldForest) (Node (q, i) rForest) =
       let nxtDepth = succ depth in
       case fldForest of
         [] -> Node (q {select=fld:select q}, i) rForest
         _  -> Node (q, i) $
               foldr (treeEntry nxtDepth)
-              (Node (Select [] (QualifiedIdentifier rootSchema fn) Nothing [] [] [] [] allRange,
-                (fn, Nothing, alias, embedHint, nxtDepth)) [])
+              (Node (Select [] (QualifiedIdentifier rootSchema fn) Nothing [] [] [] allRange,
+                (fn, Nothing, alias, hint, joinType, nxtDepth)) [])
               fldForest:rForest
 
 -- | Enforces the `max-rows` config on the result
-treeRestrictRange :: Maybe Integer -> ReadRequest -> Either ApiRequestError ReadRequest
-treeRestrictRange maxRows request = pure $ nodeRestrictRange maxRows <$> request
+treeRestrictRange :: Maybe Integer -> Action -> ReadRequest -> Either ApiRequestError ReadRequest
+treeRestrictRange _ (ActionMutate _) request = Right request
+treeRestrictRange maxRows _ request = pure $ nodeRestrictRange maxRows <$> request
   where
     nodeRestrictRange :: Maybe Integer -> ReadNode -> ReadNode
     nodeRestrictRange m (q@Select {range_=r}, i) = (q{range_=restrictRange m r }, i)
 
-augmentRequestWithJoin :: Schema -> [Relationship] -> ReadRequest -> Either ApiRequestError ReadRequest
+augmentRequestWithJoin :: Schema -> RelationshipsMap -> ReadRequest -> Either ApiRequestError ReadRequest
 augmentRequestWithJoin schema allRels request =
-  addRels schema allRels Nothing request
-  >>= addJoinConditions Nothing
+ addJoinConditions Nothing <$> addRels schema allRels Nothing request
 
-addRels :: Schema -> [Relationship] -> Maybe ReadRequest -> ReadRequest -> Either ApiRequestError ReadRequest
-addRels schema allRels parentNode (Node (query@Select{from=tbl}, (nodeName, _, alias, hint, depth)) forest) =
+addRels :: Schema -> RelationshipsMap -> Maybe ReadRequest -> ReadRequest -> Either ApiRequestError ReadRequest
+addRels schema allRels parentNode (Node (query@Select{from=tbl}, (nodeName, _, alias, hint, joinType, depth)) forest) =
   case parentNode of
-    Just (Node (Select{from=parentNodeQi}, _) _) ->
-      let newFrom r = if qiName tbl == nodeName then tableQi (relForeignTable r) else tbl
-          newReadNode = (\r -> (query{from=newFrom r}, (nodeName, Just r, alias, Nothing, depth))) <$> rel
-          rel = findRel schema allRels (qiName parentNodeQi) nodeName hint
+    Just (Node (Select{from=parentNodeQi, fromAlias=aliasQi}, _) _) ->
+      let newFrom r = if qiName tbl == nodeName then relForeignTable r else tbl
+          newReadNode = (\r ->
+            if not $ relIsSelf r -- add alias if self rel TODO consolidate aliasing in another function
+              then (query{from=newFrom r}, (nodeName, Just r, alias, hint, joinType, depth))
+              else (query{from=newFrom r, fromAlias=Just (qiName (newFrom r) <> "_" <> show depth)}, (nodeName, Just r, alias, hint, joinType, depth))
+            ) <$> rel
+          origin = if depth == 1 -- Only on depth 1 we check if the root(depth 0) has an alias so the sourceCTEName alias can be found as a relationship
+            then fromMaybe (qiName parentNodeQi) aliasQi
+            else qiName parentNodeQi
+          rel = findRel schema allRels origin nodeName hint
       in
       Node <$> newReadNode <*> (updateForest . hush $ Node <$> newReadNode <*> pure forest)
     _ ->
-      let rn = (query, (nodeName, Nothing, alias, Nothing, depth)) in
+      let rn = (query, (nodeName, Nothing, alias, Nothing, joinType, depth)) in
       Node rn <$> updateForest (Just $ Node rn forest)
   where
     updateForest :: Maybe ReadRequest -> Either ApiRequestError [ReadRequest]
     updateForest rq = addRels schema allRels rq `traverse` forest
 
+-- applies aliasing to join conditions TODO refactor, this should go into the querybuilder module
+addJoinConditions :: Maybe Alias -> ReadRequest -> ReadRequest
+addJoinConditions _ (Node node@(Select{fromAlias=tblAlias}, (_, Nothing, _, _, _, _)) forest) = Node node (addJoinConditions tblAlias <$> forest)
+addJoinConditions _ (Node node@(Select{fromAlias=tblAlias}, (_, Just ComputedRelationship{}, _, _, _, _)) forest) = Node node (addJoinConditions tblAlias <$> forest)
+addJoinConditions previousAlias (Node (query@Select{fromAlias=tblAlias}, nodeProps@(_, Just (Relationship QualifiedIdentifier{qiSchema=tSchema, qiName=tN} QualifiedIdentifier{qiName=ftN} _ card _ _), _, _, _, _)) forest) =
+  Node (query{joinConditions=joinConds}, nodeProps) (addJoinConditions tblAlias <$> forest)
+  where
+    joinConds =
+      case card of
+        M2M (Junction QualifiedIdentifier{qiName=jtn} _ _ jcols1 jcols2) ->
+           (toJoinCondition Nothing Nothing ftN jtn <$> jcols2) ++ (toJoinCondition previousAlias tblAlias tN jtn <$> jcols1)
+        O2M _ cols ->
+          toJoinCondition previousAlias tblAlias tN ftN <$> cols
+        M2O _ cols ->
+          toJoinCondition previousAlias tblAlias tN ftN <$> cols
+        O2O _ cols ->
+          toJoinCondition previousAlias tblAlias tN ftN <$> cols
+    toJoinCondition :: Maybe Alias -> Maybe Alias -> Text -> Text -> (FieldName, FieldName) -> JoinCondition
+    toJoinCondition prAl newAl tb ftb (c, fc) =
+      let qi1 = QualifiedIdentifier tSchema ftb
+          qi2 = QualifiedIdentifier tSchema tb in
+        JoinCondition (maybe qi1 (QualifiedIdentifier mempty) newAl, fc)
+                      (maybe qi2 (QualifiedIdentifier mempty) prAl, c)
+
 -- Finds a relationship between an origin and a target in the request:
 -- /origin?select=target(*) If more than one relationship is found then the
 -- request is ambiguous and we return an error.  In that case the request can
 -- be disambiguated by adding precision to the target or by using a hint:
--- /origin?select=target!hint(*) The elements will be matched according to
--- these rules:
--- origin = table / view
--- target = table / view / constraint / column-from-origin
--- hint   = table / view / constraint / column-from-origin / column-from-target
--- (hint can take table / view values to aid in finding the junction in an m2m relationship)
-findRel :: Schema -> [Relationship] -> NodeName -> NodeName -> Maybe EmbedHint -> Either ApiRequestError Relationship
+-- /origin?select=target!hint(*). The origin can be a table or view.
+findRel :: Schema -> RelationshipsMap -> NodeName -> NodeName -> Maybe Hint -> Either ApiRequestError Relationship
 findRel schema allRels origin target hint =
-  case rel of
-    []  -> Left $ NoRelBetween origin target
+  case rels of
+    []  -> Left $ NoRelBetween origin target schema
     [r] -> Right r
-    -- Here we handle a self reference relationship to not cause a breaking
-    -- change: In a self reference we get two relationships with the same
-    -- foreign key and relTable/relFtable but with different
-    -- cardinalities(m2o/o2m) We output the O2M rel, the M2O rel can be
-    -- obtained by using the origin column as an embed hint.
-    rs@[rel0, rel1]  -> case (relCardinality rel0, relCardinality rel1, relTable rel0 == relTable rel1 && relForeignTable rel0 == relForeignTable rel1) of
-      (O2M cons1, M2O cons2, True) -> if cons1 == cons2 then Right rel0 else Left $ AmbiguousRelBetween origin target rs
-      (M2O cons1, O2M cons2, True) -> if cons1 == cons2 then Right rel1 else Left $ AmbiguousRelBetween origin target rs
-      _                            -> Left $ AmbiguousRelBetween origin target rs
-    rs -> Left $ AmbiguousRelBetween origin target rs
+    rs  -> Left $ AmbiguousRelBetween origin target rs
   where
-    matchFKSingleCol hint_ cols = length cols == 1 && hint_ == (colName <$> head cols)
+    matchFKSingleCol hint_ card = case card of
+      O2M _ [(col, _)] -> hint_ == col
+      M2O _ [(col, _)] -> hint_ == col
+      O2O _ [(col, _)] -> hint_ == col
+      _                -> False
+    matchFKRefSingleCol hint_ card  = case card of
+      O2M _ [(_, fCol)] -> hint_ == fCol
+      M2O _ [(_, fCol)] -> hint_ == fCol
+      O2O _ [(_, fCol)] -> hint_ == fCol
+      _                 -> False
     matchConstraint tar card = case card of
-      O2M cons -> tar == Just cons
-      M2O cons -> tar == Just cons
-      _        -> False
+      O2M cons _ -> tar == cons
+      M2O cons _ -> tar == cons
+      O2O cons _ -> tar == cons
+      _          -> False
     matchJunction hint_ card = case card of
-      M2M Junction{junTable} -> hint_ == Just (tableName junTable)
+      M2M Junction{junTable} -> hint_ == qiName junTable
       _                      -> False
-    rel = filter (
-      \Relationship{..} ->
-        -- Both relationship ends need to be on the exposed schema
-        schema == tableSchema relTable && schema == tableSchema relForeignTable &&
-        (
-          -- /projects?select=clients(*)
-          origin == tableName relTable  &&  -- projects
-          target == tableName relForeignTable ||  -- clients
+    isM2O card = case card of
+      M2O _ _ -> True
+      _       -> False
+    isO2M card = case card of
+      O2M _ _ -> True
+      _       -> False
+    rels = filter (\case
+      ComputedRelationship{relFunction} -> target == qiName relFunction
+      Relationship{..} ->
+        -- In a self-relationship we have a single foreign key but two relationships with different cardinalities: M2O/O2M. For disambiguation, we use the convention of getting:
+        -- TODO: handle one-to-one and many-to-many self-relationships
+        if relIsSelf
+        then case hint of
+          Nothing ->
+            -- The O2M by using the table name in the target
+            target == qiName relForeignTable && isO2M relCardinality -- /family_tree?select=children:family_tree(*)
+            ||
+            -- The M2O by using the column name in the target
+            matchFKSingleCol target relCardinality && isM2O relCardinality -- /family_tree?select=parent(*)
+          Just hnt ->
+            -- /organizations?select=auditees:organizations!auditor(*)
+            target == qiName relForeignTable && isO2M relCardinality
+            && matchFKRefSingleCol hnt relCardinality -- auditor
+        else case hint of
+          -- target = table / view / constraint / column-from-origin (constraint/column-from-origin can only come from tables https://github.com/PostgREST/postgrest/issues/2277)
+          -- hint   = table / view / constraint / column-from-origin / column-from-target (hint can take table / view values to aid in finding the junction in an m2m relationship)
+          Nothing ->
+              -- /projects?select=clients(*)
+              target == qiName relForeignTable -- clients
+              ||
+              -- /projects?select=projects_client_id_fkey(*)
+              matchConstraint target relCardinality -- projects_client_id_fkey
+              && not relFTableIsView
+              ||
+              -- /projects?select=client_id(*)
+              matchFKSingleCol target relCardinality -- client_id
+              && not relFTableIsView
+          Just hnt ->
+            -- /projects?select=clients(*)
+            target == qiName relForeignTable -- clients
+            && (
+              -- /projects?select=clients!projects_client_id_fkey(*)
+              matchConstraint hnt relCardinality || -- projects_client_id_fkey
 
-          -- /projects?select=projects_client_id_fkey(*)
-          (
-            origin == tableName relTable &&              -- projects
-            matchConstraint (Just target) relCardinality -- projects_client_id_fkey
-          ) ||
-          -- /projects?select=client_id(*)
-          (
-            origin == tableName relTable &&           -- projects
-            matchFKSingleCol (Just target) relColumns -- client_id
-          )
-        ) && (
-          isNothing hint || -- hint is optional
+              -- /projects?select=clients!client_id(*) or /projects?select=clients!id(*)
+              matchFKSingleCol hnt relCardinality      || -- client_id
+              matchFKRefSingleCol hnt relCardinality   || -- id
 
-          -- /projects?select=clients!projects_client_id_fkey(*)
-          matchConstraint hint relCardinality || -- projects_client_id_fkey
+              -- /users?select=tasks!users_tasks(*) many-to-many between users and tasks
+              matchJunction hnt relCardinality -- users_tasks
+            )
+      ) $ fromMaybe mempty $ HM.lookup (QualifiedIdentifier schema origin, schema) allRels
 
-          -- /projects?select=clients!client_id(*) or /projects?select=clients!id(*)
-          matchFKSingleCol hint relColumns  || -- client_id
-          matchFKSingleCol hint relForeignColumns || -- id
-
-          -- /users?select=tasks!users_tasks(*) many-to-many between users and tasks
-          matchJunction hint relCardinality -- users_tasks
-        )
-      ) allRels
-
--- previousAlias is only used for the case of self joins
-addJoinConditions :: Maybe Alias -> ReadRequest -> Either ApiRequestError ReadRequest
-addJoinConditions previousAlias (Node node@(query@Select{from=tbl}, nodeProps@(_, rel, _, _, depth)) forest) =
-  case rel of
-    Just r@Relationship{relCardinality=M2M Junction{junTable}} ->
-      let rq = augmentQuery r in
-      Node (rq{implicitJoins=tableQi junTable:implicitJoins rq}, nodeProps) <$> updatedForest
-    Just r -> Node (augmentQuery r, nodeProps) <$> updatedForest
-    Nothing -> Node node <$> updatedForest
+addFilters :: ApiRequest -> ReadRequest -> Either ApiRequestError ReadRequest
+addFilters ApiRequest{..} rReq =
+  foldr addFilterToNode (Right rReq) flts
   where
-    newAlias = case Relationship.isSelfReference <$> rel of
-      Just True
-        | depth /= 0 -> Just (qiName tbl <> "_" <> show depth) -- root node doesn't get aliased
-        | otherwise  -> Nothing
-      _              -> Nothing
-    augmentQuery r =
-      foldr
-        (\jc rq@Select{joinConditions=jcs} -> rq{joinConditions=jc:jcs})
-        query{fromAlias=newAlias}
-        (getJoinConditions previousAlias newAlias r)
-    updatedForest = addJoinConditions newAlias `traverse` forest
+    QueryParams.QueryParams{..} = iQueryParams
+    flts =
+      case iAction of
+        ActionInvoke InvGet  -> qsFilters
+        ActionInvoke InvHead -> qsFilters
+        ActionInvoke _       -> qsFilters
+        ActionRead _         -> qsFilters
+        _                    -> qsFiltersNotRoot
 
--- previousAlias and newAlias are used in the case of self joins
-getJoinConditions :: Maybe Alias -> Maybe Alias -> Relationship -> [JoinCondition]
-getJoinConditions previousAlias newAlias (Relationship Table{tableSchema=tSchema, tableName=tN} cols Table{tableName=ftN} fCols card) =
-  case card of
-    M2M (Junction Table{tableName=jtn} _ jc1 _ jc2) ->
-      zipWith (toJoinCondition tN jtn) cols jc1 ++ zipWith (toJoinCondition ftN jtn) fCols jc2
-    _ ->
-      zipWith (toJoinCondition tN ftN) cols fCols
+    addFilterToNode :: (EmbedPath, Filter) -> Either ApiRequestError ReadRequest ->  Either ApiRequestError ReadRequest
+    addFilterToNode =
+      updateNode (\flt (Node (q@Select {where_=lf}, i) f) -> Node (q{ReadQuery.where_=addFilterToLogicForest flt lf}, i) f)
+
+addOrders :: ApiRequest -> ReadRequest -> Either ApiRequestError ReadRequest
+addOrders ApiRequest{..} rReq =
+  case iAction of
+    ActionMutate _ -> Right rReq
+    _              -> foldr addOrderToNode (Right rReq) qsOrder
   where
-    toJoinCondition :: Text -> Text -> Column -> Column -> JoinCondition
-    toJoinCondition tb ftb c fc =
-      let qi1 = removeSourceCTESchema tSchema tb
-          qi2 = removeSourceCTESchema tSchema ftb in
-        JoinCondition (maybe qi1 (QualifiedIdentifier mempty) previousAlias, colName c)
-                      (maybe qi2 (QualifiedIdentifier mempty) newAlias, colName fc)
+    QueryParams.QueryParams{..} = iQueryParams
 
-    -- On mutation and calling proc cases we wrap the target table in a WITH
-    -- {sourceCTEName} if this happens remove the schema `FROM
-    -- "schema"."{sourceCTEName}"` and use only the `FROM "{sourceCTEName}"`.
-    -- If the schema remains the FROM would be invalid.
-    removeSourceCTESchema :: Schema -> TableName -> QualifiedIdentifier
-    removeSourceCTESchema schema tbl = QualifiedIdentifier (if tbl == decodeUtf8 sourceCTEName then mempty else schema) tbl
+    addOrderToNode :: (EmbedPath, [OrderTerm]) -> Either ApiRequestError ReadRequest -> Either ApiRequestError ReadRequest
+    addOrderToNode = updateNode (\o (Node (q,i) f) -> Node (q{order=o}, i) f)
 
-addFiltersOrdersRanges :: ApiRequest -> ReadRequest -> Either ApiRequestError ReadRequest
-addFiltersOrdersRanges apiRequest rReq = do
-  rFlts <- foldr addFilter rReq <$> filters
-  rOrds <- foldr addOrder rFlts <$> orders
-  rRngs <- foldr addRange rOrds <$> ranges
-  foldr addLogicTree rRngs      <$> logicForest
+addRanges :: ApiRequest -> ReadRequest -> Either ApiRequestError ReadRequest
+addRanges ApiRequest{..} rReq =
+  case iAction of
+    ActionMutate _ -> Right rReq
+    _              -> foldr addRangeToNode (Right rReq) =<< ranges
   where
-    filters :: Either ApiRequestError [(EmbedPath, Filter)]
-    filters = pRequestFilter `traverse` flts
-    orders :: Either ApiRequestError [(EmbedPath, [OrderTerm])]
-    orders = pRequestOrder `traverse` iOrder apiRequest
     ranges :: Either ApiRequestError [(EmbedPath, NonnegRange)]
-    ranges = pRequestRange `traverse` M.toList (iRange apiRequest)
-    logicForest :: Either ApiRequestError [(EmbedPath, LogicTree)]
-    logicForest = pRequestLogicTree `traverse` logFrst
-    action = iAction apiRequest
-    -- there can be no filters on the root table when we are doing insert/update/delete
-    (flts, logFrst) =
-      case action of
-        ActionInvoke _ -> (iFilters apiRequest, iLogic apiRequest)
-        ActionRead _   -> (iFilters apiRequest, iLogic apiRequest)
-        _              -> join (***) (filter (( "." `isInfixOf` ) . fst)) (iFilters apiRequest, iLogic apiRequest)
+    ranges = first QueryParamError $ QueryParams.pRequestRange `traverse` HM.toList iRange
 
-addFilterToNode :: Filter -> ReadRequest -> ReadRequest
-addFilterToNode flt (Node (q@Select {where_=lf}, i) f) = Node (q{where_=addFilterToLogicForest flt lf}::ReadQuery, i) f
+    addRangeToNode :: (EmbedPath, NonnegRange) -> Either ApiRequestError ReadRequest -> Either ApiRequestError ReadRequest
+    addRangeToNode = updateNode (\r (Node (q,i) f) -> Node (q{range_=r}, i) f)
 
-addFilter :: (EmbedPath, Filter) -> ReadRequest -> ReadRequest
-addFilter = addProperty addFilterToNode
-
-addOrderToNode :: [OrderTerm] -> ReadRequest -> ReadRequest
-addOrderToNode o (Node (q,i) f) = Node (q{order=o}, i) f
-
-addOrder :: (EmbedPath, [OrderTerm]) -> ReadRequest -> ReadRequest
-addOrder = addProperty addOrderToNode
-
-addRangeToNode :: NonnegRange -> ReadRequest -> ReadRequest
-addRangeToNode r (Node (q,i) f) = Node (q{range_=r}, i) f
-
-addRange :: (EmbedPath, NonnegRange) -> ReadRequest -> ReadRequest
-addRange = addProperty addRangeToNode
-
-addLogicTreeToNode :: LogicTree -> ReadRequest -> ReadRequest
-addLogicTreeToNode t (Node (q@Select{where_=lf},i) f) = Node (q{where_=t:lf}::ReadQuery, i) f
-
-addLogicTree :: (EmbedPath, LogicTree) -> ReadRequest -> ReadRequest
-addLogicTree = addProperty addLogicTreeToNode
-
-addProperty :: (a -> ReadRequest -> ReadRequest) -> (EmbedPath, a) -> ReadRequest -> ReadRequest
-addProperty f ([], a) rr = f a rr
-addProperty f (targetNodeName:remainingPath, a) (Node rn forest) =
-  case pathNode of
-    Nothing -> Node rn forest -- the property is silenty dropped in the Request does not contain the required path
-    Just tn -> Node rn (addProperty f (remainingPath, a) tn:delete tn forest)
+addLogicTrees :: ApiRequest -> ReadRequest -> Either ApiRequestError ReadRequest
+addLogicTrees ApiRequest{..} rReq =
+  foldr addLogicTreeToNode (Right rReq) qsLogic
   where
-    pathNode = find (\(Node (_,(nodeName,_,alias,_,_)) _) -> nodeName == targetNodeName || alias == Just targetNodeName) forest
+    QueryParams.QueryParams{..} = iQueryParams
 
-mutateRequest :: Schema -> TableName -> ApiRequest -> [FieldName] -> ReadRequest -> Either Error MutateRequest
-mutateRequest schema tName apiRequest pkCols readReq = mapLeft ApiRequestError $
-  case action of
-    ActionCreate -> do
-        confCols <- case iOnConflict apiRequest of
-            Nothing    -> pure pkCols
-            Just param -> pRequestOnConflict param
-        pure $ Insert qi (iColumns apiRequest) body ((,) <$> iPreferResolution apiRequest <*> Just confCols) [] returnings
-    ActionUpdate -> Update qi (iColumns apiRequest) body  <$> combinedLogic <*> pure returnings
-    ActionSingleUpsert ->
-      (\flts ->
-        if null (iLogic apiRequest) &&
-           S.fromList (fst <$> iFilters apiRequest) == S.fromList pkCols &&
+    addLogicTreeToNode :: (EmbedPath, LogicTree) -> Either ApiRequestError ReadRequest -> Either ApiRequestError ReadRequest
+    addLogicTreeToNode = updateNode (\t (Node (q@Select{where_=lf},i) f) -> Node (q{ReadQuery.where_=t:lf}, i) f)
+
+-- Find a Node of the Tree and apply a function to it
+updateNode :: (a -> ReadRequest -> ReadRequest) -> (EmbedPath, a) -> Either ApiRequestError ReadRequest -> Either ApiRequestError ReadRequest
+updateNode f ([], a) rr = f a <$> rr
+updateNode _ _ (Left e) = Left e
+updateNode f (targetNodeName:remainingPath, a) (Right (Node rootNode forest)) =
+  case findNode of
+    Nothing -> Left $ NotEmbedded targetNodeName
+    Just target ->
+      (\node -> Node rootNode $ node : delete target forest) <$>
+      updateNode f (remainingPath, a) (Right target)
+  where
+    findNode :: Maybe ReadRequest
+    findNode = find (\(Node (_,(nodeName,_,alias,_,_, _)) _) -> nodeName == targetNodeName || alias == Just targetNodeName) forest
+
+mutateRequest :: Mutation -> Schema -> TableName -> ApiRequest -> [FieldName] -> ReadRequest -> Either Error MutateRequest
+mutateRequest mutation schema tName ApiRequest{..} pkCols readReq = mapLeft ApiRequestError $
+  case mutation of
+    MutationCreate ->
+      Right $ Insert qi iColumns body ((,) <$> iPreferResolution <*> Just confCols) [] returnings
+    MutationUpdate -> Right $ Update qi iColumns body combinedLogic iTopLevelRange rootOrder returnings
+    MutationSingleUpsert ->
+        if null qsLogic &&
+           qsFilterFields == S.fromList pkCols &&
            not (null (S.fromList pkCols)) &&
            all (\case
-              Filter _ (OpExpr False (Op "eq" _)) -> True
-              _                                   -> False) flts
-          then Insert qi (iColumns apiRequest) body (Just (MergeDuplicates, pkCols)) <$> combinedLogic <*> pure returnings
+              Filter _ (OpExpr False (Op OpEqual _)) -> True
+              _                                      -> False) qsFiltersRoot
+          then Right $ Insert qi iColumns body (Just (MergeDuplicates, pkCols)) combinedLogic returnings
         else
-          Left InvalidFilters) =<< filters
-    ActionDelete -> Delete qi <$> combinedLogic <*> pure returnings
-    _            -> Left UnsupportedVerb
+          Left InvalidFilters
+    MutationDelete -> Right $ Delete qi combinedLogic iTopLevelRange rootOrder returnings
   where
+    confCols = fromMaybe pkCols qsOnConflict
+    QueryParams.QueryParams{..} = iQueryParams
     qi = QualifiedIdentifier schema tName
-    action = iAction apiRequest
     returnings =
-      if iPreferRepresentation apiRequest == None
+      if iPreferRepresentation == None
         then []
         else returningCols readReq pkCols
-    filters = map snd <$> pRequestFilter `traverse` mutateFilters
-    logic = map snd <$> pRequestLogicTree `traverse` logicFilters
-    combinedLogic = foldr addFilterToLogicForest <$> logic <*> filters
-    -- update/delete filters can be only on the root table
-    (mutateFilters, logicFilters) = join (***) onlyRoot (iFilters apiRequest, iLogic apiRequest)
-    onlyRoot = filter (not . ( "." `isInfixOf` ) . fst)
-    body = pjRaw <$> iPayload apiRequest
+    logic = map snd qsLogic
+    rootOrder = maybe [] snd $ find (\(x, _) -> null x) qsOrder
+    combinedLogic = foldr addFilterToLogicForest logic qsFiltersRoot
+    body = payRaw <$> iPayload -- the body is assumed to be json at this stage(ApiRequest validates)
+
+callRequest :: ProcDescription -> ApiRequest -> ReadRequest -> CallRequest
+callRequest proc apiReq readReq = FunctionCall {
+  funCQi = QualifiedIdentifier (pdSchema proc) (pdName proc)
+, funCParams = callParams
+, funCArgs = payRaw <$> iPayload apiReq
+, funCScalar = procReturnsScalar proc
+, funCMultipleCall = iPreferParameters apiReq == Just MultipleObjects
+, funCReturning = returningCols readReq []
+}
+  where
+    paramsAsSingleObject = iPreferParameters apiReq == Just SingleObject
+    callParams = case pdParams proc of
+      [prm] | paramsAsSingleObject -> OnePosParam prm
+            | ppName prm == mempty -> OnePosParam prm
+            | otherwise            -> KeyParams $ specifiedParams [prm]
+      prms  -> KeyParams $ specifiedParams prms
+    specifiedParams = filter (\x -> ppName x `S.member` iColumns apiReq)
 
 returningCols :: ReadRequest -> [FieldName] -> [FieldName]
 returningCols rr@(Node _ forest) pkCols
@@ -358,9 +367,16 @@ returningCols rr@(Node _ forest) pkCols
     -- projects.  So this adds the foreign key columns to ensure the embedding
     -- succeeds, result would be `RETURNING name, client_id`.
     fkCols = concat $ mapMaybe (\case
-        Node (_, (_, Just Relationship{relColumns=cols}, _, _, _)) _ -> Just cols
+        Node (_, (_, Just Relationship{relCardinality=O2M _ cols}, _, _, _, _)) _ -> Just $ fst <$> cols
+        Node (_, (_, Just Relationship{relCardinality=M2O _ cols}, _, _, _, _)) _ -> Just $ fst <$> cols
+        Node (_, (_, Just Relationship{relCardinality=O2O _ cols}, _, _, _, _)) _ -> Just $ fst <$> cols
+        Node (_, (_, Just Relationship{relCardinality=M2M Junction{junColumns1, junColumns2}}, _, _, _, _)) _ -> Just $ (fst <$> junColumns1) ++ (fst <$> junColumns2)
         _                                                        -> Nothing
       ) forest
+    hasComputedRel = isJust $ find (\case
+      Node (_, (_, Just ComputedRelationship{}, _, _, _, _)) _ -> True
+      _ -> False
+      ) forest
     -- However if the "client_id" is present, e.g. mutateRequest to
     -- /projects?select=client_id,name,clients(name) we would get `RETURNING
     -- client_id, name, client_id` and then we would produce the "column
@@ -368,7 +384,10 @@ returningCols rr@(Node _ forest) pkCols
     -- deduplicate with Set: We are adding the primary key columns as well to
     -- make sure, that a proper location header can always be built for
     -- INSERT/POST
-    returnings = S.toList . S.fromList $ fldNames ++ (colName <$> fkCols) ++ pkCols
+    returnings =
+      if not hasComputedRel
+        then S.toList . S.fromList $ fldNames ++ fkCols ++ pkCols
+        else ["*"] -- on computed relationships we cannot know the required columns for an embedding to succeed, so we just return all
 
 -- Traditional filters(e.g. id=eq.1) are added as root nodes of the LogicTree
 -- they are later concatenated with AND in the QueryBuilder

src/PostgREST/Request/MutateQuery.hs

@@ -0,0 +1,44 @@
+module PostgREST.Request.MutateQuery
+  ( MutateQuery(..)
+  , MutateRequest
+  )
+where
+
+import qualified Data.ByteString.Lazy as LBS
+import qualified Data.Set             as S
+
+import PostgREST.DbStructure.Identifiers (FieldName,
+                                          QualifiedIdentifier)
+import PostgREST.RangeQuery              (NonnegRange)
+import PostgREST.Request.Preferences     (PreferResolution)
+import PostgREST.Request.Types           (LogicTree, OrderTerm)
+
+import Protolude
+
+type MutateRequest = MutateQuery
+
+data MutateQuery
+  = Insert
+      { in_        :: QualifiedIdentifier
+      , insCols    :: S.Set FieldName
+      , insBody    :: Maybe LBS.ByteString
+      , onConflict :: Maybe (PreferResolution, [FieldName])
+      , where_     :: [LogicTree]
+      , returning  :: [FieldName]
+      }
+  | Update
+      { in_       :: QualifiedIdentifier
+      , updCols   :: S.Set FieldName
+      , updBody   :: Maybe LBS.ByteString
+      , where_    :: [LogicTree]
+      , mutRange  :: NonnegRange
+      , mutOrder  :: [OrderTerm]
+      , returning :: [FieldName]
+      }
+  | Delete
+      { in_       :: QualifiedIdentifier
+      , where_    :: [LogicTree]
+      , mutRange  :: NonnegRange
+      , mutOrder  :: [OrderTerm]
+      , returning :: [FieldName]
+      }

src/PostgREST/Request/Parsers.hs

@@ -1,276 +0,0 @@
-{-|
-Module      : PostgREST.Request.Parsers
-Description : PostgREST parser combinators
-
-This module is in charge of parsing all the querystring values in an url, e.g. the select, id, order in `/projects?select=id,name&id=eq.1&order=id,name.desc`.
--}
-module PostgREST.Request.Parsers
-  ( pColumns
-  , pLogicPath
-  , pLogicSingleVal
-  , pLogicTree
-  , pOrder
-  , pOrderTerm
-  , pRequestColumns
-  , pRequestFilter
-  , pRequestLogicTree
-  , pRequestOnConflict
-  , pRequestOrder
-  , pRequestRange
-  , pRequestSelect
-  , pSingleVal
-  , pTreePath
-  ) where
-
-import qualified Data.HashMap.Strict as M
-import qualified Data.Set            as S
-
-import Data.Either.Combinators       (mapLeft)
-import Data.Foldable                 (foldl1)
-import Data.List                     (init, last)
-import Data.Text                     (intercalate, replace, strip)
-import Data.Tree                     (Tree (..))
-import Text.Parsec.Error             (errorMessages,
-                                      showErrorMessages)
-import Text.ParserCombinators.Parsec (GenParser, ParseError, Parser,
-                                      anyChar, between, char, digit,
-                                      eof, errorPos, letter,
-                                      lookAhead, many1, noneOf,
-                                      notFollowedBy, oneOf, option,
-                                      optionMaybe, parse, sepBy1,
-                                      string, try, (<?>))
-
-import PostgREST.DbStructure.Identifiers (FieldName)
-import PostgREST.Error                   (ApiRequestError (ParseRequestError))
-import PostgREST.Query.SqlFragment       (ftsOperators, operators)
-import PostgREST.RangeQuery              (NonnegRange)
-
-import PostgREST.Request.Types
-
-import Protolude      hiding (intercalate, option, replace, toS, try)
-import Protolude.Conv (toS)
-
-pRequestSelect :: Text -> Either ApiRequestError [Tree SelectItem]
-pRequestSelect selStr =
-  mapError $ parse pFieldForest ("failed to parse select parameter (" <> toS selStr <> ")") (toS selStr)
-
-pRequestOnConflict :: Text -> Either ApiRequestError  [FieldName]
-pRequestOnConflict oncStr =
-  mapError $ parse pColumns ("failed to parse on_conflict parameter (" <> toS oncStr <> ")") (toS oncStr)
-
-pRequestFilter :: (Text, Text) -> Either ApiRequestError (EmbedPath, Filter)
-pRequestFilter (k, v) = mapError $ (,) <$> path <*> (Filter <$> fld <*> oper)
-  where
-    treePath = parse pTreePath ("failed to parser tree path (" ++ toS k ++ ")") $ toS k
-    oper = parse (pOpExpr pSingleVal) ("failed to parse filter (" ++ toS v ++ ")") $ toS v
-    path = fst <$> treePath
-    fld = snd <$> treePath
-
-pRequestOrder :: (Text, Text) -> Either ApiRequestError (EmbedPath, [OrderTerm])
-pRequestOrder (k, v) = mapError $ (,) <$> path <*> ord'
-  where
-    treePath = parse pTreePath ("failed to parser tree path (" ++ toS k ++ ")") $ toS k
-    path = fst <$> treePath
-    ord' = parse pOrder ("failed to parse order (" ++ toS v ++ ")") $ toS v
-
-pRequestRange :: (ByteString, NonnegRange) -> Either ApiRequestError (EmbedPath, NonnegRange)
-pRequestRange (k, v) = mapError $ (,) <$> path <*> pure v
-  where
-    treePath = parse pTreePath ("failed to parser tree path (" ++ toS k ++ ")") $ toS k
-    path = fst <$> treePath
-
-pRequestLogicTree :: (Text, Text) -> Either ApiRequestError (EmbedPath, LogicTree)
-pRequestLogicTree (k, v) = mapError $ (,) <$> embedPath <*> logicTree
-  where
-    path = parse pLogicPath ("failed to parser logic path (" ++ toS k ++ ")") $ toS k
-    embedPath = fst <$> path
-    logicTree = do
-      op <- snd <$> path
-      -- Concat op and v to make pLogicTree argument regular,
-      -- in the form of "?and=and(.. , ..)" instead of "?and=(.. , ..)"
-      parse pLogicTree ("failed to parse logic tree (" ++ toS v ++ ")") $ toS (op <> v)
-
-pRequestColumns :: Maybe Text -> Either ApiRequestError (Maybe (S.Set FieldName))
-pRequestColumns colStr =
-  case colStr of
-    Just str ->
-      mapError $ Just . S.fromList <$> parse pColumns ("failed to parse columns parameter (" <> toS str <> ")") (toS str)
-    _ -> Right Nothing
-
-ws :: Parser Text
-ws = toS <$> many (oneOf " \t")
-
-lexeme :: Parser a -> Parser a
-lexeme p = ws *> p <* ws
-
-pTreePath :: Parser (EmbedPath, Field)
-pTreePath = do
-  p <- pFieldName `sepBy1` pDelimiter
-  jp <- option [] pJsonPath
-  return (init p, (last p, jp))
-
-pFieldForest :: Parser [Tree SelectItem]
-pFieldForest = pFieldTree `sepBy1` lexeme (char ',')
-  where
-    pFieldTree :: Parser (Tree SelectItem)
-    pFieldTree =  try (Node <$> pRelationSelect <*> between (char '(') (char ')') pFieldForest) <|>
-                  Node <$> pFieldSelect <*> pure []
-
-pStar :: Parser Text
-pStar = toS <$> (string "*" $> ("*"::ByteString))
-
-pFieldName :: Parser Text
-pFieldName =
-  pQuotedValue <|>
-  intercalate "-" . map toS <$> (many1 (letter <|> digit <|> oneOf "_ ") `sepBy1` dash) <?>
-  "field name (* or [a..z0..9_])"
-  where
-    isDash :: GenParser Char st ()
-    isDash = try ( char '-' >> notFollowedBy (char '>') )
-    dash :: Parser Char
-    dash = isDash $> '-'
-
-pJsonPath :: Parser JsonPath
-pJsonPath = many pJsonOperation
-  where
-    pJsonOperation :: Parser JsonOperation
-    pJsonOperation = pJsonArrow <*> pJsonOperand
-
-    pJsonArrow   =
-      try (string "->>" $> J2Arrow) <|>
-      try (string "->" $> JArrow)
-
-    pJsonOperand =
-      let pJKey = JKey . toS <$> pFieldName
-          pJIdx = JIdx . toS <$> ((:) <$> option '+' (char '-') <*> many1 digit) <* pEnd
-          pEnd = try (void $ lookAhead (string "->")) <|>
-                 try (void $ lookAhead (string "::")) <|>
-                 try eof in
-      try pJIdx <|> try pJKey
-
-pField :: Parser Field
-pField = lexeme $ (,) <$> pFieldName <*> option [] pJsonPath
-
-aliasSeparator :: Parser ()
-aliasSeparator = char ':' >> notFollowedBy (char ':')
-
-pRelationSelect :: Parser SelectItem
-pRelationSelect = lexeme $ try ( do
-    alias <- optionMaybe ( try(pFieldName <* aliasSeparator) )
-    fld <- pField
-    hint <- optionMaybe (
-        try ( char '!' *> pFieldName) <|>
-        -- deprecated, remove in next major version
-        try ( char '.' *> pFieldName)
-      )
-    return (fld, Nothing, alias, hint)
-  )
-
-pFieldSelect :: Parser SelectItem
-pFieldSelect = lexeme $
-  try (
-    do
-      alias <- optionMaybe ( try(pFieldName <* aliasSeparator) )
-      fld <- pField
-      cast' <- optionMaybe (string "::" *> many letter)
-      return (fld, toS <$> cast', alias, Nothing)
-  )
-  <|> do
-    s <- pStar
-    return ((s, []), Nothing, Nothing, Nothing)
-
-pOpExpr :: Parser SingleVal -> Parser OpExpr
-pOpExpr pSVal = try ( string "not" *> pDelimiter *> (OpExpr True <$> pOperation)) <|> OpExpr False <$> pOperation
-  where
-    pOperation :: Parser Operation
-    pOperation =
-          Op . toS <$> foldl1 (<|>) (try . ((<* pDelimiter) . string) . toS <$> M.keys ops) <*> pSVal
-      <|> In <$> (try (string "in" *> pDelimiter) *> pListVal)
-      <|> pFts
-      <?> "operator (eq, gt, ...)"
-
-    pFts = do
-      op   <- foldl1 (<|>) (try . string . toS <$> ftsOps)
-      lang <- optionMaybe $ try (between (char '(') (char ')') (many (letter <|> digit <|> oneOf "_")))
-      pDelimiter >> Fts (toS op) (toS <$> lang) <$> pSVal
-
-    ops = M.filterWithKey (const . flip notElem ("in":ftsOps)) operators
-    ftsOps = M.keys ftsOperators
-
-pSingleVal :: Parser SingleVal
-pSingleVal = toS <$> many anyChar
-
-pListVal :: Parser ListVal
-pListVal = lexeme (char '(') *> pListElement `sepBy1` char ',' <* lexeme (char ')')
-
-pListElement :: Parser Text
-pListElement = try (pQuotedValue <* notFollowedBy (noneOf ",)")) <|> (toS <$> many (noneOf ",)"))
-
-pQuotedValue :: Parser Text
-pQuotedValue = toS <$> (char '"' *> many (noneOf "\"") <* char '"')
-
-pDelimiter :: Parser Char
-pDelimiter = char '.' <?> "delimiter (.)"
-
-pOrder :: Parser [OrderTerm]
-pOrder = lexeme pOrderTerm `sepBy1` char ','
-
-pOrderTerm :: Parser OrderTerm
-pOrderTerm = do
-  fld <- pField
-  dir <- optionMaybe $
-         try (pDelimiter *> string "asc" $> OrderAsc) <|>
-         try (pDelimiter *> string "desc" $> OrderDesc)
-  nls <- optionMaybe pNulls <* pEnd <|>
-         pEnd $> Nothing
-  return $ OrderTerm fld dir nls
-  where
-    pNulls = try (pDelimiter *> string "nullsfirst" $> OrderNullsFirst) <|>
-             try (pDelimiter *> string "nullslast"  $> OrderNullsLast)
-    pEnd = try (void $ lookAhead (char ',')) <|>
-           try eof
-
-pLogicTree :: Parser LogicTree
-pLogicTree = Stmnt <$> try pLogicFilter
-             <|> Expr <$> pNot <*> pLogicOp <*> (lexeme (char '(') *> pLogicTree `sepBy1` lexeme (char ',') <* lexeme (char ')'))
-  where
-    pLogicFilter :: Parser Filter
-    pLogicFilter = Filter <$> pField <* pDelimiter <*> pOpExpr pLogicSingleVal
-    pNot :: Parser Bool
-    pNot = try (string "not" *> pDelimiter $> True)
-           <|> pure False
-           <?> "negation operator (not)"
-    pLogicOp :: Parser LogicOperator
-    pLogicOp = try (string "and" $> And)
-               <|> string "or" $> Or
-               <?> "logic operator (and, or)"
-
-pLogicSingleVal :: Parser SingleVal
-pLogicSingleVal = try (pQuotedValue <* notFollowedBy (noneOf ",)")) <|> try pPgArray <|> (toS <$> many (noneOf ",)"))
-  where
-    pPgArray :: Parser Text
-    pPgArray =  do
-      a <- string "{"
-      b <- many (noneOf "{}")
-      c <- string "}"
-      pure (toS $ a ++ b ++ c)
-
-pLogicPath :: Parser (EmbedPath, Text)
-pLogicPath = do
-  path <- pFieldName `sepBy1` pDelimiter
-  let op = last path
-      notOp = "not." <> op
-  return (filter (/= "not") (init path), if "not" `elem` path then notOp else op)
-
-pColumns :: Parser [FieldName]
-pColumns = pFieldName `sepBy1` lexeme (char ',')
-
-mapError :: Either ParseError a -> Either ApiRequestError a
-mapError = mapLeft translateError
-  where
-    translateError e =
-      ParseRequestError message details
-      where
-        message = show $ errorPos e
-        details = strip $ replace "\n" " " $ toS
-           $ showErrorMessages "or" "unknown parse error" "expecting" "unexpected" "end of input" (errorMessages e)

src/PostgREST/Request/Preferences.hs

@@ -1,54 +1,200 @@
-module PostgREST.Request.Preferences where
+-- |
+-- Module: PostgREST.Request.Preferences
+-- Description: Track client preferences to be employed when processing requests
+--
+-- Track client prefences set in HTTP 'Prefer' headers according to RFC7240[1].
+--
+-- [1] https://datatracker.ietf.org/doc/html/rfc7240
+--
+module PostgREST.Request.Preferences
+  ( Preferences(..)
+  , PreferCount(..)
+  , PreferParameters(..)
+  , PreferRepresentation(..)
+  , PreferResolution(..)
+  , PreferTransaction(..)
+  , fromHeaders
+  , ToAppliedHeader(..)
+  ) where
+
+import qualified Data.ByteString.Char8     as BS
+import qualified Data.Map                  as Map
+import qualified Network.HTTP.Types.Header as HTTP
 
-import GHC.Show
 import Protolude
 
 
+-- $setup
+-- Setup for doctests
+-- >>> import Text.Pretty.Simple (pPrint)
+-- >>> deriving instance Show PreferResolution
+-- >>> deriving instance Show PreferRepresentation
+-- >>> deriving instance Show PreferParameters
+-- >>> deriving instance Show PreferCount
+-- >>> deriving instance Show PreferTransaction
+-- >>> deriving instance Show Preferences
+
+-- | Preferences recognized by the application.
+data Preferences
+  = Preferences
+    { preferResolution     :: Maybe PreferResolution
+    , preferRepresentation :: Maybe PreferRepresentation
+    , preferParameters     :: Maybe PreferParameters
+    , preferCount          :: Maybe PreferCount
+    , preferTransaction    :: Maybe PreferTransaction
+    }
+
+-- |
+-- Parse HTTP headers based on RFC7240[1] to identify preferences.
+--
+-- One header with comma-separated values can be used to set multiple preferences:
+--
+-- >>> pPrint $ fromHeaders [("Prefer", "resolution=ignore-duplicates, count=exact")]
+-- Preferences
+--     { preferResolution = Just IgnoreDuplicates
+--     , preferRepresentation = Nothing
+--     , preferParameters = Nothing
+--     , preferCount = Just ExactCount
+--     , preferTransaction = Nothing
+--     }
+--
+-- Multiple headers can also be used:
+--
+-- >>> pPrint $ fromHeaders [("Prefer", "resolution=ignore-duplicates"), ("Prefer", "count=exact")]
+-- Preferences
+--     { preferResolution = Just IgnoreDuplicates
+--     , preferRepresentation = Nothing
+--     , preferParameters = Nothing
+--     , preferCount = Just ExactCount
+--     , preferTransaction = Nothing
+--     }
+--
+-- If a preference is set more than once, only the first is used:
+--
+-- >>> preferTransaction $ fromHeaders [("Prefer", "tx=commit, tx=rollback")]
+-- Just Commit
+--
+-- This is also the case across multiple headers:
+--
+-- >>> :{
+--   preferResolution . fromHeaders $
+--     [ ("Prefer", "resolution=ignore-duplicates")
+--     , ("Prefer", "resolution=merge-duplicates")
+--     ]
+-- :}
+-- Just IgnoreDuplicates
+--
+-- Preferences not recognized by the application are ignored:
+--
+-- >>> preferResolution $ fromHeaders [("Prefer", "resolution=foo")]
+-- Nothing
+--
+-- Preferences can be separated by arbitrary amounts of space, lower-case header is also recognized:
+--
+-- >>> pPrint $ fromHeaders [("prefer", "count=exact,    tx=commit   ,return=minimal")]
+-- Preferences
+--     { preferResolution = Nothing
+--     , preferRepresentation = Just None
+--     , preferParameters = Nothing
+--     , preferCount = Just ExactCount
+--     , preferTransaction = Just Commit
+--     }
+--
+fromHeaders :: [HTTP.Header] -> Preferences
+fromHeaders headers =
+  Preferences
+    { preferResolution = parsePrefs [MergeDuplicates, IgnoreDuplicates]
+    , preferRepresentation = parsePrefs [Full, None, HeadersOnly]
+    , preferParameters = parsePrefs [SingleObject, MultipleObjects]
+    , preferCount = parsePrefs [ExactCount, PlannedCount, EstimatedCount]
+    , preferTransaction = parsePrefs [Commit, Rollback]
+    }
+  where
+    prefHeaders = filter ((==) HTTP.hPrefer . fst) headers
+    prefs = fmap BS.strip . concatMap (BS.split ',' . snd) $ prefHeaders
+
+    parsePrefs :: ToHeaderValue a => [a] -> Maybe a
+    parsePrefs vals =
+      head $ mapMaybe (flip Map.lookup $ prefMap vals) prefs
+
+    prefMap :: ToHeaderValue a => [a] -> Map.Map ByteString a
+    prefMap = Map.fromList . fmap (\pref -> (toHeaderValue pref, pref))
+
+-- |
+-- Convert a preference into the value that we look for in the 'Prefer' headers.
+--
+-- >>> toHeaderValue MergeDuplicates
+-- "resolution=merge-duplicates"
+--
+class ToHeaderValue a where
+  toHeaderValue :: a -> ByteString
+
+-- |
+-- Header to indicate that a preference has been applied.
+--
+-- >>> toAppliedHeader MergeDuplicates
+-- ("Preference-Applied","resolution=merge-duplicates")
+--
+class ToHeaderValue a => ToAppliedHeader a where
+  toAppliedHeader :: a -> HTTP.Header
+  toAppliedHeader x = (HTTP.hPreferenceApplied, toHeaderValue x)
+
+-- | How to handle duplicate values.
 data PreferResolution
   = MergeDuplicates
   | IgnoreDuplicates
 
-instance Show PreferResolution where
-  show MergeDuplicates  = "resolution=merge-duplicates"
-  show IgnoreDuplicates = "resolution=ignore-duplicates"
+instance ToHeaderValue PreferResolution where
+  toHeaderValue MergeDuplicates  = "resolution=merge-duplicates"
+  toHeaderValue IgnoreDuplicates = "resolution=ignore-duplicates"
 
--- | How to return the mutated data. From https://tools.ietf.org/html/rfc7240#section-4.2
+instance ToAppliedHeader PreferResolution
+
+-- |
+-- How to return the mutated data.
+--
+-- From https://tools.ietf.org/html/rfc7240#section-4.2
 data PreferRepresentation
-  = Full        -- ^ Return the body plus the Location header(in case of POST).
+  = Full        -- ^ Return the body.
   | HeadersOnly -- ^ Return the Location header(in case of POST). This needs a SELECT privilege on the pk.
   | None        -- ^ Return nothing from the mutated data.
   deriving Eq
 
-instance Show PreferRepresentation where
-  show Full        = "return=representation"
-  show None        = "return=minimal"
-  show HeadersOnly = "return=headers-only"
+instance ToHeaderValue PreferRepresentation where
+  toHeaderValue Full        = "return=representation"
+  toHeaderValue None        = "return=minimal"
+  toHeaderValue HeadersOnly = "return=headers-only"
 
+-- | How to pass parameters to stored procedures.
 data PreferParameters
-  = SingleObject    -- ^ Pass all parameters as a single json object to a stored procedure
-  | MultipleObjects -- ^ Pass an array of json objects as params to a stored procedure
+  = SingleObject    -- ^ Pass all parameters as a single json object to a stored procedure.
+  | MultipleObjects -- ^ Pass an array of json objects as params to a stored procedure.
   deriving Eq
 
-instance Show PreferParameters where
-  show SingleObject    = "params=single-object"
-  show MultipleObjects = "params=multiple-objects"
+instance ToHeaderValue PreferParameters where
+  toHeaderValue SingleObject    = "params=single-object"
+  toHeaderValue MultipleObjects = "params=multiple-objects"
 
+-- | How to determine the count of (expected) results
 data PreferCount
-  = ExactCount     -- ^ exact count(slower)
+  = ExactCount     -- ^ Exact count (slower).
   | PlannedCount   -- ^ PostgreSQL query planner rows count guess. Done by using EXPLAIN {query}.
-  | EstimatedCount -- ^ use the query planner rows if the count is superior to max-rows, otherwise get the exact count.
+  | EstimatedCount -- ^ Use the query planner rows if the count is superior to max-rows, otherwise get the exact count.
   deriving Eq
 
-instance Show PreferCount where
-  show ExactCount     = "count=exact"
-  show PlannedCount   = "count=planned"
-  show EstimatedCount = "count=estimated"
+instance ToHeaderValue PreferCount where
+  toHeaderValue ExactCount     = "count=exact"
+  toHeaderValue PlannedCount   = "count=planned"
+  toHeaderValue EstimatedCount = "count=estimated"
 
+-- | Whether to commit or roll back transactions.
 data PreferTransaction
-  = Commit   -- Commit transaction - the default.
-  | Rollback -- Rollback transaction after sending the response - does not persist changes, e.g. for running tests.
+  = Commit   -- ^ Commit transaction - the default.
+  | Rollback -- ^ Rollback transaction after sending the response - does not persist changes, e.g. for running tests.
   deriving Eq
 
-instance Show PreferTransaction where
-  show Commit   = "tx=commit"
-  show Rollback = "tx=rollback"
+instance ToHeaderValue PreferTransaction where
+  toHeaderValue Commit   = "tx=commit"
+  toHeaderValue Rollback = "tx=rollback"
+
+instance ToAppliedHeader PreferTransaction

src/PostgREST/Request/QueryParams.hs

@@ -0,0 +1,523 @@
+-- |
+-- Module      : PostgREST.Request.QueryParams
+-- Description : Parser for PostgREST Query paramters
+--
+-- This module is in charge of parsing all the querystring values in an url, e.g.
+-- the select, id, order in `/projects?select=id,name&id=eq.1&order=id,name.desc`.
+{-# LANGUAGE LambdaCase    #-}
+{-# LANGUAGE TupleSections #-}
+module PostgREST.Request.QueryParams
+  ( parse
+  , QueryParams(..)
+  , pRequestRange
+  ) where
+
+import qualified Data.ByteString.Char8         as BS
+import qualified Data.HashMap.Strict           as HM
+import qualified Data.List                     as L
+import qualified Data.Set                      as S
+import qualified Data.Text                     as T
+import qualified Data.Text.Encoding            as T
+import qualified Network.HTTP.Base             as HTTP
+import qualified Network.HTTP.Types.URI        as HTTP
+import qualified Text.ParserCombinators.Parsec as P
+
+import Control.Arrow                 ((***))
+import Data.Either.Combinators       (mapLeft)
+import Data.List                     (init, last)
+import Data.Ranged.Boundaries        (Boundary (..))
+import Data.Ranged.Ranges            (Range (..))
+import Data.Tree                     (Tree (..))
+import Text.Parsec.Error             (errorMessages,
+                                      showErrorMessages)
+import Text.Parsec.Prim              (parserFail)
+import Text.ParserCombinators.Parsec (GenParser, ParseError, Parser,
+                                      anyChar, between, char, digit,
+                                      eof, errorPos, letter,
+                                      lookAhead, many1, noneOf,
+                                      notFollowedBy, oneOf,
+                                      optionMaybe, sepBy1, string,
+                                      try, (<?>))
+
+import PostgREST.DbStructure.Identifiers (FieldName)
+import PostgREST.RangeQuery              (NonnegRange, allRange,
+                                          rangeGeq, rangeLimit,
+                                          rangeOffset, restrictRange)
+
+import PostgREST.Request.ReadQuery (SelectItem)
+import PostgREST.Request.Types     (EmbedParam (..), EmbedPath, Field,
+                                    Filter (..), FtsOperator (..),
+                                    JoinType (..), JsonOperand (..),
+                                    JsonOperation (..), JsonPath,
+                                    ListVal, LogicOperator (..),
+                                    LogicTree (..), OpExpr (..),
+                                    Operation (..),
+                                    OrderDirection (..),
+                                    OrderNulls (..), OrderTerm (..),
+                                    QPError (..), SimpleOperator (..),
+                                    SingleVal, TrileanVal (..))
+
+import Protolude hiding (try)
+
+
+-- $setup
+-- Setup for doctests
+-- >>> import Text.Pretty.Simple (pPrint)
+-- >>> deriving instance Show QPError
+-- >>> deriving instance Show TrileanVal
+-- >>> deriving instance Show FtsOperator
+-- >>> deriving instance Show SimpleOperator
+-- >>> deriving instance Show Operation
+-- >>> deriving instance Show OpExpr
+-- >>> deriving instance Show JsonOperand
+-- >>> deriving instance Show JsonOperation
+-- >>> deriving instance Show Filter
+-- >>> deriving instance Show JoinType
+
+data QueryParams =
+  QueryParams
+    { qsCanonical      :: ByteString
+    -- ^ Canonical representation of the query params, sorted alphabetically
+    , qsParams         :: [(Text, Text)]
+    -- ^ Parameters for RPC calls
+    , qsRanges         :: HM.HashMap Text (Range Integer)
+    -- ^ Ranges derived from &limit and &offset params
+    , qsOrder          :: [(EmbedPath, [OrderTerm])]
+    -- ^ &order parameters for each level
+    , qsLogic          :: [(EmbedPath, LogicTree)]
+    -- ^ &and and &or parameters used for complex boolean logic
+    , qsColumns        :: Maybe (S.Set FieldName)
+    -- ^ &columns parameter and payload
+    , qsSelect         :: [Tree SelectItem]
+    -- ^ &select parameter used to shape the response
+    , qsFilters        :: [(EmbedPath, Filter)]
+    -- ^ Filters on the result from e.g. &id=e.10
+    , qsFiltersRoot    :: [Filter]
+    -- ^ Subset of the filters that apply on the root table. These are used on UPDATE/DELETE.
+    , qsFiltersNotRoot :: [(EmbedPath, Filter)]
+    -- ^ Subset of the filters that do not apply on the root table
+    , qsFilterFields   :: S.Set FieldName
+    -- ^ Set of fields that filters apply to
+    , qsOnConflict     :: Maybe [FieldName]
+    -- ^ &on_conflict parameter used to upsert on specific unique keys
+    }
+
+-- |
+-- Parse query parameters from a query string like "id=eq.1&select=name".
+--
+-- The canonical representation of the query string has paramters sorted alphabetically:
+--
+-- >>> qsCanonical <$> parse "a=1&c=3&b=2&d"
+-- Right "a=1&b=2&c=3&d="
+--
+-- 'select' is a reserved parameter that selects the fields to be returned:
+--
+-- >>> qsSelect <$> parse "select=name,location"
+-- Right [Node {rootLabel = (("name",[]),Nothing,Nothing,Nothing,Nothing), subForest = []},Node {rootLabel = (("location",[]),Nothing,Nothing,Nothing,Nothing), subForest = []}]
+--
+-- Filters are parameters whose value contains an operator, separated by a '.' from its value:
+--
+-- >>> qsFilters <$> parse "a.b=eq.0"
+-- Right [(["a"],Filter {field = ("b",[]), opExpr = OpExpr False (Op OpEqual "0")})]
+--
+-- If the operator specified in a filter does not exist, parsing the query string fails:
+--
+-- >>> qsFilters <$> parse "a.b=noop.0"
+-- Left (QPError "\"failed to parse filter (noop.0)\" (line 1, column 6)" "unknown single value operator noop")
+parse :: ByteString -> Either QPError QueryParams
+parse qs =
+  QueryParams
+    canonical
+    params
+    ranges
+    <$> pRequestOrder `traverse` order
+    <*> pRequestLogicTree `traverse` logic
+    <*> pRequestColumns columns
+    <*> pRequestSelect select
+    <*> pRequestFilter `traverse` filters
+    <*> (fmap snd <$> (pRequestFilter `traverse` filtersRoot))
+    <*> pRequestFilter `traverse` filtersNotRoot
+    <*> pure (S.fromList (fst <$> filters))
+    <*> sequenceA (pRequestOnConflict <$> onConflict)
+  where
+    logic = filter (endingIn ["and", "or"] . fst) nonemptyParams
+    select = fromMaybe "*" $ lookupParam "select"
+    onConflict = lookupParam "on_conflict"
+    columns = lookupParam "columns"
+    order = filter (endingIn ["order"] . fst) nonemptyParams
+    limits = filter (endingIn ["limit"] . fst) nonemptyParams
+    -- Replace .offset ending with .limit to be able to match those params later in a map
+    offsets = first (replaceLast "limit") <$> filter (endingIn ["offset"] . fst) nonemptyParams
+    lookupParam :: Text -> Maybe Text
+    lookupParam needle = toS <$> join (L.lookup needle qParams)
+    nonemptyParams = mapMaybe (\(k, v) -> (k,) <$> v) qParams
+
+    qString = HTTP.parseQueryReplacePlus True qs
+
+    qParams = [(T.decodeUtf8 k, T.decodeUtf8 <$> v)|(k,v) <- qString]
+
+    canonical =
+      BS.pack $ HTTP.urlEncodeVars
+        . L.sortOn fst
+        . map (join (***) BS.unpack . second (fromMaybe mempty))
+        $ qString
+
+    endingIn:: [Text] -> Text -> Bool
+    endingIn xx key = lastWord `elem` xx
+      where lastWord = L.last $ T.split (== '.') key
+
+    (filters, params) = L.partition isParam filtersAndParams
+    isParam (k, v) = isEmbedPath k || hasOperator v || hasFtsOperator v
+
+    filtersAndParams = filter (isFilterOrParam . fst)  nonemptyParams
+    isFilterOrParam k = not (endingIn reservedEmbeddable k) && notElem k reserved
+    reserved = ["select", "columns", "on_conflict"]
+    reservedEmbeddable = ["order", "limit", "offset", "and", "or"]
+
+    (filtersNotRoot, filtersRoot) = L.partition isNotRoot filters
+    isNotRoot = flip T.isInfixOf "." . fst
+
+    -- TODO: These checks are redundant to the parsers, should use parsers to differentiate params
+    hasOperator val =
+      case T.splitOn "." val of
+        "not" : _ : _ -> True
+        "is" : _      -> True
+        "in" : _      -> True
+        x : _         -> isJust (operator x) || isJust (ftsOperator x)
+        _             -> False
+
+    hasFtsOperator val =
+      case T.splitOn "(" val of
+        x : _ : _ -> isJust $ ftsOperator x
+        _         -> False
+
+    isEmbedPath = T.isInfixOf "."
+    replaceLast x s = T.intercalate "." $ L.init (T.split (=='.') s) <> [x]
+
+    ranges :: HM.HashMap Text (Range Integer)
+    ranges = HM.unionWith f limitParams offsetParams
+      where
+        f rl ro = Range (BoundaryBelow o) (BoundaryAbove $ o + l - 1)
+          where
+            l = fromMaybe 0 $ rangeLimit rl
+            o = rangeOffset ro
+
+        limitParams =
+          HM.fromList [(k, restrictRange (readMaybe v) allRange) | (k,v) <- limits]
+
+        offsetParams =
+          HM.fromList [(k, maybe allRange rangeGeq (readMaybe v)) | (k,v) <- offsets]
+
+operator :: Text -> Maybe SimpleOperator
+operator = \case
+  "eq"     -> Just OpEqual
+  "gte"    -> Just OpGreaterThanEqual
+  "gt"     -> Just OpGreaterThan
+  "lte"    -> Just OpLessThanEqual
+  "lt"     -> Just OpLessThan
+  "neq"    -> Just OpNotEqual
+  "like"   -> Just OpLike
+  "ilike"  -> Just OpILike
+  "cs"     -> Just OpContains
+  "cd"     -> Just OpContained
+  "ov"     -> Just OpOverlap
+  "sl"     -> Just OpStrictlyLeft
+  "sr"     -> Just OpStrictlyRight
+  "nxr"    -> Just OpNotExtendsRight
+  "nxl"    -> Just OpNotExtendsLeft
+  "adj"    -> Just OpAdjacent
+  "match"  -> Just OpMatch
+  "imatch" -> Just OpIMatch
+  _        -> Nothing
+
+ftsOperator :: Text -> Maybe FtsOperator
+ftsOperator = \case
+  "fts"   -> Just FilterFts
+  "plfts" -> Just FilterFtsPlain
+  "phfts" -> Just FilterFtsPhrase
+  "wfts"  -> Just FilterFtsWebsearch
+  _       -> Nothing
+
+
+-- PARSERS
+
+
+pRequestSelect :: Text -> Either QPError [Tree SelectItem]
+pRequestSelect selStr =
+  mapError $ P.parse pFieldForest ("failed to parse select parameter (" <> toS selStr <> ")") (toS selStr)
+
+pRequestOnConflict :: Text -> Either QPError [FieldName]
+pRequestOnConflict oncStr =
+  mapError $ P.parse pColumns ("failed to parse on_conflict parameter (" <> toS oncStr <> ")") (toS oncStr)
+
+pRequestFilter :: (Text, Text) -> Either QPError (EmbedPath, Filter)
+pRequestFilter (k, v) = mapError $ (,) <$> path <*> (Filter <$> fld <*> oper)
+  where
+    treePath = P.parse pTreePath ("failed to parse tree path (" ++ toS k ++ ")") $ toS k
+    oper = P.parse (pOpExpr pSingleVal) ("failed to parse filter (" ++ toS v ++ ")") $ toS v
+    path = fst <$> treePath
+    fld = snd <$> treePath
+
+pRequestOrder :: (Text, Text) -> Either QPError (EmbedPath, [OrderTerm])
+pRequestOrder (k, v) = mapError $ (,) <$> path <*> ord'
+  where
+    treePath = P.parse pTreePath ("failed to parse tree path (" ++ toS k ++ ")") $ toS k
+    path = fst <$> treePath
+    ord' = P.parse pOrder ("failed to parse order (" ++ toS v ++ ")") $ toS v
+
+pRequestRange :: (Text, NonnegRange) -> Either QPError (EmbedPath, NonnegRange)
+pRequestRange (k, v) = mapError $ (,) <$> path <*> pure v
+  where
+    treePath = P.parse pTreePath ("failed to parse tree path (" ++ toS k ++ ")") $ toS k
+    path = fst <$> treePath
+
+pRequestLogicTree :: (Text, Text) -> Either QPError (EmbedPath, LogicTree)
+pRequestLogicTree (k, v) = mapError $ (,) <$> embedPath <*> logicTree
+  where
+    path = P.parse pLogicPath ("failed to parse logic path (" ++ toS k ++ ")") $ toS k
+    embedPath = fst <$> path
+    logicTree = do
+      op <- snd <$> path
+      -- Concat op and v to make pLogicTree argument regular,
+      -- in the form of "?and=and(.. , ..)" instead of "?and=(.. , ..)"
+      P.parse pLogicTree ("failed to parse logic tree (" ++ toS v ++ ")") $ toS (op <> v)
+
+pRequestColumns :: Maybe Text -> Either QPError (Maybe (S.Set FieldName))
+pRequestColumns colStr =
+  case colStr of
+    Just str ->
+      mapError $ Just . S.fromList <$> P.parse pColumns ("failed to parse columns parameter (" <> toS str <> ")") (toS str)
+    _ -> Right Nothing
+
+ws :: Parser Text
+ws = toS <$> many (oneOf " \t")
+
+lexeme :: Parser a -> Parser a
+lexeme p = ws *> p <* ws
+
+pTreePath :: Parser (EmbedPath, Field)
+pTreePath = do
+  p <- pFieldName `sepBy1` pDelimiter
+  jp <- P.option [] pJsonPath
+  return (init p, (last p, jp))
+
+pFieldForest :: Parser [Tree SelectItem]
+pFieldForest = pFieldTree `sepBy1` lexeme (char ',')
+  where
+    pFieldTree :: Parser (Tree SelectItem)
+    pFieldTree =  try (Node <$> pRelationSelect <*> between (char '(') (char ')') pFieldForest) <|>
+                  Node <$> pFieldSelect <*> pure []
+
+pStar :: Parser Text
+pStar = string "*" $> "*"
+
+pFieldName :: Parser Text
+pFieldName =
+  pQuotedValue <|>
+  T.intercalate "-" . map toS <$> (many1 pIdentifierChar `sepBy1` dash) <?>
+  "field name (* or [a..z0..9_])"
+  where
+    isDash :: GenParser Char st ()
+    isDash = try ( char '-' >> notFollowedBy (char '>') )
+    dash :: Parser Char
+    dash = isDash $> '-'
+
+-- |
+-- Parse json operators in select, order and filters
+--
+-- >>> P.parse pJsonPath "" "->text"
+-- Right [JArrow {jOp = JKey {jVal = "text"}}]
+--
+-- >>> P.parse pJsonPath "" "->1"
+-- Right [JArrow {jOp = JIdx {jVal = "+1"}}]
+--
+-- >>> P.parse pJsonPath "" "->>text"
+-- Right [J2Arrow {jOp = JKey {jVal = "text"}}]
+--
+-- >>> P.parse pJsonPath "" "->>1"
+-- Right [J2Arrow {jOp = JIdx {jVal = "+1"}}]
+--
+-- >>> P.parse pJsonPath "" "->0,other"
+-- Right [JArrow {jOp = JIdx {jVal = "+0"}}]
+--
+-- >>> P.parse pJsonPath "" "->0.desc"
+-- Right [JArrow {jOp = JIdx {jVal = "+0"}}]
+pJsonPath :: Parser JsonPath
+pJsonPath = many pJsonOperation
+  where
+    pJsonOperation :: Parser JsonOperation
+    pJsonOperation = pJsonArrow <*> pJsonOperand
+
+    pJsonArrow   =
+      try (string "->>" $> J2Arrow) <|>
+      try (string "->" $> JArrow)
+
+    pJsonOperand =
+      let pJKey = JKey . toS <$> pFieldName
+          pJIdx = JIdx . toS <$> ((:) <$> P.option '+' (char '-') <*> many1 digit) <* pEnd
+          pEnd = try (void $ lookAhead (string "->")) <|>
+                 try (void $ lookAhead (string "::")) <|>
+                 try (void $ lookAhead (string ".")) <|>
+                 try (void $ lookAhead (string ",")) <|>
+                 try eof in
+      try pJIdx <|> try pJKey
+
+pField :: Parser Field
+pField = lexeme $ (,) <$> pFieldName <*> P.option [] pJsonPath
+
+aliasSeparator :: Parser ()
+aliasSeparator = char ':' >> notFollowedBy (char ':')
+
+pRelationSelect :: Parser SelectItem
+pRelationSelect = lexeme $ try ( do
+    alias <- optionMaybe ( try(pFieldName <* aliasSeparator) )
+    fld <- pField
+    prm1 <- optionMaybe pEmbedParam
+    prm2 <- optionMaybe pEmbedParam
+    return (fld, Nothing, alias, embedParamHint prm1 <|> embedParamHint prm2, embedParamJoin prm1 <|> embedParamJoin prm2)
+  )
+  where
+    pEmbedParam :: Parser EmbedParam
+    pEmbedParam =
+      char '!' *> (
+        try (string "left"  $> EPJoinType JTLeft)  <|>
+        try (string "inner" $> EPJoinType JTInner) <|>
+        try (EPHint <$> pFieldName))
+    embedParamHint prm = case prm of
+      Just (EPHint hint) -> Just hint
+      _                  -> Nothing
+    embedParamJoin prm = case prm of
+      Just (EPJoinType jt) -> Just jt
+      _                    -> Nothing
+
+pFieldSelect :: Parser SelectItem
+pFieldSelect = lexeme $
+  try (
+    do
+      alias <- optionMaybe ( try(pFieldName <* aliasSeparator) )
+      fld <- pField
+      cast' <- optionMaybe (string "::" *> many pIdentifierChar)
+      return (fld, toS <$> cast', alias, Nothing, Nothing)
+  )
+  <|> do
+    s <- pStar
+    return ((s, []), Nothing, Nothing, Nothing, Nothing)
+
+pOpExpr :: Parser SingleVal -> Parser OpExpr
+pOpExpr pSVal = try ( string "not" *> pDelimiter *> (OpExpr True <$> pOperation)) <|> OpExpr False <$> pOperation
+  where
+    pOperation :: Parser Operation
+    pOperation = pIn <|> pIs <|> try pFts <|> pOp <?> "operator (eq, gt, ...)"
+
+    pIn = In <$> (try (string "in" *> pDelimiter) *> pListVal)
+    pIs = Is <$> (try (string "is" *> pDelimiter) *> pTriVal)
+
+    pOp = do
+      opStr <- try (P.manyTill anyChar (try pDelimiter))
+      op <- parseMaybe ("unknown single value operator " <> opStr) . operator $ toS opStr
+      Op op <$> pSVal
+
+    pTriVal = try (ciString "null"    $> TriNull)
+          <|> try (ciString "unknown" $> TriUnknown)
+          <|> try (ciString "true"    $> TriTrue)
+          <|> try (ciString "false"   $> TriFalse)
+          <?> "null or trilean value (unknown, true, false)"
+
+    pFts = do
+      opStr <- try (P.many (noneOf ".("))
+      op <- parseMaybe ("unknown fts operator " <> opStr) . ftsOperator $ toS opStr
+      lang <- optionMaybe $ try (between (char '(') (char ')') $ many pIdentifierChar)
+      pDelimiter >> Fts op (toS <$> lang) <$> pSVal
+
+    parseMaybe :: [Char] -> Maybe a -> Parser a
+    parseMaybe err Nothing = parserFail err
+    parseMaybe _ (Just x)  = pure x
+
+    -- case insensitive char and string
+    ciChar :: Char -> GenParser Char state Char
+    ciChar c = char c <|> char (toUpper c)
+    ciString :: [Char] -> GenParser Char state [Char]
+    ciString = traverse ciChar
+
+pSingleVal :: Parser SingleVal
+pSingleVal = toS <$> many anyChar
+
+pListVal :: Parser ListVal
+pListVal = lexeme (char '(') *> pListElement `sepBy1` char ',' <* lexeme (char ')')
+
+pListElement :: Parser Text
+pListElement = try (pQuotedValue <* notFollowedBy (noneOf ",)")) <|> (toS <$> many (noneOf ",)"))
+
+pQuotedValue :: Parser Text
+pQuotedValue = toS <$> (char '"' *> many pCharsOrSlashed <* char '"')
+  where
+    pCharsOrSlashed = noneOf "\\\"" <|> (char '\\' *> anyChar)
+
+pDelimiter :: Parser Char
+pDelimiter = char '.' <?> "delimiter (.)"
+
+pOrder :: Parser [OrderTerm]
+pOrder = lexeme pOrderTerm `sepBy1` char ','
+
+pOrderTerm :: Parser OrderTerm
+pOrderTerm = do
+  fld <- pField
+  dir <- optionMaybe $
+         try (pDelimiter *> string "asc" $> OrderAsc) <|>
+         try (pDelimiter *> string "desc" $> OrderDesc)
+  nls <- optionMaybe pNulls <* pEnd <|>
+         pEnd $> Nothing
+  return $ OrderTerm fld dir nls
+  where
+    pNulls = try (pDelimiter *> string "nullsfirst" $> OrderNullsFirst) <|>
+             try (pDelimiter *> string "nullslast"  $> OrderNullsLast)
+    pEnd = try (void $ lookAhead (char ',')) <|>
+           try eof
+
+pLogicTree :: Parser LogicTree
+pLogicTree = Stmnt <$> try pLogicFilter
+             <|> Expr <$> pNot <*> pLogicOp <*> (lexeme (char '(') *> pLogicTree `sepBy1` lexeme (char ',') <* lexeme (char ')'))
+  where
+    pLogicFilter :: Parser Filter
+    pLogicFilter = Filter <$> pField <* pDelimiter <*> pOpExpr pLogicSingleVal
+    pNot :: Parser Bool
+    pNot = try (string "not" *> pDelimiter $> True)
+           <|> pure False
+           <?> "negation operator (not)"
+    pLogicOp :: Parser LogicOperator
+    pLogicOp = try (string "and" $> And)
+               <|> string "or" $> Or
+               <?> "logic operator (and, or)"
+
+pLogicSingleVal :: Parser SingleVal
+pLogicSingleVal = try (pQuotedValue <* notFollowedBy (noneOf ",)")) <|> try pPgArray <|> (toS <$> many (noneOf ",)"))
+  where
+    pPgArray :: Parser Text
+    pPgArray =  do
+      a <- string "{"
+      b <- many (noneOf "{}")
+      c <- string "}"
+      pure (toS $ a ++ b ++ c)
+
+pLogicPath :: Parser (EmbedPath, Text)
+pLogicPath = do
+  path <- pFieldName `sepBy1` pDelimiter
+  let op = last path
+      notOp = "not." <> op
+  return (filter (/= "not") (init path), if "not" `elem` path then notOp else op)
+
+pColumns :: Parser [FieldName]
+pColumns = pFieldName `sepBy1` lexeme (char ',')
+
+pIdentifierChar :: Parser Char
+pIdentifierChar = letter <|> digit <|> oneOf "_ $"
+
+mapError :: Either ParseError a -> Either QPError a
+mapError = mapLeft translateError
+  where
+    translateError e =
+      QPError message details
+      where
+        message = show $ errorPos e
+        details = T.strip $ T.replace "\n" " " $ toS
+           $ showErrorMessages "or" "unknown parse error" "expecting" "unexpected" "end of input" (errorMessages e)

src/PostgREST/Request/ReadQuery.hs

@@ -0,0 +1,46 @@
+module PostgREST.Request.ReadQuery
+  ( ReadNode
+  , ReadQuery(..)
+  , ReadRequest
+  , SelectItem
+  , fstFieldNames
+  ) where
+
+import Data.Tree (Tree (..))
+
+import PostgREST.DbStructure.Identifiers  (FieldName,
+                                           QualifiedIdentifier)
+import PostgREST.DbStructure.Relationship (Relationship)
+import PostgREST.RangeQuery               (NonnegRange)
+import PostgREST.Request.Types            (Alias, Cast, Depth, Field,
+                                           Hint, JoinCondition,
+                                           JoinType, LogicTree,
+                                           NodeName, OrderTerm)
+
+
+import Protolude
+
+type ReadRequest = Tree ReadNode
+
+type ReadNode =
+  (ReadQuery, (NodeName, Maybe Relationship, Maybe Alias, Maybe Hint, Maybe JoinType, Depth))
+
+-- | The select value in `/tbl?select=alias:field::cast`
+type SelectItem = (Field, Maybe Cast, Maybe Alias, Maybe Hint, Maybe JoinType)
+
+data ReadQuery = Select
+  { select         :: [SelectItem]
+  , from           :: QualifiedIdentifier
+  , fromAlias      :: Maybe Alias
+  -- ^ A table alias is used in case of self joins
+  , where_         :: [LogicTree]
+  , joinConditions :: [JoinCondition]
+  , order          :: [OrderTerm]
+  , range_         :: NonnegRange
+  }
+  deriving (Eq)
+
+-- First level FieldNames(e.g get a,b from /table?select=a,b,other(c,d))
+fstFieldNames :: ReadRequest -> [FieldName]
+fstFieldNames (Node (sel, _) _) =
+  fst . (\(f, _, _, _, _) -> f) <$> select sel

src/PostgREST/Request/Types.hs

@@ -1,73 +1,77 @@
 {-# LANGUAGE DuplicateRecordFields #-}
 module PostgREST.Request.Types
   ( Alias
+  , Cast
   , Depth
-  , EmbedHint
+  , EmbedParam(..)
+  , ApiRequestError(..)
   , EmbedPath
   , Field
   , Filter(..)
+  , Hint
+  , CallQuery(..)
+  , CallParams(..)
+  , CallRequest
   , JoinCondition(..)
+  , JoinType(..)
   , JsonOperand(..)
   , JsonOperation(..)
   , JsonPath
   , ListVal
   , LogicOperator(..)
   , LogicTree(..)
-  , MutateQuery(..)
-  , MutateRequest
   , NodeName
   , OpExpr(..)
   , Operation (..)
   , OrderDirection(..)
   , OrderNulls(..)
   , OrderTerm(..)
-  , ReadNode
-  , ReadQuery(..)
-  , ReadRequest
-  , SelectItem
+  , QPError(..)
   , SingleVal
-  , fstFieldNames
+  , TrileanVal(..)
+  , SimpleOperator(..)
+  , FtsOperator(..)
   ) where
 
-import qualified Data.ByteString.Lazy as BL
-import qualified Data.Set             as S
-
-import Data.Tree (Tree (..))
-
-import qualified GHC.Show (show)
+import qualified Data.ByteString.Lazy as LBS
 
 import PostgREST.DbStructure.Identifiers  (FieldName,
                                            QualifiedIdentifier)
+import PostgREST.DbStructure.Proc         (ProcDescription (..),
+                                           ProcParam (..))
 import PostgREST.DbStructure.Relationship (Relationship)
-import PostgREST.RangeQuery               (NonnegRange)
-import PostgREST.Request.Preferences      (PreferResolution)
+import PostgREST.MediaType                (MediaType (..))
 
 import Protolude
 
 
-type ReadRequest = Tree ReadNode
-type MutateRequest = MutateQuery
 
-type ReadNode =
-  (ReadQuery, (NodeName, Maybe Relationship, Maybe Alias, Maybe EmbedHint, Depth))
+data ApiRequestError
+  = AmbiguousRelBetween Text Text [Relationship]
+  | AmbiguousRpc [ProcDescription]
+  | MediaTypeError [ByteString]
+  | InvalidBody ByteString
+  | InvalidFilters
+  | InvalidRange
+  | InvalidRpcMethod ByteString
+  | LimitNoOrderError
+  | NotFound
+  | NoRelBetween Text Text Text
+  | NoRpc Text Text [Text] Bool MediaType Bool
+  | NotEmbedded Text
+  | ParseRequestError Text Text
+  | PutRangeNotAllowedError
+  | QueryParamError QPError
+  | UnacceptableSchema [Text]
+  | UnsupportedMethod ByteString
+
+data QPError = QPError Text Text
+
+type CallRequest = CallQuery
 
 type NodeName = Text
 type Depth = Integer
 
-data ReadQuery = Select
-  { select         :: [SelectItem]
-  , from           :: QualifiedIdentifier
-  -- ^ A table alias is used in case of self joins
-  , fromAlias      :: Maybe Alias
-  -- ^ Only used for Many to Many joins. Parent and Child joins use explicit joins.
-  , implicitJoins  :: [QualifiedIdentifier]
-  , where_         :: [LogicTree]
-  , joinConditions :: [JoinCondition]
-  , order          :: [OrderTerm]
-  , range_         :: NonnegRange
-  }
-  deriving (Eq)
-
 data JoinCondition =
   JoinCondition
     (QualifiedIdentifier, FieldName)
@@ -86,52 +90,40 @@ data OrderDirection
   | OrderDesc
   deriving (Eq)
 
-instance Show OrderDirection where
-  show OrderAsc  = "ASC"
-  show OrderDesc = "DESC"
-
 data OrderNulls
   = OrderNullsFirst
   | OrderNullsLast
   deriving (Eq)
 
-instance Show OrderNulls where
-  show OrderNullsFirst = "NULLS FIRST"
-  show OrderNullsLast  = "NULLS LAST"
+data CallQuery = FunctionCall
+  { funCQi           :: QualifiedIdentifier
+  , funCParams       :: CallParams
+  , funCArgs         :: Maybe LBS.ByteString
+  , funCScalar       :: Bool
+  , funCMultipleCall :: Bool
+  , funCReturning    :: [FieldName]
+  }
 
-data MutateQuery
-  = Insert
-      { in_        :: QualifiedIdentifier
-      , insCols    :: S.Set FieldName
-      , insBody    :: Maybe BL.ByteString
-      , onConflict :: Maybe (PreferResolution, [FieldName])
-      , where_     :: [LogicTree]
-      , returning  :: [FieldName]
-      }
-  | Update
-      { in_       :: QualifiedIdentifier
-      , updCols   :: S.Set FieldName
-      , updBody   :: Maybe BL.ByteString
-      , where_    :: [LogicTree]
-      , returning :: [FieldName]
-      }
-  | Delete
-      { in_       :: QualifiedIdentifier
-      , where_    :: [LogicTree]
-      , returning :: [FieldName]
-      }
-
--- | The select value in `/tbl?select=alias:field::cast`
-type SelectItem = (Field, Maybe Cast, Maybe Alias, Maybe EmbedHint)
+data CallParams
+  = KeyParams [ProcParam] -- ^ Call with key params: func(a := val1, b:= val2)
+  | OnePosParam ProcParam -- ^ Call with positional params(only one supported): func(val)
 
 type Field = (FieldName, JsonPath)
 type Cast = Text
 type Alias = Text
+type Hint = Text
 
--- | Disambiguates an embedding operation when there's multiple relationships
--- between two tables. Can be the name of a foreign key constraint, column
--- name or the junction in an m2m relationship.
-type EmbedHint = Text
+data EmbedParam
+  -- | Disambiguates an embedding operation when there's multiple relationships
+  -- between two tables. Can be the name of a foreign key constraint, column
+  -- name or the junction in an m2m relationship.
+  = EPHint Hint
+  | EPJoinType JoinType
+
+data JoinType
+  = JTInner
+  | JTLeft
+  deriving Eq
 
 -- | Path of the embedded levels, e.g "clients.projects.name=eq.." gives Path
 -- ["clients", "projects"]
@@ -155,12 +147,6 @@ data JsonOperand
   | JIdx { jVal :: Text }
   deriving (Eq)
 
--- First level FieldNames(e.g get a,b from /table?select=a,b,other(c,d))
-fstFieldNames :: ReadRequest -> [FieldName]
-fstFieldNames (Node (sel, _) _) =
-  fst . (\(f, _, _, _) -> f) <$> select sel
-
-
 -- | Boolean logic expression tree e.g. "and(name.eq.N,or(id.eq.1,id.eq.2))" is:
 --
 --            And
@@ -178,10 +164,6 @@ data LogicOperator
   | Or
   deriving Eq
 
-instance Show LogicOperator where
-  show And = "AND"
-  show Or  = "OR"
-
 data Filter = Filter
   { field  :: Field
   , opExpr :: OpExpr
@@ -193,12 +175,12 @@ data OpExpr =
   deriving (Eq)
 
 data Operation
-  = Op Operator SingleVal
+  = Op SimpleOperator SingleVal
   | In ListVal
-  | Fts Operator (Maybe Language) SingleVal
+  | Is TrileanVal
+  | Fts FtsOperator (Maybe Language) SingleVal
   deriving (Eq)
 
-type Operator = Text
 type Language = Text
 
 -- | Represents a single value in a filter, e.g. id=eq.singleval
@@ -206,3 +188,40 @@ type SingleVal = Text
 
 -- | Represents a list value in a filter, e.g. id=in.(val1,val2,val3)
 type ListVal = [Text]
+
+-- | Three-valued logic values
+data TrileanVal
+  = TriTrue
+  | TriFalse
+  | TriNull
+  | TriUnknown
+  deriving Eq
+
+data SimpleOperator
+  = OpEqual
+  | OpGreaterThanEqual
+  | OpGreaterThan
+  | OpLessThanEqual
+  | OpLessThan
+  | OpNotEqual
+  | OpLike
+  | OpILike
+  | OpContains
+  | OpContained
+  | OpOverlap
+  | OpStrictlyLeft
+  | OpStrictlyRight
+  | OpNotExtendsRight
+  | OpNotExtendsLeft
+  | OpAdjacent
+  | OpMatch
+  | OpIMatch
+  deriving Eq
+
+-- | Operators for full text search operators
+data FtsOperator
+  = FilterFts
+  | FilterFtsPlain
+  | FilterFtsPhrase
+  | FilterFtsWebsearch
+  deriving Eq

src/PostgREST/Unix.hs

@@ -43,10 +43,9 @@ runAppWithSocket settings app socketFileMode socketFilePath =
 -- | Set signal handlers, only for systems with signals
 installSignalHandlers :: AppState.AppState -> IO ()
 installSignalHandlers appState = do
-  -- Releases the connection pool whenever the program is terminated,
-  -- see https://github.com/PostgREST/postgrest/issues/268
-  install Signals.sigINT $ AppState.releasePool appState
-  install Signals.sigTERM $ AppState.releasePool appState
+  let interrupt = throwTo (AppState.getMainThreadId appState) UserInterrupt
+  install Signals.sigINT interrupt
+  install Signals.sigTERM interrupt
 
   -- The SIGUSR1 signal updates the internal 'DbStructure' by running
   -- 'connectionWorker' exactly as before.

src/PostgREST/Version.hs

@@ -1,29 +1,44 @@
 {-# LANGUAGE TemplateHaskell #-}
-{-# OPTIONS_GHC -fno-warn-type-defaults #-}
 module PostgREST.Version
   ( docsVersion
   , prettyVersion
   ) where
 
-import qualified Data.Text as T
+import qualified Data.ByteString as BS
+import qualified Data.Text       as T
 
-import Data.Version       (versionBranch)
+import Data.Version       (showVersion, versionBranch)
 import Development.GitRev (gitHash)
 import Paths_postgrest    (version)
 
 import Protolude
 
 
--- | User friendly version number
-prettyVersion :: Text
+-- | User friendly version number such as '1.1.1'.
+-- Pre-release versions are tagged as such, e.g., '1.1.1.1 (pre-release)'.
+-- If a git hash is available, it's added to the version, e.g., '1.1.1 (abcdef0)'.
+prettyVersion :: ByteString
 prettyVersion =
-  T.intercalate "." (map show $ versionBranch version) <> gitRev
+  toUtf8 (showVersion version) <> preRelease <> gitRev
   where
     gitRev =
-      if $(gitHash) == "UNKNOWN"
-        then mempty
-        else " (" <> T.take 7 $(gitHash) <> ")"
+      if $(gitHash) == ("UNKNOWN" :: Text) then
+        mempty
+      else
+        " (" <> BS.take 7 $(gitHash) <> ")"
+    preRelease = if isPreRelease then " (pre-release)" else mempty
 
--- | Version number used in docs
+
+-- | Version number used in docs.
+-- Pre-release versions link to the latest docs
+-- Uses only the two first components of the version. Example: 'v1.1'
 docsVersion :: Text
-docsVersion = "v" <> T.dropEnd 1 (T.dropWhileEnd (/= '.') prettyVersion)
+docsVersion
+  | isPreRelease = "latest"
+  | otherwise    =  "v" <> (T.intercalate "." . map show . take 2 $ versionBranch version)
+
+
+-- | Versions with four components (e.g., '1.1.1.1') are treated as pre-releases.
+isPreRelease :: Bool
+isPreRelease =
+  length (versionBranch version) == 4

src/PostgREST/Workers.hs

@@ -9,13 +9,14 @@ module PostgREST.Workers
 
 import qualified Data.Aeson                 as JSON
 import qualified Data.ByteString            as BS
-import qualified Hasql.Connection           as C
-import qualified Hasql.Notifications        as N
-import qualified Hasql.Pool                 as P
-import qualified Hasql.Transaction.Sessions as HT
+import qualified Data.ByteString.Lazy       as LBS
+import qualified Data.Text.Encoding         as T
+import qualified Hasql.Notifications        as SQL
+import qualified Hasql.Transaction.Sessions as SQL
 
-import Control.Retry (RetryStatus, capDelay, exponentialBackoff,
-                      retrying, rsPreviousDelay)
+import Control.Retry    (RetryStatus, capDelay, exponentialBackoff,
+                         retrying, rsPreviousDelay)
+import Hasql.Connection (acquire)
 
 import PostgREST.AppState         (AppState)
 import PostgREST.Config           (AppConfig (..), readAppConfig)
@@ -27,8 +28,7 @@ import PostgREST.Error            (PgError (PgError), checkIsFatal,
 
 import qualified PostgREST.AppState as AppState
 
-import Protolude      hiding (head, toS)
-import Protolude.Conv (toS)
+import Protolude
 
 
 -- | Current database connection status data ConnectionStatus
@@ -48,7 +48,7 @@ data SCacheStatus
 -- up-to-date schema cache(DbStructure).  This method is meant to be called
 -- multiple times by the same thread, but does nothing if the previous
 -- invocation has not terminated. In all cases this method does not halt the
--- calling thread, the work is preformed in a separate thread.
+-- calling thread, the work is performed in a separate thread.
 --
 -- Background thread that does the following :
 --  1. Tries to connect to pg server and will keep trying until success.
@@ -57,13 +57,14 @@ data SCacheStatus
 --  3. Obtains the dbStructure. If this fails, it goes back to 1.
 connectionWorker :: AppState -> IO ()
 connectionWorker appState = do
-  isWorkerOn <- AppState.getIsWorkerOn appState
+  runExclusively (AppState.getWorkerSem appState) work
   -- Prevents multiple workers to be running at the same time. Could happen on
   -- too many SIGUSR1s.
-  unless isWorkerOn $ do
-    AppState.putIsWorkerOn appState True
-    void $ forkIO work
   where
+    runExclusively mvar action = mask_ $ do
+      success <- tryPutMVar mvar ()
+      when success $ do
+        void $ forkIO $ action `finally` takeMVar mvar
     work = do
       AppConfig{..} <- AppState.getConfig appState
       AppState.logWithZTime appState "Attempting to connect to the database..."
@@ -90,11 +91,11 @@ connectionWorker appState = do
               -- do nothing and proceed if the load was successful
               return ()
             SCOnRetry ->
+              -- retry reloading the schema cache
               work
             SCFatalFail ->
               -- die if our schema cache query has an error
               killThread $ AppState.getMainThreadId appState
-          AppState.putIsWorkerOn appState False
 
 -- | Check if a connection from the pool allows access to the PostgreSQL
 -- database.  If not, the pool connections are released and a new connection is
@@ -108,20 +109,19 @@ connectionWorker appState = do
 connectionStatus :: AppState -> IO ConnectionStatus
 connectionStatus appState =
   retrying retrySettings shouldRetry $
-    const $ P.release pool >> getConnectionStatus
+    const $ AppState.releasePool appState >> getConnectionStatus
   where
-    pool = AppState.getPool appState
     retrySettings = capDelay delayMicroseconds $ exponentialBackoff backoffMicroseconds
     delayMicroseconds = 32000000 -- 32 seconds
     backoffMicroseconds = 1000000 -- 1 second
 
     getConnectionStatus :: IO ConnectionStatus
     getConnectionStatus = do
-      pgVersion <- P.use pool queryPgVersion
+      pgVersion <- AppState.usePool appState queryPgVersion
       case pgVersion of
         Left e -> do
           let err = PgError False e
-          AppState.logWithZTime appState . toS $ errorPayload err
+          AppState.logWithZTime appState . T.decodeUtf8 . LBS.toStrict $ errorPayload err
           case checkIsFatal err of
             Just reason ->
               return $ FatalConnectionError reason
@@ -144,6 +144,7 @@ connectionStatus appState =
         "Attempting to reconnect to the database in "
         <> (show delay::Text)
         <> " seconds..."
+      when itShould $ AppState.putRetryNextIn appState delay
       return itShould
 
 -- | Load the DbStructure by using a connection from the pool.
@@ -151,14 +152,14 @@ loadSchemaCache :: AppState -> IO SCacheStatus
 loadSchemaCache appState = do
   AppConfig{..} <- AppState.getConfig appState
   result <-
-    let transaction = if configDbPreparedStatements then HT.transaction else HT.unpreparedTransaction in
-    P.use (AppState.getPool appState) . transaction HT.ReadCommitted HT.Read $
+    let transaction = if configDbPreparedStatements then SQL.transaction else SQL.unpreparedTransaction in
+    AppState.usePool appState . transaction SQL.ReadCommitted SQL.Read $
       queryDbStructure (toList configDbSchemas) configDbExtraSearchPath configDbPreparedStatements
   case result of
     Left e -> do
       let
         err = PgError False e
-        putErr = AppState.logWithZTime appState . toS $ errorPayload err
+        putErr = AppState.logWithZTime appState . T.decodeUtf8 . LBS.toStrict $ errorPayload err
       case checkIsFatal err of
         Just hint -> do
           AppState.logWithZTime appState "A fatal error ocurred when loading the schema cache"
@@ -166,14 +167,15 @@ loadSchemaCache appState = do
           AppState.logWithZTime appState hint
           return SCFatalFail
         Nothing -> do
+          AppState.putDbStructure appState Nothing
           AppState.logWithZTime appState "An error ocurred when loading the schema cache"
           putErr
           return SCOnRetry
 
     Right dbStructure -> do
-      AppState.putDbStructure appState dbStructure
-      when (isJust configDbRootSpec) $
-        AppState.putJsonDbS appState $ toS $ JSON.encode dbStructure
+      AppState.putDbStructure appState (Just dbStructure)
+      when (isJust configDbRootSpec) .
+        AppState.putJsonDbS appState . LBS.toStrict $ JSON.encode dbStructure
       AppState.logWithZTime appState "Schema cache loaded"
       return SCLoaded
 
@@ -193,18 +195,20 @@ listener appState = do
 
   -- forkFinally allows to detect if the thread dies
   void . flip forkFinally (handleFinally dbChannel) $ do
-    dbOrError <- C.acquire $ toS configDbUri
+    dbOrError <- acquire $ toUtf8 configDbUri
     case dbOrError of
       Right db -> do
         AppState.logWithZTime appState $ "Listening for notifications on the " <> dbChannel <> " channel"
-        N.listen db $ N.toPgIdentifier dbChannel
-        N.waitForNotifications handleNotification db
+        AppState.putIsListenerOn appState True
+        SQL.listen db $ SQL.toPgIdentifier dbChannel
+        SQL.waitForNotifications handleNotification db
       _ ->
         die $ "Could not listen for notifications on the " <> dbChannel <> " channel"
   where
     handleFinally dbChannel _ = do
       -- if the thread dies, we try to recover
       AppState.logWithZTime appState $ "Retrying listening for notifications on the " <> dbChannel <> " channel.."
+      AppState.putIsListenerOn appState False
       -- assume the pool connection was also lost, call the connection worker
       connectionWorker appState
       -- retry the listener
@@ -228,12 +232,12 @@ reReadConfig startingUp appState = do
   AppConfig{..} <- AppState.getConfig appState
   dbSettings <-
     if configDbConfig then do
-      qDbSettings <- queryDbSettings (AppState.getPool appState) configDbPreparedStatements
+      qDbSettings <- AppState.usePool appState $ queryDbSettings configDbPreparedStatements
       case qDbSettings of
         Left e -> do
           let
             err = PgError False e
-            putErr = AppState.logWithZTime appState . toS $ errorPayload err
+            putErr = AppState.logWithZTime appState . T.decodeUtf8 . LBS.toStrict $ errorPayload err
           AppState.logWithZTime appState
             "An error ocurred when trying to query database settings for the config parameters"
           case checkIsFatal err of
@@ -242,7 +246,7 @@ reReadConfig startingUp appState = do
               AppState.logWithZTime appState hint
               killThread (AppState.getMainThreadId appState)
             Nothing -> do
-              AppState.logWithZTime appState $ show e
+              putErr
           pure []
         Right x -> pure x
     else
@@ -252,10 +256,10 @@ reReadConfig startingUp appState = do
       if startingUp then
         panic err -- die on invalid config if the program is starting up
       else
-        AppState.logWithZTime appState $ "Failed re-loading config: " <> err
+        AppState.logWithZTime appState $ "Failed reloading config: " <> err
     Right newConf -> do
       AppState.putConfig appState newConf
       if startingUp then
         pass
       else
-        AppState.logWithZTime appState "Config re-loaded"
+        AppState.logWithZTime appState "Config reloaded"

stack.yaml

@@ -1,4 +1,4 @@
-resolver: lts-18.2 # 2021-07-10, GHC 8.10.4
+resolver: lts-19.14 # 2022-07-01, GHC 9.0.2
 
 nix:
   packages:
@@ -10,6 +10,12 @@ nix:
   pure: false
 
 extra-deps:
-  - hasql-dynamic-statements-0.3.1@sha256:c3a2c89c4a8b3711368dbd33f0ccfe46a493faa7efc2c85d3e354c56a01dfc48,2673
-  - hasql-implicits-0.1.0.2@sha256:5d54e09cb779a209681b139fb3cc726bae75134557932156340cc0a56dd834a8,1361
-  - ptr-0.16.8.1@sha256:525219ec5f5da5c699725f7efcef91b00a7d44120fc019878b85c09440bf51d6,2686
+  - HTTP-4000.3.16@sha256:6042643c15a0b43e522a6693f1e322f05000d519543a84149cb80aeffee34f71,5947
+  - configurator-pg-0.2.6@sha256:cd9b06a458428e493a4d6def725af7ab1ab0fef678fbd871f9586fc7f9aa70be,2849
+  - hasql-dynamic-statements-0.3.1.1@sha256:2cfe6e75990e690f595a87cbe553f2e90fcd738610f6c66749c81cc4396b2cc4,2675
+  - hasql-implicits-0.1.0.4@sha256:0848d3cbc9d94e1e539948fa0be4d0326b26335034161bf8076785293444ca6f,1361
+  - hasql-pool-0.5.2.2@sha256:b56d4dea112d97a2ef4b2749508c0ca646828cb2d77b827e8dc433d249bb2062,2438
+  - lens-aeson-1.1.3@sha256:52c8eaecd2d1c2a969c0762277c4a8ee72c339a686727d5785932e72ef9c3050,1764
+  - optparse-applicative-0.16.1.0@sha256:418c22ed6a19124d457d96bc66bd22c93ac22fad0c7100fe4972bbb4ac989731,4982
+  - protolude-0.3.2@sha256:2a38b3dad40d238ab644e234b692c8911423f9d3ed0e36b62287c4a698d92cd1,2240
+  - ptr-0.16.8.2@sha256:708ebb95117f2872d2c5a554eb6804cf1126e86abe793b2673f913f14e5eb1ac,3959

stack.yaml.lock

@@ -5,29 +5,71 @@
 
 packages:
 - completed:
-    hackage: hasql-dynamic-statements-0.3.1@sha256:c3a2c89c4a8b3711368dbd33f0ccfe46a493faa7efc2c85d3e354c56a01dfc48,2673
+    hackage: HTTP-4000.3.16@sha256:6042643c15a0b43e522a6693f1e322f05000d519543a84149cb80aeffee34f71,5947
     pantry-tree:
-      size: 641
-      sha256: b1b9a6a26ec765e5fe29f9a670a5c9ec7067ea00dee8491f0819284ff0201b6f
+      size: 1428
+      sha256: b73a7f6d21cf20bbf819e19039409c9010efb5000d2b72cdd8fd67a9027c14e8
   original:
-    hackage: hasql-dynamic-statements-0.3.1@sha256:c3a2c89c4a8b3711368dbd33f0ccfe46a493faa7efc2c85d3e354c56a01dfc48,2673
+    hackage: HTTP-4000.3.16@sha256:6042643c15a0b43e522a6693f1e322f05000d519543a84149cb80aeffee34f71,5947
 - completed:
-    hackage: hasql-implicits-0.1.0.2@sha256:5d54e09cb779a209681b139fb3cc726bae75134557932156340cc0a56dd834a8,1361
+    hackage: configurator-pg-0.2.6@sha256:cd9b06a458428e493a4d6def725af7ab1ab0fef678fbd871f9586fc7f9aa70be,2849
     pantry-tree:
-      size: 310
-      sha256: 2f00d1467d0e226b966c2cd7bac433c8948e2f7bbdf8a44936029f66fc20b5f3
+      size: 2463
+      sha256: 97efe7a22afc93033bda5adcffdabc0f1c30dc32b2c3ba02114ce7cd74c942fd
   original:
-    hackage: hasql-implicits-0.1.0.2@sha256:5d54e09cb779a209681b139fb3cc726bae75134557932156340cc0a56dd834a8,1361
+    hackage: configurator-pg-0.2.6@sha256:cd9b06a458428e493a4d6def725af7ab1ab0fef678fbd871f9586fc7f9aa70be,2849
 - completed:
-    hackage: ptr-0.16.8.1@sha256:525219ec5f5da5c699725f7efcef91b00a7d44120fc019878b85c09440bf51d6,2686
+    hackage: hasql-dynamic-statements-0.3.1.1@sha256:2cfe6e75990e690f595a87cbe553f2e90fcd738610f6c66749c81cc4396b2cc4,2675
     pantry-tree:
-      size: 1089
-      sha256: d2b8440a738719ef8430ec38fe33b129e3940e4ccf2c016a727a1110a43656bb
+      size: 595
+      sha256: b84ae10a5c776f88f546df73bc957a35e61056400b7e805dad0b254612907e97
   original:
-    hackage: ptr-0.16.8.1@sha256:525219ec5f5da5c699725f7efcef91b00a7d44120fc019878b85c09440bf51d6,2686
+    hackage: hasql-dynamic-statements-0.3.1.1@sha256:2cfe6e75990e690f595a87cbe553f2e90fcd738610f6c66749c81cc4396b2cc4,2675
+- completed:
+    hackage: hasql-implicits-0.1.0.4@sha256:0848d3cbc9d94e1e539948fa0be4d0326b26335034161bf8076785293444ca6f,1361
+    pantry-tree:
+      size: 264
+      sha256: d49af8f8749ab7039fa668af4b78f997f7fa2928b4aded6798f573a3d08e76a0
+  original:
+    hackage: hasql-implicits-0.1.0.4@sha256:0848d3cbc9d94e1e539948fa0be4d0326b26335034161bf8076785293444ca6f,1361
+- completed:
+    hackage: hasql-pool-0.5.2.2@sha256:b56d4dea112d97a2ef4b2749508c0ca646828cb2d77b827e8dc433d249bb2062,2438
+    pantry-tree:
+      size: 412
+      sha256: 2741a33f947d28b4076c798c20c1f646beecd21f5eaf522c8256cbeb34d4d6d0
+  original:
+    hackage: hasql-pool-0.5.2.2@sha256:b56d4dea112d97a2ef4b2749508c0ca646828cb2d77b827e8dc433d249bb2062,2438
+- completed:
+    hackage: lens-aeson-1.1.3@sha256:52c8eaecd2d1c2a969c0762277c4a8ee72c339a686727d5785932e72ef9c3050,1764
+    pantry-tree:
+      size: 541
+      sha256: b31392b78f2a03111c805f4400007778eb93b49f998ab41dfbebaaf9b5526bad
+  original:
+    hackage: lens-aeson-1.1.3@sha256:52c8eaecd2d1c2a969c0762277c4a8ee72c339a686727d5785932e72ef9c3050,1764
+- completed:
+    hackage: optparse-applicative-0.16.1.0@sha256:418c22ed6a19124d457d96bc66bd22c93ac22fad0c7100fe4972bbb4ac989731,4982
+    pantry-tree:
+      size: 2979
+      sha256: dd092d843091c08691485d68a1908517079b1bc6f3d73928f37635a19dc27fc1
+  original:
+    hackage: optparse-applicative-0.16.1.0@sha256:418c22ed6a19124d457d96bc66bd22c93ac22fad0c7100fe4972bbb4ac989731,4982
+- completed:
+    hackage: protolude-0.3.2@sha256:2a38b3dad40d238ab644e234b692c8911423f9d3ed0e36b62287c4a698d92cd1,2240
+    pantry-tree:
+      size: 1594
+      sha256: a36d2912ac552d950ba4476de7d950b56b82dd28e48b9f4d0efee938f10bc525
+  original:
+    hackage: protolude-0.3.2@sha256:2a38b3dad40d238ab644e234b692c8911423f9d3ed0e36b62287c4a698d92cd1,2240
+- completed:
+    hackage: ptr-0.16.8.2@sha256:708ebb95117f2872d2c5a554eb6804cf1126e86abe793b2673f913f14e5eb1ac,3959
+    pantry-tree:
+      size: 1303
+      sha256: 557c438345de19f82bf01d676100da2a191ef06f624e7a4b90b09ac17cbb52a5
+  original:
+    hackage: ptr-0.16.8.2@sha256:708ebb95117f2872d2c5a554eb6804cf1126e86abe793b2673f913f14e5eb1ac,3959
 snapshots:
 - completed:
-    size: 585392
-    url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/18/2.yaml
-    sha256: 7abb45c0cc5eb349448b66d8753655542d45d387ad26970419282eab3d860724
-  original: lts-18.2
+    size: 618951
+    url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/19/14.yaml
+    sha256: 4c31d4ef975b0211078862566aedf3b82b6cea569fc2cde4c72a51e5a8d236ce
+  original: lts-19.14

test/Feature/CorsSpec.hs

@@ -1,74 +0,0 @@
-module Feature.CorsSpec where
-
--- {{{ Imports
-import qualified Data.ByteString.Lazy as BL
-
-import Network.Wai      (Application)
-import Network.Wai.Test (SResponse (simpleBody, simpleHeaders))
-
-import Network.HTTP.Types
-import Test.Hspec
-import Test.Hspec.Wai
-
-import Protolude
-import SpecHelper
--- }}}
-
-spec :: SpecWith ((), Application)
-spec =
-  describe "CORS" $ do
-    let preflightHeaders = [
-          ("Accept", "*/*"),
-          ("Origin", "http://example.com"),
-          ("Access-Control-Request-Method", "POST"),
-          ("Access-Control-Request-Headers", "Foo,Bar") ]
-    let normalCors = [
-          ("Host", "localhost:3000"),
-          ("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.9; rv:32.0) Gecko/20100101 Firefox/32.0"),
-          ("Origin", "http://localhost:8000"),
-          ("Accept", "text/csv, */*; q=0.01"),
-          ("Accept-Language", "en-US,en;q=0.5"),
-          ("Accept-Encoding", "gzip, deflate"),
-          ("Referer", "http://localhost:8000/"),
-          ("Connection", "keep-alive") ]
-
-    describe "preflight request" $ do
-      it "replies naively and permissively to preflight request" $ do
-        r <- request methodOptions "/items" preflightHeaders ""
-        liftIO $ do
-          let respHeaders = simpleHeaders r
-          respHeaders `shouldSatisfy` matchHeader
-            "Access-Control-Allow-Origin"
-            "http://example.com"
-          respHeaders `shouldSatisfy` matchHeader
-            "Access-Control-Allow-Credentials"
-            "true"
-          respHeaders `shouldSatisfy` matchHeader
-            "Access-Control-Allow-Methods"
-            "GET, POST, PATCH, PUT, DELETE, OPTIONS, HEAD"
-          respHeaders `shouldSatisfy` matchHeader
-            "Access-Control-Allow-Headers"
-            "Authentication, Foo, Bar, Accept, Accept-Language, Content-Language"
-          respHeaders `shouldSatisfy` matchHeader
-            "Access-Control-Max-Age"
-            "86400"
-
-      it "suppresses body in response" $ do
-        r <- request methodOptions "/" preflightHeaders ""
-        liftIO $ simpleBody r `shouldBe` ""
-
-    describe "regular request" $
-      it "exposes necesssary response headers" $ do
-        r <- request methodGet "/items" [("Origin", "http://example.com")] ""
-        liftIO $ simpleHeaders r `shouldSatisfy` matchHeader
-          "Access-Control-Expose-Headers"
-          "Content-Encoding, Content-Location, Content-Range, Content-Type, \
-            \Date, Location, Server, Transfer-Encoding, Range-Unit"
-
-    describe "postflight request" $
-      it "allows INFO body through even with CORS request headers present" $ do
-        r <- request methodOptions "/items" normalCors ""
-        liftIO $ do
-          simpleHeaders r `shouldSatisfy` matchHeader
-            "Access-Control-Allow-Origin" "\\*"
-          simpleBody r `shouldSatisfy` BL.null

test/Feature/DeleteSpec.hs

@@ -1,92 +0,0 @@
-module Feature.DeleteSpec where
-
-import Network.Wai (Application)
-
-import Network.HTTP.Types
-import Test.Hspec
-import Test.Hspec.Wai
-import Test.Hspec.Wai.JSON
-
-import Protolude hiding (get)
-
-spec :: SpecWith ((), Application)
-spec =
-  describe "Deleting" $ do
-    context "existing record" $ do
-      it "succeeds with 204 and deletion count" $
-        request methodDelete "/items?id=eq.1" [] ""
-          `shouldRespondWith` ""
-          { matchStatus  = 204
-          , matchHeaders = ["Content-Range" <:> "*/*"]
-          }
-
-      it "returns the deleted item and count if requested" $
-        request methodDelete "/items?id=eq.2" [("Prefer", "return=representation"), ("Prefer", "count=exact")] ""
-          `shouldRespondWith` [json|[{"id":2}]|]
-          { matchStatus  = 200
-          , matchHeaders = ["Content-Range" <:> "*/1"]
-          }
-
-      it "ignores ?select= when return not set or return=minimal" $ do
-        request methodDelete "/items?id=eq.3&select=id" [] ""
-          `shouldRespondWith` ""
-          { matchStatus  = 204
-          , matchHeaders = ["Content-Range" <:> "*/*"]
-          }
-        request methodDelete "/items?id=eq.3&select=id" [("Prefer", "return=minimal")] ""
-          `shouldRespondWith` ""
-          { matchStatus  = 204
-          , matchHeaders = ["Content-Range" <:> "*/*"]
-          }
-
-      it "returns the deleted item and shapes the response" $
-        request methodDelete "/complex_items?id=eq.2&select=id,name" [("Prefer", "return=representation")] ""
-          `shouldRespondWith` [json|[{"id":2,"name":"Two"}]|]
-          { matchStatus  = 200
-          , matchHeaders = ["Content-Range" <:> "*/*"]
-          }
-
-      it "can rename and cast the selected columns" $
-        request methodDelete "/complex_items?id=eq.3&select=ciId:id::text,ciName:name" [("Prefer", "return=representation")] ""
-          `shouldRespondWith` [json|[{"ciId":"3","ciName":"Three"}]|]
-
-      it "can embed (parent) entities" $
-        request methodDelete "/tasks?id=eq.8&select=id,name,project:projects(id)" [("Prefer", "return=representation")] ""
-          `shouldRespondWith` [json|[{"id":8,"name":"Code OSX","project":{"id":4}}]|]
-          { matchStatus  = 200
-          , matchHeaders = ["Content-Range" <:> "*/*"]
-          }
-
-    context "known route, no records matched" $
-      it "includes [] body if return=rep" $
-        request methodDelete "/items?id=eq.101"
-          [("Prefer", "return=representation")] ""
-          `shouldRespondWith` "[]"
-          { matchStatus  = 200
-          , matchHeaders = ["Content-Range" <:> "*/*"]
-          }
-
-    context "totally unknown route" $
-      it "fails with 404" $
-        request methodDelete "/foozle?id=eq.101" [] "" `shouldRespondWith` 404
-
-    context "table with limited privileges" $ do
-      it "fails deleting the row when return=representation and selecting all the columns" $
-        request methodDelete "/app_users?id=eq.1" [("Prefer", "return=representation")] mempty
-            `shouldRespondWith` 401
-
-      it "succeeds deleting the row when return=representation and selecting only the privileged columns" $
-        request methodDelete "/app_users?id=eq.1&select=id,email" [("Prefer", "return=representation")]
-          [json| { "password": "passxyz" } |]
-            `shouldRespondWith` [json|[ { "id": 1, "email": "test@123.com" } ]|]
-            { matchStatus  = 200
-            , matchHeaders = ["Content-Range" <:> "*/*"]
-            }
-
-      it "suceeds deleting the row with no explicit select when using return=minimal" $
-        request methodDelete "/app_users?id=eq.2" [("Prefer", "return=minimal")] mempty
-            `shouldRespondWith` 204
-
-      it "suceeds deleting the row with no explicit select by default" $
-        request methodDelete "/app_users?id=eq.3" [] mempty
-            `shouldRespondWith` 204

test/Feature/NoJwtSpec.hs

@@ -1,31 +0,0 @@
-module Feature.NoJwtSpec where
-
--- {{{ Imports
-
-import Network.Wai (Application)
-
-import Network.HTTP.Types
-import Test.Hspec
-import Test.Hspec.Wai
-import Test.Hspec.Wai.JSON
-
-import Protolude
-import SpecHelper
--- }}}
-
-spec :: SpecWith ((), Application)
-spec = describe "server started without JWT secret" $ do
-
-  -- this test will stop working 9999999999s after the UNIX EPOCH
-  it "responds with error on attempted auth" $ do
-    let auth = authHeaderJWT "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjk5OTk5OTk5OTksInJvbGUiOiJwb3N0Z3Jlc3RfdGVzdF9hdXRob3IiLCJpZCI6Impkb2UifQ.Dpss-QoLYjec5OTsOaAc3FNVsSjA89wACoV-0ra3ClA"
-    request methodGet "/authors_only" [auth] ""
-      `shouldRespondWith`
-      [json|{"message":"Server lacks JWT secret"}|]
-      { matchStatus  = 500
-      , matchHeaders = [ matchContentTypeJson ]
-      }
-
-  it "behaves normally when user does not attempt auth" $
-    request methodGet "/items" [] ""
-      `shouldRespondWith` 200

test/Feature/NonexistentSchemaSpec.hs

@@ -1,17 +0,0 @@
-module Feature.NonexistentSchemaSpec where
-
-import Network.Wai (Application)
-
-import Test.Hspec
-import Test.Hspec.Wai
-
-import Protolude hiding (get)
-
-spec :: SpecWith ((), Application)
-spec =
-  describe "Non existent api schema" $ do
-    it "succeeds when requesting root path" $
-      get "/" `shouldRespondWith` 200
-
-    it "gives 404 when requesting a nonexistent table in this nonexistent schema" $
-      get "/nonexistent_table" `shouldRespondWith` 404

test/Feature/OptionsSpec.hs

@@ -1,71 +0,0 @@
-module Feature.OptionsSpec where
-
-import Network.Wai      (Application)
-import Network.Wai.Test (SResponse (..))
-
-import Network.HTTP.Types
-import Test.Hspec
-import Test.Hspec.Wai
-
-import Protolude
-import SpecHelper
-
-spec :: SpecWith ((), Application)
-spec = describe "Allow header" $ do
-  context "a table" $ do
-    it "includes read/write verbs for writeable table" $ do
-      r <- request methodOptions "/items" [] ""
-      liftIO $
-        simpleHeaders r `shouldSatisfy`
-          matchHeader "Allow" "OPTIONS,GET,HEAD,POST,PUT,PATCH,DELETE"
-
-  context "a view" $ do
-    context "auto updatable" $ do
-      it "includes read/write verbs for auto updatable views with pk" $ do
-        r <- request methodOptions "/projects_auto_updatable_view_with_pk" [] ""
-        liftIO $
-          simpleHeaders r `shouldSatisfy`
-            matchHeader "Allow" "OPTIONS,GET,HEAD,POST,PUT,PATCH,DELETE"
-
-      it "includes read/write verbs for auto updatable views without pk" $ do
-        r <- request methodOptions "/projects_auto_updatable_view_without_pk" [] ""
-        liftIO $
-          simpleHeaders r `shouldSatisfy`
-            matchHeader "Allow" "OPTIONS,GET,HEAD,POST,PATCH,DELETE"
-
-    context "non auto updatable" $ do
-      it "includes read verbs for non auto updatable views" $ do
-        r <- request methodOptions "/projects_view_without_triggers" [] ""
-        liftIO $
-          simpleHeaders r `shouldSatisfy`
-            matchHeader "Allow" "OPTIONS,GET,HEAD"
-
-      it "includes read/write verbs for insertable, updatable and deletable views with pk" $ do
-        r <- request methodOptions "/projects_view_with_all_triggers_with_pk" [] ""
-        liftIO $
-          simpleHeaders r `shouldSatisfy`
-            matchHeader "Allow" "OPTIONS,GET,HEAD,POST,PUT,PATCH,DELETE"
-
-      it "includes read/write verbs for insertable, updatable and deletable views without pk" $ do
-        r <- request methodOptions "/projects_view_with_all_triggers_without_pk" [] ""
-        liftIO $
-          simpleHeaders r `shouldSatisfy`
-            matchHeader "Allow" "OPTIONS,GET,HEAD,POST,PATCH,DELETE"
-
-      it "includes read and insert verbs for insertable views" $ do
-        r <- request methodOptions "/projects_view_with_insert_trigger" [] ""
-        liftIO $
-          simpleHeaders r `shouldSatisfy`
-            matchHeader "Allow" "OPTIONS,GET,HEAD,POST"
-
-      it "includes read and update verbs for updatable views" $ do
-        r <- request methodOptions "/projects_view_with_update_trigger" [] ""
-        liftIO $
-          simpleHeaders r `shouldSatisfy`
-            matchHeader "Allow" "OPTIONS,GET,HEAD,PATCH"
-
-      it "includes read and delete verbs for deletable views" $ do
-        r <- request methodOptions "/projects_view_with_delete_trigger" [] ""
-        liftIO $
-          simpleHeaders r `shouldSatisfy`
-            matchHeader "Allow" "OPTIONS,GET,HEAD,DELETE"

test/Feature/QueryLimitedSpec.hs

@@ -1,69 +0,0 @@
-module Feature.QueryLimitedSpec where
-
-import Network.Wai (Application)
-
-import Network.HTTP.Types
-import Test.Hspec
-import Test.Hspec.Wai
-import Test.Hspec.Wai.JSON
-
-import Protolude  hiding (get)
-import SpecHelper
-
-spec :: SpecWith ((), Application)
-spec =
-  describe "Requesting many items with server limits(max-rows) enabled" $ do
-    it "restricts results" $
-      get "/items?order=id"
-        `shouldRespondWith`
-          [json| [{"id":1},{"id":2}] |]
-          { matchHeaders = ["Content-Range" <:> "0-1/*"] }
-
-    it "respects additional client limiting" $ do
-      request methodGet  "/items"
-          (rangeHdrs $ ByteRangeFromTo 0 0)
-          ""
-        `shouldRespondWith`
-          [json| [{"id":1}] |]
-          { matchHeaders = ["Content-Range" <:> "0-0/*"] }
-
-    it "works on all levels" $
-      get "/users?select=id,tasks(id)&order=id.asc&tasks.order=id.asc"
-        `shouldRespondWith`
-          [json|[{"id":1,"tasks":[{"id":1},{"id":2}]},{"id":2,"tasks":[{"id":5},{"id":6}]}]|]
-          { matchHeaders = ["Content-Range" <:> "0-1/*"] }
-
-    it "succeeds in getting parent embeds despite the limit, see #647" $
-      get "/tasks?select=id,project:projects(id)&id=gt.5"
-        `shouldRespondWith`
-          [json|[{"id":6,"project":{"id":3}},{"id":7,"project":{"id":4}}]|]
-          { matchHeaders = ["Content-Range" <:> "0-1/*"] }
-
-    it "can offset the parent embed, being consistent with the other embed types" $
-      get "/tasks?select=id,project:projects(id)&id=gt.5&project.offset=1"
-        `shouldRespondWith`
-          [json|[{"id":6,"project":null}, {"id":7,"project":null}]|]
-          { matchHeaders = ["Content-Range" <:> "0-1/*"] }
-
-    context "count=estimated" $ do
-      it "uses the query planner guess when query rows > maxRows" $
-        request methodHead "/getallprojects_view" [("Prefer", "count=estimated")] ""
-          `shouldRespondWith`
-            ""
-            { matchStatus  = 206
-            , matchHeaders = ["Content-Range" <:> "0-1/2019"]
-            }
-
-      it "gives exact count when query rows <= maxRows" $
-        request methodHead "/getallprojects_view?id=lt.3" [("Prefer", "count=estimated")] ""
-          `shouldRespondWith`
-            ""
-            { matchHeaders = ["Content-Range" <:> "0-1/2"] }
-
-      it "only uses the query planner guess if it's indeed greater than the exact count" $
-        request methodHead "/get_projects_above_view" [("Prefer", "count=estimated")] ""
-          `shouldRespondWith`
-            ""
-            { matchStatus  = 206
-            , matchHeaders = ["Content-Range" <:> "0-1/3"]
-            }

test/Main.hs

@@ -1,227 +0,0 @@
-module Main where
-
-import qualified Data.Aeson                 as JSON
-import qualified Hasql.Pool                 as P
-import qualified Hasql.Transaction.Sessions as HT
-
-import Data.Function      (id)
-import Data.List.NonEmpty (toList)
-
-import Test.Hspec
-
-import PostgREST.App              (postgrest)
-import PostgREST.Config           (AppConfig (..), LogLevel (..))
-import PostgREST.Config.Database  (queryPgVersion)
-import PostgREST.Config.PgVersion (pgVersion96)
-import PostgREST.DbStructure      (queryDbStructure)
-import Protolude                  hiding (toList, toS)
-import Protolude.Conv             (toS)
-import SpecHelper
-
-import qualified PostgREST.AppState as AppState
-
-import qualified Feature.AndOrParamsSpec
-import qualified Feature.AsymmetricJwtSpec
-import qualified Feature.AudienceJwtSecretSpec
-import qualified Feature.AuthSpec
-import qualified Feature.BinaryJwtSecretSpec
-import qualified Feature.ConcurrentSpec
-import qualified Feature.CorsSpec
-import qualified Feature.DeleteSpec
-import qualified Feature.DisabledOpenApiSpec
-import qualified Feature.EmbedDisambiguationSpec
-import qualified Feature.ExtraSearchPathSpec
-import qualified Feature.HtmlRawOutputSpec
-import qualified Feature.IgnorePrivOpenApiSpec
-import qualified Feature.InsertSpec
-import qualified Feature.JsonOperatorSpec
-import qualified Feature.MultipleSchemaSpec
-import qualified Feature.NoJwtSpec
-import qualified Feature.NonexistentSchemaSpec
-import qualified Feature.OpenApiSpec
-import qualified Feature.OptionsSpec
-import qualified Feature.ProxySpec
-import qualified Feature.QueryLimitedSpec
-import qualified Feature.QuerySpec
-import qualified Feature.RangeSpec
-import qualified Feature.RawOutputTypesSpec
-import qualified Feature.RollbackSpec
-import qualified Feature.RootSpec
-import qualified Feature.RpcPreRequestGucsSpec
-import qualified Feature.RpcSpec
-import qualified Feature.SingularSpec
-import qualified Feature.UnicodeSpec
-import qualified Feature.UpdateSpec
-import qualified Feature.UpsertSpec
-
-
-main :: IO ()
-main = do
-  testDbConn <- getEnvVarWithDefault "PGRST_DB_URI" "postgres://postgrest_test@localhost/postgrest_test"
-
-  pool <- P.acquire (3, 10, toS testDbConn)
-
-  actualPgVersion <- either (panic.show) id <$> P.use pool queryPgVersion
-
-  baseDbStructure <-
-    loadDbStructure pool
-      (configDbSchemas $ testCfg testDbConn)
-      (configDbExtraSearchPath $ testCfg testDbConn)
-
-  let
-    -- For tests that run with the same refDbStructure
-    app cfg = do
-      let config = cfg testDbConn
-      appState <- AppState.initWithPool pool config
-      AppState.putPgVersion appState actualPgVersion
-      AppState.putDbStructure appState baseDbStructure
-      when (isJust $ configDbRootSpec config) $
-        AppState.putJsonDbS appState $ toS $ JSON.encode baseDbStructure
-      return ((), postgrest LogCrit appState $ pure ())
-
-    -- For tests that run with a different DbStructure(depends on configSchemas)
-    appDbs cfg = do
-      let config = cfg testDbConn
-      customDbStructure <-
-        loadDbStructure pool
-          (configDbSchemas config)
-          (configDbExtraSearchPath config)
-      appState <- AppState.initWithPool pool config
-      AppState.putDbStructure appState customDbStructure
-      when (isJust $ configDbRootSpec config) $
-        AppState.putJsonDbS appState $ toS $ JSON.encode baseDbStructure
-      return ((), postgrest LogCrit appState $ pure ())
-
-  let withApp              = app testCfg
-      maxRowsApp           = app testMaxRowsCfg
-      disabledOpenApi      = app testDisabledOpenApiCfg
-      proxyApp             = app testProxyCfg
-      noJwtApp             = app testCfgNoJWT
-      binaryJwtApp         = app testCfgBinaryJWT
-      audJwtApp            = app testCfgAudienceJWT
-      asymJwkApp           = app testCfgAsymJWK
-      asymJwkSetApp        = app testCfgAsymJWKSet
-      rootSpecApp          = app testCfgRootSpec
-      htmlRawOutputApp     = app testCfgHtmlRawOutput
-      responseHeadersApp   = app testCfgResponseHeaders
-      disallowRollbackApp  = app testCfgDisallowRollback
-      forceRollbackApp     = app testCfgForceRollback
-
-      extraSearchPathApp   = appDbs testCfgExtraSearchPath
-      unicodeApp           = appDbs testUnicodeCfg
-      nonexistentSchemaApp = appDbs testNonexistentSchemaCfg
-      multipleSchemaApp    = appDbs testMultipleSchemaCfg
-      ignorePrivOpenApi    = appDbs testIgnorePrivOpenApiCfg
-
-  let analyze :: IO ()
-      analyze = do
-        analyzeTable testDbConn "items"
-        analyzeTable testDbConn "child_entities"
-
-      specs = uncurry describe <$> [
-          ("Feature.AndOrParamsSpec"         , Feature.AndOrParamsSpec.spec actualPgVersion)
-        , ("Feature.AuthSpec"                , Feature.AuthSpec.spec actualPgVersion)
-        , ("Feature.ConcurrentSpec"          , Feature.ConcurrentSpec.spec)
-        , ("Feature.CorsSpec"                , Feature.CorsSpec.spec)
-        , ("Feature.DeleteSpec"              , Feature.DeleteSpec.spec)
-        , ("Feature.EmbedDisambiguationSpec" , Feature.EmbedDisambiguationSpec.spec)
-        , ("Feature.InsertSpec"              , Feature.InsertSpec.spec actualPgVersion)
-        , ("Feature.JsonOperatorSpec"        , Feature.JsonOperatorSpec.spec actualPgVersion)
-        , ("Feature.OpenApiSpec"             , Feature.OpenApiSpec.spec)
-        , ("Feature.OptionsSpec"             , Feature.OptionsSpec.spec)
-        , ("Feature.QuerySpec"               , Feature.QuerySpec.spec actualPgVersion)
-        , ("Feature.RawOutputTypesSpec"      , Feature.RawOutputTypesSpec.spec)
-        , ("Feature.RpcSpec"                 , Feature.RpcSpec.spec actualPgVersion)
-        , ("Feature.SingularSpec"            , Feature.SingularSpec.spec)
-        , ("Feature.UpdateSpec"              , Feature.UpdateSpec.spec)
-        , ("Feature.UpsertSpec"              , Feature.UpsertSpec.spec)
-        ]
-
-  hspec $ do
-    mapM_ (parallel . before withApp) specs
-
-    -- we analyze to get accurate results from EXPLAIN
-    parallel $ beforeAll_ analyze . before withApp $
-      describe "Feature.RangeSpec" Feature.RangeSpec.spec
-
-    -- this test runs with a raw-output-media-types set to text/html
-    parallel $ before htmlRawOutputApp $
-      describe "Feature.HtmlRawOutputSpec" Feature.HtmlRawOutputSpec.spec
-
-    -- this test runs with a different server flag
-    parallel $ before maxRowsApp $
-      describe "Feature.QueryLimitedSpec" Feature.QueryLimitedSpec.spec
-
-    -- this test runs with a different schema
-    parallel $ before unicodeApp $
-      describe "Feature.UnicodeSpec" Feature.UnicodeSpec.spec
-
-    -- this test runs with openapi-mode set to disabled
-    parallel $ before disabledOpenApi $
-      describe "Feature.DisabledOpenApiSpec" Feature.DisabledOpenApiSpec.spec
-
-    -- this test runs with openapi-mode set to ignore-acl
-    parallel $ before ignorePrivOpenApi $
-      describe "Feature.IgnorePrivOpenApiSpec" Feature.IgnorePrivOpenApiSpec.spec
-
-    -- this test runs with a proxy
-    parallel $ before proxyApp $
-      describe "Feature.ProxySpec" Feature.ProxySpec.spec
-
-    -- this test runs without a JWT secret
-    parallel $ before noJwtApp $
-      describe "Feature.NoJwtSpec" Feature.NoJwtSpec.spec
-
-    -- this test runs with a binary JWT secret
-    parallel $ before binaryJwtApp $
-      describe "Feature.BinaryJwtSecretSpec" Feature.BinaryJwtSecretSpec.spec
-
-    -- this test runs with a binary JWT secret and an audience claim
-    parallel $ before audJwtApp $
-      describe "Feature.AudienceJwtSecretSpec" Feature.AudienceJwtSecretSpec.spec
-
-    -- this test runs with asymmetric JWK
-    parallel $ before asymJwkApp $
-      describe "Feature.AsymmetricJwtSpec" Feature.AsymmetricJwtSpec.spec
-
-    -- this test runs with asymmetric JWKSet
-    parallel $ before asymJwkSetApp $
-      describe "Feature.AsymmetricJwtSpec" Feature.AsymmetricJwtSpec.spec
-
-    -- this test runs with a nonexistent db-schema
-    parallel $ before nonexistentSchemaApp $
-      describe "Feature.NonexistentSchemaSpec" Feature.NonexistentSchemaSpec.spec
-
-    -- this test runs with an extra search path
-    parallel $ before extraSearchPathApp $
-      describe "Feature.ExtraSearchPathSpec" Feature.ExtraSearchPathSpec.spec
-
-    when (actualPgVersion >= pgVersion96) $ do
-      -- this test runs with a root spec function override
-      parallel $ before rootSpecApp $
-        describe "Feature.RootSpec" Feature.RootSpec.spec
-      parallel $ before responseHeadersApp $
-        describe "Feature.RpcPreRequestGucsSpec" Feature.RpcPreRequestGucsSpec.spec
-
-    -- this test runs with multiple schemas
-    parallel $ before multipleSchemaApp $
-      describe "Feature.MultipleSchemaSpec" $ Feature.MultipleSchemaSpec.spec actualPgVersion
-
-    -- Note: the rollback tests can not run in parallel, because they test persistance and
-    -- this results in race conditions
-
-    -- this test runs with tx-rollback-all = true and tx-allow-override = true
-    before withApp $
-      describe"Feature.RollbackAllowedSpec" Feature.RollbackSpec.allowed
-
-    -- this test runs with tx-rollback-all = false and tx-allow-override = false
-    before disallowRollbackApp $
-      describe "Feature.RollbackDisallowedSpec" Feature.RollbackSpec.disallowed
-
-    -- this test runs with tx-rollback-all = true and tx-allow-override = false
-    before forceRollbackApp $
-      describe "Feature.RollbackForcedSpec" Feature.RollbackSpec.forced
-
-  where
-    loadDbStructure pool schemas extraSearchPath =
-      either (panic.show) id <$> P.use pool (HT.transaction HT.ReadCommitted HT.Read $ queryDbStructure (toList schemas) extraSearchPath True)