Upgrade protolude to 0.3.1 (#2306 )

bump version to 9.0.1
* Format CHANGELOG
2022-06-08 16:15:56 -05:00 · 2022-06-03 22:19:16 -05:00 · 2022-06-03 22:19:16 -05:00 · 2022-06-03 22:19:16 -05:00 · 2022-06-03 22:19:16 -05:00 · 2022-06-03 22:19:16 -05:00
182 changed files with 5161 additions and 2573 deletions
@@ -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
@@ -1,71 +1,15 @@
 freebsd_instance:
-  image: freebsd-12-2-release-amd64
+  image_family: freebsd-13-0
 build_task:
-  env:
+  name: Build FreeBSD (Stack)
-    GITHUB_TOKEN: ENCRYPTED[!1ecc3020fe8c6463c06ebc22153533239e132ee56e4faad95ce336bd2ee2bde6aa89c0352e89faaa2c10f4a5bac9b7fc!]
+  install_script: pkg install -y postgresql13-client hs-stack
  # caches the freebsd package downloads
  # saves probably just a couple of seconds, but hey...
  pkg_cache:
    folder: /var/cache/pkg
-  install_script:
+  stack_cache:
-  #  - pkg update
+    folders: /.stack
-    - pkg install -y postgresql12-client ghc hs-cabal-install jq git
+    fingerprint_script: cat postgrest.cabal stack.yaml.lock
  # 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
    reupload_on_changes: false
-  # cache the dependencies built by cabal
+  build_script: stack build -j 1 --local-bin-path . --copy-bins
-  # they have to be uploaded on every change to make the next build fast
+  bin_artifacts:
-  store_cache:
+    path: postgrest
    # 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
@@ -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
@@ -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
@@ -0,0 +1,6 @@
 version: 2
 updates:
 - package-ecosystem: github-actions
  directory: /
  schedule:
    interval: weekly
@@ -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
@@ -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"
@@ -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
@@ -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
@@ -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
@@ -0,0 +1,485 @@
 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 }}'
      - name: Build static executable
        run: nix-build -A postgrestStatic
      - 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
            test: true
            pgdir: /usr/lib/postgresql
            artifact: postgrest-ubuntu-x64
          - name: MacOS & test
            runs-on: macos-latest
            cache: |
              ~/.stack
              .stack-work
            test: true
            pgdir: /usr/local/Cellar/postgresql
            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
            # We'd need to make test/with_tmp_db run on Windows first
            # test: true
            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: Run Spec tests with Stack
        if: ${{ matrix.test }}
        run: |
          postgresql_bin="$(find ${{ matrix.pgdir }} -maxdepth 2 -type d -name bin | head -n 1)"
          echo "Using PostgreSQL binaries at $postgresql_bin ..."
          PATH="$postgresql_bin:$PATH" test/with_tmp_db stack test
      - 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
@@ -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
@@ -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
@@ -21,3 +21,4 @@ __pycache__
 *.tix
 coverage
 .hpc
 loadtest
@@ -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
@@ -3,12 +3,57 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
-## Unreleased
+## [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
@@ -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
@@ -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
    }
  }
 }
@@ -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"
    )
  )
@@ -3,7 +3,7 @@ let
    "postgrest";
  compiler =
-    "ghc8104";
+    "ghc8107";
  # 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,10 +33,10 @@ 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; })
    ];
@@ -46,12 +46,12 @@ let
  postgresqlVersions =
    [
      { name = "postgresql-14"; postgresql = pkgs.postgresql_14; }
      { 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; }
    ];
  patches =
@@ -79,8 +79,7 @@ let
      }
    );
-  lib =
+  inherit (pkgs.haskell) lib;
    pkgs.haskell.lib;
 in
 rec {
  inherit nixpkgs pkgs;
@@ -103,13 +102,12 @@ rec {
      )
    );
-  env =
+  inherit (postgrest) env;
    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 +117,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 +137,20 @@ rec {
  # Scripts for publishing new releases.
  release =
-    pkgs.callPackage nix/tools/release {
+    pkgs.callPackage nix/tools/release { };
      inherit docker;
      postgrest = postgrestStatic;
    };
  # 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;
    };
  withTools =
-    pkgs.callPackage nix/tools/withTools.nix { inherit postgresqlVersions; };
+    pkgs.callPackage nix/tools/withTools.nix { inherit devCabalOptions postgresqlVersions postgrest; };
 }
@@ -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-style-check             postgrest-with-postgresql-9.6
-postgrest-test-io                 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-style-check             postgrest-with-postgresql-9.6
-postgrest-test-io                 postgrest-with-postgresql-9.6
+postgrest-test-io
 postgrest-test-memory
 ...
@@ -149,7 +149,7 @@ 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
@@ -17,6 +17,7 @@ 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
@@ -27,13 +28,14 @@ import qualified Language.Haskell.GHC.ExactPrint.Parsers as ExactPrint
 import qualified Options.Applicative                     as O
 import qualified System.FilePath                         as FP
 import Bag                        (bagToList)
 import Data.Aeson.Encode.Pretty   (encodePretty)
 import Data.Function              ((&))
 import Data.List                  (intercalate)
 import Data.Maybe                 (catMaybes, mapMaybe)
 import Data.Text                  (Text)
 import GHC.Generics               (Generic)
-import HsExtension                (GhcPs)
+import GHC.Hs.Extension           (GhcPs)
 import Module                     (moduleNameString)
 import OccName                    (occNameString)
 import RdrName                    (rdrNameOcc)
@@ -201,8 +203,9 @@ parseModule filepath = do
  case result of
    Right (_, hsmod) ->
      return $ GHC.unLoc hsmod
-    Left (loc, err) ->
+    Left errs ->
-      fail $ "Error with " <> show filepath <> " at " <> show loc <> ": " <> err
+      fail $ "Errors with " <> show filepath <> ":\n    "
        <> List.intercalate "\n    " (show <$> bagToList errs)
 -- | Symbols imported in an import declaration.
 --
@@ -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
@@ -1,6 +1,6 @@
 # Pinned version of Nixpkgs, generated with postgrest-nixpkgs-upgrade.
 {
-  date = "2021-07-17";
+  date = "2021-11-02";
-  rev = "d00b5a5fa6fe8bdf7005abb06c46ae0245aec8b5";
+  rev = "7053541084bf5ce2921ef307e5585d39d7ba8b3f";
-  tarballHash = "08497wbpnf3w5dalcasqzymw3fmcn8qrnbkf8rxxwwvyjdnczxdv";
+  tarballHash = "1flhh5d4zy43x6060hvzjb5hi5cmc51ivc0nwmija9n8d35kcc4x";
 }
@@ -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()
@@ -64,8 +64,8 @@ let
        ${argbash}/bin/argbash --type completion --strip all ${argsTemplate}/${name}.m4 > $out
      ''
-      + lib.optionalString addCommandCompletion ''
+      + lib.optionalString (positionalCompletion != "") ''
-        sed 's/COMPREPLY.*compgen -o bashdefault .*$/_command/' -i $out
+        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 ''
@@ -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;
 }
@@ -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 { };
 }
@@ -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;
 }
@@ -2,8 +2,7 @@
 self: super:
 let
-  lib =
+  inherit (self.haskell) lib;
    self.haskell.lib;
  overrides =
    final: prev:
@@ -21,6 +20,54 @@ let
      # To get the sha256:
      #   nix-prefetch-url --unpack https://hackage.haskell.org/package/protolude-0.3.0/protolude-0.3.0.tar.gz
      # 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
      protolude =
        prev.callHackageDirect
          {
            pkg = "protolude";
            ver = "0.3.1";
            sha256 = "0gf0mn1ycllr69kdq1p07qf7935s10jz0nnhynwqy3d6nmycxr5j";
          }
          { };
      wai-extra =
        prev.callHackageDirect
          {
            pkg = "wai-extra";
            ver = "3.1.8";
            sha256 = "1ha8sxc2ii7k7xs5nm06wfwqmf4f1p2acp4ya0jnx6yn6551qps4";
          }
          { };
      wai-logger =
        prev.callHackageDirect
          {
            pkg = "wai-logger";
            ver = "2.3.7";
            sha256 = "1d23fdbwbahr3y1vdyn57m1qhljy22pm5cpgb20dy6mlxzdb30xd";
          }
          { };
      warp =
        lib.dontCheck (prev.callHackageDirect
          {
            pkg = "warp";
            ver = "3.3.19";
            sha256 = "0y3jj4bhviss6ff9lwxki0zbdcl1rb398bk4s80zvfpnpy7p94cx";
          }
          { });
      hasql-dynamic-statements =
        lib.dontCheck (lib.unmarkBroken prev.hasql-dynamic-statements);
@@ -1,5 +1,5 @@
 self: super:
 # Overlay that sets the default version of PostgreSQL.
 {
-  postgresql = super.postgresql_13;
+  postgresql = super.postgresql_14;
 }
@@ -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;
 }
@@ -5,16 +5,16 @@ self: super:
  # PostgreSQL 9.5 was removed from Nixpkgs with
  # https://github.com/NixOS/nixpkgs/commit/72ab382fb6b729b0d654f2c03f5eb25b39f11fbb
  # We pin its parent commit to get the last version that was available.
-  postgresql_9_5 =
+  # postgresql_9_5 =
-    let
+  #  let
-      rev = "55ac7d4580c9ab67848c98cb9519317a1cc399c8";
+  #    rev = "55ac7d4580c9ab67848c98cb9519317a1cc399c8";
-      tarballHash = "02ffj9f8s1hwhmxj85nx04sv64qb6jm7w0122a1dz9n32fymgklj";
+  #    tarballHash = "02ffj9f8s1hwhmxj85nx04sv64qb6jm7w0122a1dz9n32fymgklj";
-
+  #
-      pinnedPkgs =
+  #    pinnedPkgs =
-        builtins.fetchTarball {
+  #      builtins.fetchTarball {
-          url = "https://github.com/nixos/nixpkgs/archive/${rev}.tar.gz";
+  #        url = "https://github.com/nixos/nixpkgs/archive/${rev}.tar.gz";
-          sha256 = tarballHash;
+  #        sha256 = tarballHash;
-        };
+  #      };
-    in
+  #  in
-    (import pinnedPkgs { }).pkgs.postgresql_9_5;
+  #  (import pinnedPkgs { }).pkgs.postgresql_9_5;
 }
@@ -39,16 +39,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.
  normalPkgs =
    import patchedNixpkgs { inherit overlays; };
  defaultCabalPackageVersionComingWithGhc =
    {
      ghc8107 = "Cabal_3_2_1_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}"
@@ -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,161 @@ 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
+            This currently excludes the memory and spec-idempotence tests,
-            expensive.
+            as those are particularly expensive.
          '';
        inRootDir = true;
      }
      ''
-        ${tests}/bin/postgrest-with-all ${tests}/bin/postgrest-test-spec
+        ${tests}/bin/postgrest-test-spec
-        ${tests}/bin/postgrest-test-spec-idempotence
+        ${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 [ disabled != "$_arg_mode" ]; 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_@}"
          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 '${git}/bin/git stash pop $(git stash list --format=format:%gD --grep "$stash" -n1)' 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 '${git}/bin/git stash pop $(git stash list --format=format:%gD --grep "$stash" -n1)' 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 +287,7 @@ buildToolbox
    watch
    pushCachix
    check
    gitHooks
    dumpMinimalImports
    hsieMinimalImports
    hsieGraphModules
@@ -0,0 +1,174 @@
 { 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;
      }
      ''
        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 \"''${_arg_leftovers[@]}\"" \
          | tee "$_arg_output" \
          | ${vegeta}/bin/vegeta report -type=text
      '';
  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 ];
 }
@@ -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.withPg} test/memory/memory-tests.sh
        ${withTools.latest} test/memory-tests.sh
      '';
 in
@@ -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
@@ -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,29 @@ 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_USER:?DOCKER_USER is required}"
-        DOCKER_PASS="''${DOCKER_PASS:?DOCKER_PASS is required}"
+        : "''${DOCKER_PASS:?DOCKER_PASS is required}"
-        DOCKER_REPO="''${DOCKER_REPO:?DOCKER_REPO 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.
+        repo_url="https://hub.docker.com/v2/repositories/$DOCKER_REPO/postgrest/"
-        responseCode="$(
+        echo "Patching both descriptions at $repo_url ..." 
-          ${curl}/bin/curl -s --write-out "%{response_code}" \
+        ${curl}/bin/curl --fail -X PATCH "$repo_url" \
-            --output /dev/null -H "Authorization: JWT $token" -X PATCH \
+          -H "Authorization: JWT $token" \
-            --data-urlencode description@${description} \
+          --data-urlencode description@${description} \
-            --data-urlencode full_description@${fullDescription} \
+          --data-urlencode full_description@${fullDescription}
            "https://hub.docker.com/v2/repositories/$DOCKER_REPO/postgrest/"
        )"
        [ "$responseCode" -eq 200 ]
      '';
 in
 buildToolbox
 {
  name = "postgrest-release";
-  tools = [ github dockerLogin dockerHub dockerHubDescription ];
+  tools = [ dockerHubDescription ];
 }
@@ -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
@@ -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,6 +44,8 @@ let
      ''
        ${style}
        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'
      '';
@@ -47,17 +53,27 @@ let
    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
+        echo "Linting bash scripts..."
-        ${shellcheck}/bin/shellcheck test/create_test_db test/memory-tests.sh
+        ${shellcheck}/bin/shellcheck \
          .github/get_cirrusci_freebsd \
          .github/release \
          test/with_tmp_db
        echo "Linting workflows..."
        ${actionlint}/bin/actionlint
      '';
 in
@@ -5,7 +5,7 @@
 , ghc
 , glibcLocales
 , gnugrep
-, haskell
+, haskellPackages
 , hpc-codecov
 , jq
 , postgrest
@@ -24,7 +24,37 @@ let
        withEnv = postgrest.env;
      }
      ''
-        ${withTools.latest} ${cabal-install}/bin/cabal v2-test ${devCabalOptions}
+        ${withTools.withPg} ${cabal-install}/bin/cabal v2-run ${devCabalOptions} test:spec
      '';
  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 +66,9 @@ let
        withEnv = postgrest.env;
      }
      ''
-        ${withTools.latest} ${runtimeShell} -c " \
+        ${withTools.withPg} ${runtimeShell} -c " \
-          ${cabal-install}/bin/cabal v2-test ${devCabalOptions} && \
+          ${cabal-install}/bin/cabal v2-run ${devCabalOptions} test:spec && \
-          ${cabal-install}/bin/cabal v2-test ${devCabalOptions}"
+          ${cabal-install}/bin/cabal v2-run ${devCabalOptions} test:spec"
      '';
  ioTestPython =
@@ -62,8 +92,8 @@ let
      }
      ''
        ${cabal-install}/bin/cabal v2-build ${devCabalOptions}
-        ${cabal-install}/bin/cabal v2-exec ${withTools.latest} \
+        ${cabal-install}/bin/cabal v2-exec -- ${withTools.withPg} -f test/io/fixtures.sql \
-          ${ioTestPython}/bin/pytest -- -v test/io-tests "''${_arg_leftovers[@]}"
+          ${ioTestPython}/bin/pytest -v test/io "''${_arg_leftovers[@]}"
      '';
  dumpSchema =
@@ -73,11 +103,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.withPg} \
        ${withTools.latest} \
            ${cabal-install}/bin/cabal v2-run ${devCabalOptions} --verbose=0 -- \
            postgrest --dump-schema \
            | ${yq}/bin/yq -y .
@@ -87,7 +116,7 @@ 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;
@@ -102,18 +131,26 @@ let
        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
+        ${cabal-install}/bin/cabal v2-build ${devCabalOptions} exe:postgrest lib:postgrest test:spec test:querycost
        ${haskellPackages.weeder}/bin/weeder --config=./test/weeder.dhall || echo Found dead code: Check file list above.
        # collect all tests
        HPCTIXFILE="$tmpdir"/io.tix \
-        ${withTools.latest} ${cabal-install}/bin/cabal v2-exec ${devCabalOptions} \
+          ${withTools.withPg} -f test/io/fixtures.sql ${cabal-install}/bin/cabal v2-exec ${devCabalOptions} -- \
-          ${ioTestPython}/bin/pytest -- -v test/io-tests
+          ${ioTestPython}/bin/pytest -v test/io
        HPCTIXFILE="$tmpdir"/spec.tix \
-        ${withTools.latest} ${cabal-install}/bin/cabal v2-test ${devCabalOptions}
+          ${withTools.withPg} ${cabal-install}/bin/cabal v2-run ${devCabalOptions} test:spec
        HPCTIXFILE="$tmpdir"/querycost.tix \
          ${withTools.withPg} ${cabal-install}/bin/cabal v2-run ${devCabalOptions} test:querycost
        # 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
+        ${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
@@ -164,6 +201,8 @@ buildToolbox
  tools =
    [
      testSpec
      testQuerycost
      testDoctests
      testSpecIdempotence
      testIO
      dumpSchema
@@ -1,9 +1,14 @@
 { bashCompletion
 , buildToolbox
 , cabal-install
 , checkedShellScript
 , curl
 , devCabalOptions
 , git
 , lib
 , postgresqlVersions
-, writeTextFile
+, postgrest
 , writeText
 }:
 let
  withTmpDb =
@@ -14,7 +19,7 @@ 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])"
@@ -22,18 +27,18 @@ let
            "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 "$@"
+          exec "$_arg_command" "''${_arg_leftovers[@]}"
        fi
-        
+
        export PATH=${postgresql}/bin:"$PATH"
        setuplog="$tmpdir/setup.log"
        log () {
@@ -60,18 +65,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" \
          >> "$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 +83,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 +118,157 @@ 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
        ${cabal-install}/bin/cabal v2-build ${devCabalOptions} > "$tmpdir"/build.log 2>&1
        ${cabal-install}/bin/cabal v2-run ${devCabalOptions} --verbose=0 -- \
          postgrest ${legacyConfig} > "$tmpdir"/run.log 2>&1 &
        # to get the pid of the postgrest process, we need to jump through some hoops
        # $! will return the pid of cabal - but killing this, will not propagate to postgrest
        pid=$(timeout -s TERM 1 ${waitForPgrstPid})
        cleanup() {
          kill "$pid" || true
        }
        trap cleanup EXIT
        timeout -s TERM 5 ${waitForPgrstReady}
        ("$_arg_command" "''${_arg_leftovers[@]}")
      '';
 in
 buildToolbox
 {
  name = "postgrest-with";
-  tools = [ withAll ] ++ withVersions;
+  tools = [ withPgAll withGit withPgrst ] ++ withPgVersions;
-  extra = {
+  # make withTools available for other nix files
-    # make withTools.latest available for other nix files
+  extra = { inherit withGit withPg withPgAll withPgrst; };
    latest = withTmpDb (builtins.head postgresqlVersions);
  };
 }
@@ -1,8 +1,8 @@
 name:               postgrest
-version:            8.0.0
+version:            9.0.1
 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 verbs that security
                    permits.
 license:            MIT
 license-file:       LICENSE
@@ -44,6 +44,7 @@ library
                      PostgREST.Config.PgVersion
                      PostgREST.Config.Proxy
                      PostgREST.ContentType
                      PostgREST.Cors
                      PostgREST.DbStructure
                      PostgREST.DbStructure.Identifiers
                      PostgREST.DbStructure.Proc
@@ -51,6 +52,7 @@ library
                      PostgREST.DbStructure.Table
                      PostgREST.Error
                      PostgREST.GucHeader
                      PostgREST.Logger
                      PostgREST.Middleware
                      PostgREST.OpenAPI
                      PostgREST.Query.QueryBuilder
@@ -65,11 +67,10 @@ library
                      PostgREST.Version
                      PostgREST.Workers
  other-modules:      Paths_postgrest
-  build-depends:      base                      >= 4.9 && < 4.15
+  build-depends:      base                      >= 4.9 && < 4.16
                    , 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
                    , auto-update               >= 0.1.4 && < 0.2
                    , base64-bytestring         >= 1 && < 1.3
                    , bytestring                >= 0.10.8 && < 0.11
@@ -77,11 +78,9 @@ library
                    , 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
@@ -99,9 +98,9 @@ library
                    , 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
                    , text                      >= 1.2.2 && < 1.3
@@ -110,10 +109,8 @@ library
                    , 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-extra                 >= 3.1.8 && < 3.2
-                    , wai-logger                >= 2.3.2
+                    , warp                      >= 3.3.19 && < 3.4
                    , wai-middleware-static     >= 0.8.1 && < 0.10
                    , warp                      >= 3.2.12 && < 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 +120,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
@@ -143,16 +140,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.16
                    , containers          >= 0.5.7 && < 0.7
                    , postgrest
-                    , protolude           >= 0.3 && < 0.4
+                    , protolude           >= 0.3.1 && < 0.4
-  ghc-options:        -threaded -rtsopts "-with-rtsopts=-N -I2"
+  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,7 +163,7 @@ 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
@@ -176,11 +175,13 @@ test-suite spec
                      Feature.DeleteSpec
                      Feature.DisabledOpenApiSpec
                      Feature.EmbedDisambiguationSpec
                      Feature.EmbedInnerJoinSpec
                      Feature.ExtraSearchPathSpec
                      Feature.HtmlRawOutputSpec
                      Feature.InsertSpec
                      Feature.IgnorePrivOpenApiSpec
                      Feature.JsonOperatorSpec
                      Feature.LegacyGucsSpec
                      Feature.MultipleSchemaSpec
                      Feature.NoJwtSpec
                      Feature.NonexistentSchemaSpec
@@ -201,7 +202,7 @@ test-suite spec
                      Feature.UpsertSpec
                      SpecHelper
                      TestTypes
-  build-depends:      base              >= 4.9 && < 4.15
+  build-depends:      base              >= 4.9 && < 4.16
                    , aeson             >= 1.4.7 && < 1.6
                    , aeson-qq          >= 0.8.1 && < 0.9
                    , async             >= 2.1.1 && < 2.3
@@ -209,14 +210,11 @@ test-suite spec
                    , 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-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
@@ -225,57 +223,67 @@ test-suite spec
                    , 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
+test-suite querycost
-  type:                exitcode-stdio-1.0
+  type:               exitcode-stdio-1.0
-  default-language:    Haskell2010
+  default-language:   Haskell2010
-  default-extensions:  OverloadedStrings
+  default-extensions: OverloadedStrings
-                       QuasiQuotes
+                      QuasiQuotes
-                       NoImplicitPrelude
+                      NoImplicitPrelude
-  hs-source-dirs:      test
+  hs-source-dirs:     test/spec
-  main-is:             QueryCost.hs
+  main-is:            QueryCost.hs
-  other-modules:       SpecHelper
+  other-modules:      SpecHelper
-  build-depends:       base              >= 4.9 && < 4.15
+  build-depends:      base              >= 4.9 && < 4.16
-                     , aeson             >= 1.4.7 && < 1.6
+                    , aeson             >= 1.4.7 && < 1.6
-                     , aeson-qq          >= 0.8.1 && < 0.9
+                    , base64-bytestring >= 1 && < 1.3
-                     , async             >= 2.1.1 && < 2.3
+                    , bytestring        >= 0.10.8 && < 0.11
-                     , auto-update       >= 0.1.4 && < 0.2
+                    , case-insensitive  >= 1.2 && < 1.3
-                     , base64-bytestring >= 1 && < 1.3
+                    , containers        >= 0.5.7 && < 0.7
-                     , bytestring        >= 0.10.8 && < 0.11
+                    , contravariant     >= 1.4 && < 1.6
-                     , case-insensitive  >= 1.2 && < 1.3
+                    , hasql             >= 1.4 && < 1.5
-                     , cassava           >= 0.4.5 && < 0.6
+                    , hasql-dynamic-statements  == 0.3.1
-                     , containers        >= 0.5.7 && < 0.7
+                    , hasql-pool        >= 0.5 && < 0.6
-                     , contravariant     >= 1.4 && < 1.6
+                    , hasql-transaction >= 1.0.1 && < 1.1
-                     , hasql             >= 1.4 && < 1.5
+                    , heredoc           >= 0.2 && < 0.3
-                     , hasql-dynamic-statements  == 0.3.1
+                    , hspec             >= 2.3 && < 2.9
-                     , hasql-pool        >= 0.5 && < 0.6
+                    , hspec-wai         >= 0.10 && < 0.12
-                     , hasql-transaction >= 1.0.1 && < 1.1
+                    , http-types        >= 0.12.3 && < 0.13
-                     , heredoc           >= 0.2 && < 0.3
+                    , lens              >= 4.14 && < 5.1
-                     , hspec             >= 2.3 && < 2.8
+                    , lens-aeson        >= 1.0.1 && < 1.2
-                     , hspec-wai         >= 0.10 && < 0.12
+                    , postgrest
-                     , hspec-wai-json    >= 0.10 && < 0.12
+                    , process           >= 1.4.2 && < 1.7
-                     , http-types        >= 0.12.3 && < 0.13
+                    , protolude         >= 0.3.1 && < 0.4
-                     , lens              >= 4.14 && < 5.1
+                    , regex-tdfa        >= 1.2.2 && < 1.4
-                     , lens-aeson        >= 1.0.1 && < 1.2
+                    , wai-extra         >= 3.0.19 && < 3.2
-                     , monad-control     >= 1.0.1 && < 1.1
+  ghc-options:        -O0 -Werror -Wall -fwarn-identities
-                     , postgrest
+                      -fno-spec-constr -optP-Wno-nonportable-include-path
-                     , process           >= 1.4.2 && < 1.7
+                      -fwrite-ide-info
-                     , protolude         >= 0.3 && < 0.4
+                      -- https://github.com/PostgREST/postgrest/issues/387
-                     , regex-tdfa        >= 1.2.2 && < 1.4
+                      -with-rtsopts=-K1K
-                     , text              >= 1.2.2 && < 1.3
+
-                     , time              >= 1.6 && < 1.11
+test-suite doctests
-                     , transformers-base >= 0.4.4 && < 0.5
+  type:               exitcode-stdio-1.0
-                     , wai               >= 3.2.1 && < 3.3
+  default-language:   Haskell2010
-                     , wai-extra         >= 3.0.19 && < 3.2
+  default-extensions: OverloadedStrings
-  ghc-options:         -O0 -Werror -Wall -fwarn-identities
+                      NoImplicitPrelude
-                       -fno-spec-constr -optP-Wno-nonportable-include-path
+  hs-source-dirs:     test/doc
  main-is:            Main.hs
  build-depends:      base              >= 4.9 && < 4.16
                    , 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
@@ -2,39 +2,34 @@
 # disabled by default. You can activate them by passing arguments to nix-shell,
 # e.g.:
 #
-#    nix-shell --arg release true
+#    nix-shell --arg docker true
 #
 # This will provide you with a shell where the `postgrest-release-*` scripts
 # are available.
 #
 # 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;
-  pkgs =
+  inherit (postgrest) pkgs;
    postgrest.pkgs;
-  lib =
+  inherit (pkgs) lib;
    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 memory postgrest.memory;
    ++ lib.optional release postgrest.release;
 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
      ]
@@ -51,6 +47,7 @@ lib.overrideDerivation postgrest.env (
    shellHook =
      ''
        source ${pkgs.bashCompletion}/etc/profile.d/bash_completion.sh
        source ${pkgs.git}/share/git/contrib/completion/git-completion.bash
        source ${postgrest.hsie.bashCompletion}
      ''
@@ -26,10 +26,10 @@ 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.HashMap.Strict             as M
-import qualified Data.Set                        as Set
+import qualified Data.Set                        as S
 import qualified Hasql.DynamicStatements.Snippet as SQL
 import qualified Hasql.Pool                      as SQL
 import qualified Hasql.Transaction               as SQL
@@ -42,8 +42,10 @@ import qualified Network.Wai.Handler.Warp        as Warp
 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
@@ -76,7 +78,8 @@ import PostgREST.Request.ApiRequest      (Action (..),
                                          Target (..))
 import PostgREST.Request.Preferences     (PreferCount (..),
                                          PreferParameters (..),
-                                          PreferRepresentation (..))
+                                          PreferRepresentation (..),
                                          toAppliedHeader)
 import PostgREST.Request.Types           (ReadRequest, fstFieldNames)
 import PostgREST.Version                 (prettyVersion)
 import PostgREST.Workers                 (connectionWorker, listener)
@@ -84,8 +87,7 @@ import PostgREST.Workers                 (connectionWorker, listener)
 import qualified PostgREST.ContentType      as ContentType
 import qualified PostgREST.DbStructure.Proc as Proc
-import Protolude      hiding (Handler, toS)
+import Protolude hiding (Handler)
 import Protolude.Conv (toS)
 data RequestContext = RequestContext
@@ -133,12 +135,13 @@ 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 =
+postgrest logLevel appState connWorker =
-  Middleware.pgrstMiddleware logLev $
+  Logger.middleware logLevel .
  Cors.middleware $
    \req respond -> do
      time <- AppState.getTime appState
      conf <- AppState.getConfig appState
@@ -152,13 +155,19 @@ postgrest logLev appState connWorker =
          runExceptT $ postgrestResponse conf maybeDbStructure jsonDbS pgVer (AppState.getPool appState) time req
      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.
-      when (Wai.responseStatus response == HTTP.status503) connWorker
+      let isPGAway = Wai.responseStatus response == HTTP.status503
      when isPGAway connWorker
      resp <- addRetryHint isPGAway appState response
      respond resp
-      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
@@ -184,7 +193,7 @@ postgrestResponse conf maybeDbStructure jsonDbS pgVer pool time req = do
      ApiRequest.userApiRequest conf dbStructure req body
  -- The JWT must be checked before touching the db
-  jwtClaims <- Auth.jwtClaims conf (toS iJWT) time
+  jwtClaims <- Auth.jwtClaims conf (toUtf8Lazy iJWT) time
  let
    handleReq apiReq =
@@ -192,7 +201,7 @@ postgrestResponse conf maybeDbStructure jsonDbS pgVer pool time req = do
  runDbHandler pool (txMode apiRequest) jwtClaims (configDbPreparedStatements conf) .
    Middleware.optionalRollback conf apiRequest $
-      Middleware.runPgLocals conf jwtClaims handleReq apiRequest jsonDbS
+      Middleware.runPgLocals conf jwtClaims handleReq apiRequest jsonDbS pgVer
 runDbHandler :: SQL.Pool -> SQL.Mode -> Auth.JWTClaims -> Bool -> DbHandler a -> Handler IO a
 runDbHandler pool mode jwtClaims prepared handler = do
@@ -252,7 +261,6 @@ handleRead headersOnly identifier context@RequestContext{..} = do
        (shouldCount iPreferCount)
        (iAcceptContentType == CTTextCSV)
        bField
        ctxPgVersion
        configDbPreparedStatements
  total <- readTotal ctxConfig ctxApiRequest tableTotal countQuery
@@ -264,14 +272,14 @@ handleRead headersOnly identifier context@RequestContext{..} = do
      [ contentRange
      , ( "Content-Location"
        , "/"
-            <> toS (qiName identifier)
+            <> toUtf8 (qiName identifier)
-            <> if BS8.null iCanonicalQS then mempty else "?" <> toS iCanonicalQS
+            <> if BS.null iCanonicalQS then mempty else "?" <> iCanonicalQS
        )
      ]
      ++ contentTypeHeaders context
  failNotSingular iAcceptContentType queryTotal . response status headers $
-    if headersOnly then mempty else toS body
+    if headersOnly then mempty else LBS.fromStrict body
 readTotal :: AppConfig -> ApiRequest -> Maybe Int64 -> SQL.Snippet -> DbHandler (Maybe Int64)
 readTotal AppConfig{..} ApiRequest{..} tableTotal countQuery =
@@ -308,7 +316,7 @@ handleCreate identifier@QualifiedIdentifier{..} context@RequestContext{..} = do
            Just
              ( HTTP.hLocation
              , "/"
-                  <> toS qiName
+                  <> toUtf8 qiName
                  <> HTTP.renderSimpleQuery True (splitKeyValue <$> resFields)
              )
        , Just . RangeQuery.contentRangeH 1 0 $
@@ -316,12 +324,12 @@ handleCreate identifier@QualifiedIdentifier{..} context@RequestContext{..} = do
        , if null pkCols && isNothing iOnConflict then
            Nothing
          else
-            (\x -> ("Preference-Applied", BS8.pack $ show x)) <$> iPreferResolution
+            toAppliedHeader <$> iPreferResolution
        ]
  failNotSingular iAcceptContentType resQueryTotal $
    if iPreferRepresentation == Full then
-      response HTTP.status201 (headers ++ contentTypeHeaders context) (toS resBody)
+      response HTTP.status201 (headers ++ contentTypeHeaders context) (LBS.fromStrict resBody)
    else
      response HTTP.status201 headers mempty
@@ -332,7 +340,7 @@ handleUpdate identifier context@(RequestContext _ _ ApiRequest{..} _) = do
  let
    response = gucResponse resGucStatus resGucHeaders
    fullRepr = iPreferRepresentation == Full
-    updateIsNoOp = Set.null iColumns
+    updateIsNoOp = S.null iColumns
    status
      | resQueryTotal == 0 && not updateIsNoOp = HTTP.status404
      | fullRepr = HTTP.status200
@@ -343,7 +351,7 @@ handleUpdate identifier context@(RequestContext _ _ ApiRequest{..} _) = do
  failNotSingular iAcceptContentType resQueryTotal $
    if fullRepr then
-      response status (contentTypeHeaders context ++ [contentRangeHeader]) (toS resBody)
+      response status (contentTypeHeaders context ++ [contentRangeHeader]) (LBS.fromStrict resBody)
    else
      response status [contentRangeHeader] mempty
@@ -367,7 +375,7 @@ handleSingleUpsert identifier context@(RequestContext _ _ ApiRequest{..} _) = do
  return $
    if iPreferRepresentation == Full then
-      response HTTP.status200 (contentTypeHeaders context) (toS resBody)
+      response HTTP.status200 (contentTypeHeaders context) (LBS.fromStrict resBody)
    else
      response HTTP.status204 (contentTypeHeaders context) mempty
@@ -385,7 +393,7 @@ handleDelete identifier context@(RequestContext _ _ ApiRequest{..} _) = do
    if iPreferRepresentation == Full then
      response HTTP.status200
        (contentTypeHeaders context ++ [contentRangeHeader])
-        (toS resBody)
+        (LBS.fromStrict resBody)
    else
      response HTTP.status204 [contentRangeHeader] mempty
@@ -400,7 +408,7 @@ handleInfo identifier RequestContext{..} =
    allOrigins = ("Access-Control-Allow-Origin", "*")
    allowH table =
      ( HTTP.hAllow
-      , BS8.intercalate "," $
+      , BS.intercalate "," $
          ["OPTIONS,GET,HEAD"]
          ++ ["POST" | tableInsertable table]
          ++ ["PUT" | tableInsertable table && tableUpdatable table && hasPK]
@@ -423,25 +431,17 @@ 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
  let callReq = ReqBuilder.callRequest proc ctxApiRequest req
  (tableTotal, queryTotal, body, gucHeaders, gucStatus) <-
    lift . SQL.statement mempty $
      Statements.callProcStatement
-        (returnsScalar iTarget)
+        (Proc.procReturnsScalar proc)
-        (returnsSingle iTarget)
+        (Proc.procReturnsSingle proc)
-        (QueryBuilder.requestToCallProcQuery
+        (QueryBuilder.requestToCallProcQuery callReq)
          (QualifiedIdentifier (pdSchema proc) (pdName proc))
          (Proc.specifiedProcArgs iColumns proc)
          iPayload
          (returnsScalar iTarget)
          iPreferParameters
          (ReqBuilder.returningCols req [])
        )
        (QueryBuilder.readRequestToQuery req)
        (QueryBuilder.readRequestToCountQuery req)
        (shouldCount iPreferCount)
@@ -449,7 +449,6 @@ handleInvoke invMethod proc context@RequestContext{..} = do
        (iAcceptContentType == CTTextCSV)
        (iPreferParameters == Just MultipleObjects)
        bField
        ctxPgVersion
        (configDbPreparedStatements ctxConfig)
  response <- liftEither $ gucResponse <$> gucStatus <*> gucHeaders
@@ -461,21 +460,21 @@ handleInvoke invMethod proc context@RequestContext{..} = do
  failNotSingular iAcceptContentType queryTotal $
    response status
      (contentTypeHeaders context ++ [contentRange])
-      (if invMethod == InvHead then mempty else toS body)
+      (if invMethod == InvHead then mempty else LBS.fromStrict body)
 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.accessibleTables ctxPgVersion configDbPreparedStatements)
-           <*> SQL.statement tSchema (DbStructure.accessibleProcs 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)
+              (M.filterWithKey (\(QualifiedIdentifier sch _) _ ->  sch == tSchema) $ DbStructure.dbProcs dbStructure)
          <$> SQL.statement tSchema (DbStructure.schemaDescription configDbPreparedStatements)
      OADisabled ->
        pure mempty
@@ -483,7 +482,7 @@ handleOpenApi headersOnly tSchema (RequestContext conf@AppConfig{..} dbStructure
  return $
    Wai.responseLBS HTTP.status200
      (ContentType.toHeader CTOpenAPI : maybeToList (profileHeader apiRequest))
-      (if headersOnly then mempty else toS body)
+      (if headersOnly then mempty else body)
 txMode :: ApiRequest -> SQL.Mode
 txMode ApiRequest{..} =
@@ -534,7 +533,6 @@ writeQuery identifier@QualifiedIdentifier{..} isInsert pkCols context@RequestCon
        (iAcceptContentType ctxApiRequest == CTTextCSV)
        (iPreferRepresentation ctxApiRequest)
        pkCols
        ctxPgVersion
        (configDbPreparedStatements ctxConfig)
  liftEither $ WriteQueryResult queryTotal fields body <$> gucStatus <*> gucHeaders
@@ -607,10 +605,10 @@ rawContentTypes AppConfig{..} =
 profileHeader :: ApiRequest -> Maybe HTTP.Header
 profileHeader ApiRequest{..} =
-  (,) "Content-Profile" <$> (toS <$> iProfile)
+  (,) "Content-Profile" <$> (toUtf8 <$> iProfile)
 splitKeyValue :: ByteString -> (ByteString, ByteString)
 splitKeyValue kv =
-  (k, BS8.tail v)
+  (k, BS.tail v)
  where
-    (k, v) = BS8.break (== '=') kv
+    (k, v) = BS.break (== '=') kv
@@ -10,6 +10,7 @@ module PostgREST.AppState
  , getPgVersion
  , getPool
  , getTime
  , getRetryNextIn
  , init
  , initWithPool
  , logWithZTime
@@ -18,12 +19,13 @@ module PostgREST.AppState
  , putIsWorkerOn
  , putJsonDbS
  , putPgVersion
  , putRetryNextIn
  , releasePool
  , signalListener
  , waitListener
  ) where
-import qualified Hasql.Pool as P
+import qualified Hasql.Pool as SQL
 import Control.AutoUpdate (defaultUpdateSettings, mkAutoUpdate,
                           updateAction)
@@ -37,12 +39,11 @@ import PostgREST.Config           (AppConfig (..))
 import PostgREST.Config.PgVersion (PgVersion (..), minimumPgVersion)
 import PostgREST.DbStructure      (DbStructure)
-import Protolude      hiding (toS)
+import Protolude
 import Protolude.Conv (toS)
 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)
@@ -60,6 +61,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,7 +70,7 @@ 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
@@ -79,16 +82,17 @@ initWithPool newPool conf =
    <*> mkAutoUpdate defaultUpdateSettings { updateAction = getCurrentTime }
    <*> mkAutoUpdate defaultUpdateSettings { updateAction = getZonedTime }
    <*> myThreadId
    <*> newIORef 0
-initPool :: AppConfig -> IO P.Pool
+initPool :: AppConfig -> IO SQL.Pool
 initPool AppConfig{..} =
-  P.acquire (configDbPoolSize, configDbPoolTimeout, toS configDbUri)
+  SQL.acquire (configDbPoolSize, configDbPoolTimeout, toUtf8 configDbUri)
-getPool :: AppState -> P.Pool
+getPool :: AppState -> SQL.Pool
 getPool = statePool
 releasePool :: AppState -> IO ()
-releasePool AppState{..} = P.release statePool >> throwTo stateMainThreadId UserInterrupt
+releasePool AppState{..} = SQL.release statePool >> throwTo stateMainThreadId UserInterrupt
 getPgVersion :: AppState -> IO PgVersion
 getPgVersion = readIORef . statePgVersion
@@ -115,6 +119,12 @@ getIsWorkerOn = readIORef . stateIsWorkerOn
 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
@@ -8,12 +8,12 @@ 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.Pool                 as SQL
-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)
@@ -54,19 +54,19 @@ dumpSchema :: AppState -> IO LBS.ByteString
 dumpSchema appState = do
  AppConfig{..} <- AppState.getConfig appState
  result <-
-    let transaction = if configDbPreparedStatements then HT.transaction else HT.unpreparedTransaction in
+    let transaction = if configDbPreparedStatements then SQL.transaction else SQL.unpreparedTransaction in
-    P.use (AppState.getPool appState) $
+    SQL.use (AppState.getPool appState) $
-      transaction HT.ReadCommitted HT.Read $
+      transaction SQL.ReadCommitted SQL.Read $
        queryDbStructure
          (toList configDbSchemas)
          configDbExtraSearchPath
          configDbPreparedStatements
-  P.release $ AppState.getPool appState
+  SQL.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
@@ -91,7 +91,7 @@ readCLIShowHelp hasEnvironment =
    progDesc =
      O.progDesc $
        "PostgREST "
-        <> Conv.toS prettyVersion
+        <> BS.unpack prettyVersion
        <> " / create a REST API to an existing Postgres database"
    footer =
@@ -166,6 +166,10 @@ exampleConfigFile =
      |## Enable in-database configuration
      |db-config = true
      |
      |## 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
      |
      |## how to terminate database transactions
      |## possible values are:
      |## commit (default)
@@ -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 Data.Text.Encoding     as T
 import qualified GHC.Show (show)
 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,13 +52,13 @@ 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 Protolude      hiding (Proxy, toList, toS)
+import Protolude hiding (Proxy, toList)
 import Protolude.Conv (toS)
 data AppConfig = AppConfig
@@ -79,16 +78,17 @@ 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
  , configOpenApiServerProxyUri :: Maybe Text
-  , configRawMediaTypes         :: [B.ByteString]
+  , configRawMediaTypes         :: [BS.ByteString]
  , configServerHost            :: Text
  , configServerPort            :: Int
  , configServerUnixSocket      :: Maybe FilePath
@@ -97,19 +97,21 @@ data AppConfig = AppConfig
 data LogLevel = LogCrit | LogError | LogWarn | LogInfo
-instance Show LogLevel where
+dumpLogLevel :: LogLevel -> Text
-  show LogCrit  = "crit"
+dumpLogLevel = \case
-  show LogError = "error"
+  LogCrit  -> "crit"
-  show LogWarn  = "warn"
+  LogError -> "error"
-  show LogInfo  = "info"
+  LogWarn  -> "warn"
  LogInfo  -> "info"
 data OpenAPIMode = OAFollowPriv | OAIgnorePriv | OADisabled
  deriving Eq
-instance Show OpenAPIMode where
+dumpOpenApiMode :: OpenAPIMode -> Text
-  show OAFollowPriv = "follow-privileges"
+dumpOpenApiMode = \case
-  show OAIgnorePriv = "ignore-privileges"
+  OAFollowPriv -> "follow-privileges"
-  show OADisabled   = "disabled"
+  OAIgnorePriv -> "ignore-privileges"
  OADisabled   -> "disabled"
 -- | Dump the config
 toText :: AppConfig -> Text
@@ -125,21 +127,22 @@ toText conf =
      ,("db-max-rows",                   maybe "\"\"" show . configDbMaxRows)
      ,("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)
+      ,("db-use-legacy-gucs",            T.toLower . show . configDbUseLegacyGucs)
-      ,("jwt-role-claim-key",        q . T.intercalate mempty . fmap show . configJwtRoleClaimKey)
+      ,("jwt-aud",                       T.decodeUtf8 . LBS.toStrict . JSON.encode . maybe "" toJSON . configJwtAudience)
-      ,("jwt-secret",                q . toS . showJwtSecret)
+      ,("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)
+      ,("log-level",                 q . dumpLogLevel . configLogLevel)
-      ,("openapi-mode",              q . show . configOpenApiMode)
+      ,("openapi-mode",              q . dumpOpenApiMode . configOpenApiMode)
      ,("openapi-server-proxy-uri",  q . fromMaybe mempty . configOpenApiServerProxyUri)
-      ,("raw-media-types",           q . toS . B.intercalate "," . configRawMediaTypes)
+      ,("raw-media-types",           q . T.decodeUtf8 . BS.intercalate "," . configRawMediaTypes)
      ,("server-host",               q . configServerHost)
      ,("server-port",                   show . configServerPort)
      ,("server-unix-socket",        q . maybe mempty T.pack . configServerUnixSocket)
@@ -159,7 +162,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
@@ -222,6 +225,7 @@ parser optPath env dbSettings =
    <*> parseTxEnd "db-tx-end" snd
    <*> parseTxEnd "db-tx-end" fst
    <*> reqString "db-uri"
    <*> (fromMaybe True <$> optBool "db-use-legacy-gucs")
    <*> pure optPath
    <*> pure Nothing
    <*> parseJwtAudience "jwt-aud"
@@ -365,17 +369,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 +424,8 @@ parseSecret bytes =
  fromMaybe (maybe secret (\jwk' -> JWT.JWKSet [jwk']) maybeJWK)
    maybeJWKSet
  where
-    maybeJWKSet = JSON.decode (toS bytes) :: Maybe JWKSet
+    maybeJWKSet = JSON.decodeStrict bytes :: Maybe JWKSet
-    maybeJWK = JSON.decode (toS bytes) :: Maybe JWK
+    maybeJWK = JSON.decodeStrict bytes :: Maybe JWK
    secret = JWT.JWKSet [JWT.fromKeyMaterial keyMaterial]
    keyMaterial = JWT.OctKeyMaterial . JWT.OctKeyParameters $ JOSE.Base64Octets bytes
@@ -1,7 +1,8 @@
 {-# LANGUAGE QuasiQuotes #-}
 module PostgREST.Config.Database
-  ( queryDbSettings
+  ( pgVersionStatement
  , queryDbSettings
  , queryPgVersion
  ) where
@@ -9,46 +10,56 @@ 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.Pool                 as SQL
-import qualified Hasql.Session              as H
+import           Hasql.Session              (Session, statement)
-import qualified Hasql.Statement            as H
+import qualified Hasql.Statement            as SQL
-import qualified Hasql.Transaction          as HT
+import qualified Hasql.Transaction          as SQL
-import qualified Hasql.Transaction.Sessions as HT
+import qualified Hasql.Transaction.Sessions as SQL
 import Text.InterpolatedString.Perl6 (q)
 import Protolude
-queryPgVersion :: H.Session PgVersion
+queryPgVersion :: Session PgVersion
-queryPgVersion = H.statement mempty $ H.Statement sql HE.noParams versionRow False
+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 :: SQL.Pool -> Bool -> IO (Either SQL.UsageError [(Text, Text)])
 queryDbSettings pool prepared =
-  let transaction = if prepared then HT.transaction else HT.unpreparedTransaction in
+  let transaction = if prepared then SQL.transaction else SQL.unpreparedTransaction in
-  P.use pool . transaction HT.ReadCommitted HT.Read $
+  SQL.use pool . transaction SQL.ReadCommitted SQL.Read $
-    HT.statement mempty dbSettingsStatement
+    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 :: SQL.Statement () [(Text, Text)]
-dbSettingsStatement = H.Statement sql HE.noParams decodeSettings False
+dbSettingsStatement = SQL.Statement sql HE.noParams decodeSettings False
  where
    sql = [q|
-      with
+      WITH
-      role_setting as (
+      role_setting (database, setting) AS (
-        select setdatabase, unnest(setconfig) as setting from pg_catalog.pg_db_role_setting
+        SELECT setdatabase,
-        where setrole = current_user::regrole::oid
+               unnest(setconfig)
-          and setdatabase in (0, (select oid from pg_catalog.pg_database where datname = current_catalog))
+          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 (
+      kv_settings (database, k, v) AS (
-        select setdatabase, split_part(setting, '=', 1) as k, split_part(setting, '=', 2) as value from role_setting
+        SELECT database,
-        where setting like 'pgrst.%'
+               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
+      SELECT DISTINCT ON (key)
-      from kv_settings
+             replace(k, 'pgrst.', '') AS key,
-      order by key, setdatabase desc;
+             v AS value
        FROM kv_settings
       ORDER BY key, database DESC;
    |]
    decodeSettings = HD.rowList $ (,) <$> column HD.text <*> column HD.text
@@ -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
 import Protolude      hiding (toS)
 import Protolude.Conv (toS)
 -- | full jspath, e.g. .property[0].attr.detail
@@ -30,10 +22,10 @@ data JSPathExp
  = JSPKey Text
  | JSPIdx Int
-instance Show JSPathExp where
+dumpJSPath :: JSPathExp -> Text
-  -- TODO: this needs to be quoted properly for special chars
+-- TODO: this needs to be quoted properly for special chars
-  show (JSPKey k) = "." <> show k
+dumpJSPath (JSPKey k) = "." <> show k
-  show (JSPIdx i) = "[" <> show i <> "]"
+dumpJSPath (JSPIdx i) = "[" <> show i <> "]"
 -- Used for the config value "role-claim-key"
 pRoleClaimKey :: Text -> Either Text JSPath
@@ -3,7 +3,6 @@
 module PostgREST.Config.PgVersion
  ( PgVersion(..)
  , minimumPgVersion
  , pgVersion95
  , pgVersion96
  , pgVersion100
  , pgVersion109
@@ -12,6 +11,7 @@ module PostgREST.Config.PgVersion
  , pgVersion114
  , pgVersion121
  , pgVersion130
  , pgVersion140
  ) where
 import qualified Data.Aeson as JSON
@@ -30,10 +30,7 @@ instance Ord PgVersion where
 -- | Tells the minimum PostgreSQL version required by this version of PostgREST
 minimumPgVersion :: PgVersion
-minimumPgVersion = pgVersion95
+minimumPgVersion = pgVersion96
 pgVersion95 :: PgVersion
 pgVersion95 = PgVersion 90500 "9.5"
 pgVersion96 :: PgVersion
 pgVersion96 = PgVersion 90600 "9.6"
@@ -58,3 +55,6 @@ pgVersion121 = PgVersion 120001 "12.1"
 pgVersion130 :: PgVersion
 pgVersion130 = PgVersion 130000 "13.0"
 pgVersion140 :: PgVersion
 pgVersion140 = PgVersion 140000 "14.0"
@@ -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,
+import Protolude hiding (Proxy)
                       toLower, toS, (&))
 import Protolude.Conv (toS)
 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
+  | T.toLower (T.pack s) == "https:" = True
-  | toLower (pack s) == "http:" = True
+  | T.toLower (T.pack s) == "http:" = True
  | otherwise = False
 isQueryValid :: URI -> Bool
@@ -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   -> []
@@ -33,18 +33,22 @@ import qualified Data.HashMap.Strict as M
 import qualified Data.List           as L
 import qualified Hasql.Decoders      as HD
 import qualified Hasql.Encoders      as HE
-import qualified Hasql.Statement     as H
+import qualified Hasql.Statement     as SQL
-import qualified Hasql.Transaction   as HT
+import qualified Hasql.Transaction   as SQL
 import Contravariant.Extras          (contrazip2)
 import Data.Set                      as S (fromList)
 import Data.Text                     (split)
 import Text.InterpolatedString.Perl6 (q)
 import PostgREST.Config.Database          (pgVersionStatement)
 import PostgREST.Config.PgVersion         (PgVersion, pgVersion100,
                                           pgVersion110)
 import PostgREST.DbStructure.Identifiers  (QualifiedIdentifier (..),
                                           Schema, TableName)
-import PostgREST.DbStructure.Proc         (PgArg (..), PgType (..),
+import PostgREST.DbStructure.Proc         (PgType (..),
                                           ProcDescription (..),
                                           ProcParam (..),
                                           ProcVolatility (..),
                                           ProcsMap, RetType (..))
 import PostgREST.DbStructure.Relationship (Cardinality (..),
@@ -53,8 +57,7 @@ import PostgREST.DbStructure.Relationship (Cardinality (..),
                                           Relationship (..))
 import PostgREST.DbStructure.Table        (Column (..), Table (..))
-import Protolude        hiding (toS)
+import Protolude
 import Protolude.Conv   (toS)
 import Protolude.Unsafe (unsafeHead)
@@ -82,15 +85,16 @@ type ViewColumn = Column
 -- | A SQL query that can be executed independently
 type SqlQuery = ByteString
-queryDbStructure :: [Schema] -> [Schema] -> Bool -> HT.Transaction DbStructure
+queryDbStructure :: [Schema] -> [Schema] -> Bool -> SQL.Transaction DbStructure
 queryDbStructure schemas extraSearchPath prepared = do
-  HT.sql "set local schema ''" -- This voids the search path. The following queries need this for getting the fully qualified name(schema.name) of every db object
+  SQL.sql "set local schema ''" -- This voids the search path. The following queries need this for getting the fully qualified name(schema.name) of every db object
-  tabs    <- HT.statement mempty $ allTables prepared
+  pgVer   <- SQL.statement mempty pgVersionStatement
-  cols    <- HT.statement schemas $ allColumns tabs prepared
+  tabs    <- SQL.statement mempty $ allTables pgVer prepared
-  srcCols <- HT.statement (schemas, extraSearchPath) $ pfkSourceColumns cols prepared
+  cols    <- SQL.statement schemas $ allColumns tabs prepared
-  m2oRels <- HT.statement mempty $ allM2ORels tabs cols prepared
+  srcCols <- SQL.statement (schemas, extraSearchPath) $ pfkSourceColumns cols prepared
-  keys    <- HT.statement mempty $ allPrimaryKeys tabs prepared
+  m2oRels <- SQL.statement mempty $ allM2ORels tabs cols prepared
-  procs   <- HT.statement schemas $ allProcs prepared
+  keys    <- SQL.statement mempty $ allPrimaryKeys tabs prepared
  procs   <- SQL.statement schemas $ allProcs pgVer prepared
  let rels = addO2MRels . addM2MRels $ addViewM2ORels srcCols m2oRels
      keys' = addViewPrimaryKeys srcCols keys
@@ -192,7 +196,7 @@ decodeProcs =
              <*> column HD.text
              <*> nullableColumn HD.text
              <*> compositeArrayColumn
-                  (PgArg
+                  (ProcParam
                  <$> compositeField HD.text
                  <*> compositeField HD.text
                  <*> compositeField HD.bool
@@ -223,18 +227,18 @@ decodeProcs =
                      | v == 's' = Stable
                      | otherwise = Volatile -- only 'v' can happen here
-allProcs :: Bool -> H.Statement [Schema] ProcsMap
+allProcs :: PgVersion -> Bool -> SQL.Statement [Schema] ProcsMap
-allProcs = H.Statement (toS sql) (arrayParam HE.text) decodeProcs
+allProcs pgVer = SQL.Statement sql (arrayParam HE.text) decodeProcs
  where
-    sql = procsSqlQuery <> " WHERE pn.nspname = ANY($1)"
+    sql = procsSqlQuery pgVer <> " AND pn.nspname = ANY($1)"
-accessibleProcs :: Bool -> H.Statement Schema ProcsMap
+accessibleProcs :: PgVersion -> Bool -> SQL.Statement Schema ProcsMap
-accessibleProcs = H.Statement (toS sql) (param HE.text) decodeProcs
+accessibleProcs pgVer = SQL.Statement sql (param HE.text) decodeProcs
  where
-    sql = procsSqlQuery <> " WHERE pn.nspname = $1 AND has_function_privilege(p.oid, 'execute')"
+    sql = procsSqlQuery pgVer <> " AND pn.nspname = $1 AND has_function_privilege(p.oid, 'execute')"
-procsSqlQuery :: SqlQuery
+procsSqlQuery :: PgVersion -> SqlQuery
-procsSqlQuery = [q|
+procsSqlQuery pgVer = [q|
 -- Recursively get the base types of domains
  WITH
  base_types AS (
@@ -283,10 +287,8 @@ procsSqlQuery = [q|
    COALESCE(comp.relname, t.typname) AS name,
    p.proretset AS rettype_is_setof,
    (t.typtype = 'c'
-     -- Only pg pseudo type that is a row type is 'record'
+     -- if any TABLE, INOUT or OUT arguments present, treat as composite
-     or t.typtype = 'p' and t.typname = 'record'
+     or COALESCE(proargmodes::text[] && '{t,b,o}', false)
     -- if any INOUT or OUT arguments present, treat as composite
     or COALESCE(proargmodes::text[] && '{b,o}', false)
    ) AS rettype_is_composite,
    p.provolatile,
    p.provariadic > 0 as hasvariadic
@@ -298,11 +300,12 @@ procsSqlQuery = [q|
  JOIN pg_namespace tn ON tn.oid = t.typnamespace
  LEFT JOIN pg_class comp ON comp.oid = t.typrelid
  LEFT JOIN pg_catalog.pg_description as d ON d.objoid = p.oid
-|]
+  WHERE t.oid <> 'pg_catalog.trigger'::regtype
 |] <> (if pgVer >= pgVersion110 then "AND prokind = 'f'" else "AND NOT (proisagg OR proiswindow)")
-schemaDescription :: Bool -> H.Statement Schema (Maybe Text)
+schemaDescription :: Bool -> SQL.Statement Schema (Maybe Text)
 schemaDescription =
-    H.Statement sql (param HE.text) (join <$> HD.rowMaybe (nullableColumn HD.text))
+    SQL.Statement sql (param HE.text) (join <$> HD.rowMaybe (nullableColumn HD.text))
  where
    sql = [q|
      select
@@ -313,9 +316,9 @@ schemaDescription =
      where
        n.nspname = $1 |]
-accessibleTables :: Bool -> H.Statement Schema [Table]
+accessibleTables :: PgVersion -> Bool -> SQL.Statement Schema [Table]
-accessibleTables =
+accessibleTables pgVer =
-  H.Statement sql (param HE.text) decodeTables
+  SQL.Statement sql (param HE.text) decodeTables
 where
  sql = [q|
    select
@@ -323,38 +326,27 @@ accessibleTables =
      relname as table_name,
      d.description as table_description,
      (
-        c.relkind IN ('r', 'v','f')
+        c.relkind IN ('r','p')
-        AND (pg_relation_is_updatable(c.oid::regclass, FALSE) & 8) = 8
+        OR (
-        OR EXISTS (
+          c.relkind IN ('v','f')
-          SELECT 1
+          -- CMD_INSERT - see allTables query below for explanation
-          FROM pg_trigger
+          AND (pg_relation_is_updatable(c.oid::regclass, TRUE) & 8) = 8
          WHERE
            pg_trigger.tgrelid = c.oid
            AND (pg_trigger.tgtype::integer & 69) = 69
        )
      ) AS insertable,
      (
-        c.relkind IN ('r', 'v','f')
+        c.relkind IN ('r','p')
-        AND (pg_relation_is_updatable(c.oid::regclass, FALSE) & 4) = 4
+        OR (
-        -- CMD_UPDATE
+          c.relkind IN ('v','f')
-        OR EXISTS (
+          -- CMD_UPDATE
-          SELECT 1
+          AND (pg_relation_is_updatable(c.oid::regclass, TRUE) & 4) = 4
          FROM pg_trigger
          WHERE
            pg_trigger.tgrelid = c.oid
            and (pg_trigger.tgtype::integer & 81) = 81
        )
      ) as updatable,
      (
-        c.relkind IN ('r', 'v','f')
+        c.relkind IN ('r','p')
-        AND (pg_relation_is_updatable(c.oid::regclass, FALSE) & 16) = 16
+        OR (
-        -- CMD_DELETE
+          c.relkind IN ('v','f')
-        OR EXISTS (
+          -- CMD_DELETE
-          SELECT 1
+          AND (pg_relation_is_updatable(c.oid::regclass, TRUE) & 16) = 16
          FROM pg_trigger
          WHERE
            pg_trigger.tgrelid = c.oid
            and (pg_trigger.tgtype::integer & 73) = 73
        )
      ) as deletable
    from
@@ -362,8 +354,9 @@ accessibleTables =
      join pg_namespace n on n.oid = c.relnamespace
      left join pg_catalog.pg_description as d on d.objoid = c.oid and d.objsubid = 0
    where
-      c.relkind in ('v', 'r', 'm', 'f')
+      c.relkind in ('v','r','m','f','p')
-      and n.nspname = $1
+      and n.nspname = $1 |]
      <> relIsNotPartition pgVer <> [q|
      and (
        pg_has_role(c.relowner, 'USAGE')
        or has_table_privilege(c.oid, 'SELECT, INSERT, UPDATE, DELETE, TRUNCATE, REFERENCES, TRIGGER')
@@ -458,9 +451,9 @@ addViewPrimaryKeys srcCols = concatMap (\pk ->
                filter (\(col, _) -> colTable col == pkTable pk && colName col == pkName pk) srcCols in
  pk : viewPks)
-allTables :: Bool -> H.Statement () [Table]
+allTables :: PgVersion -> Bool -> SQL.Statement () [Table]
-allTables =
+allTables pgVer =
-  H.Statement sql HE.noParams decodeTables
+  SQL.Statement sql HE.noParams decodeTables
 where
  sql = [q|
    SELECT
@@ -468,67 +461,45 @@ allTables =
      c.relname AS table_name,
      d.description AS table_description,
      (
-        c.relkind = 'r'
+        c.relkind IN ('r','p')
        OR (
          c.relkind in ('v','f')
          AND (pg_relation_is_updatable(c.oid::regclass, FALSE) & 8) = 8
          -- The function `pg_relation_is_updateable` returns a bitmask where 8
          -- corresponds to `1 << CMD_INSERT` in the PostgreSQL source code, i.e.
          -- it's possible to insert into the relation.
-          OR EXISTS (
+          AND (pg_relation_is_updatable(c.oid::regclass, TRUE) & 8) = 8
            SELECT 1
            FROM pg_trigger
            WHERE
              pg_trigger.tgrelid = c.oid
            AND (pg_trigger.tgtype::integer & 69) = 69
            -- The trigger type `tgtype` is a bitmask where 69 corresponds to
            -- TRIGGER_TYPE_ROW + TRIGGER_TYPE_INSTEAD + TRIGGER_TYPE_INSERT
            -- in the PostgreSQL source code.
          )
        )
      ) AS insertable,
      (
-        c.relkind = 'r'
+        c.relkind IN ('r','p')
        OR (
          c.relkind in ('v','f')
          AND (pg_relation_is_updatable(c.oid::regclass, FALSE) & 4) = 4
          -- CMD_UPDATE
-          OR EXISTS (
+          AND (pg_relation_is_updatable(c.oid::regclass, TRUE) & 4) = 4
            SELECT 1
            FROM pg_trigger
            WHERE
              pg_trigger.tgrelid = c.oid
              and (pg_trigger.tgtype::integer & 81) = 81
              -- TRIGGER_TYPE_ROW + TRIGGER_TYPE_INSTEAD + TRIGGER_TYPE_UPDATE
          )
        )
      ) AS updatable,
      (
-        c.relkind = 'r'
+        c.relkind IN ('r','p')
        OR (
          c.relkind in ('v','f')
          AND (pg_relation_is_updatable(c.oid::regclass, FALSE) & 16) = 16
          -- CMD_DELETE
-          OR EXISTS (
+          AND (pg_relation_is_updatable(c.oid::regclass, TRUE) & 16) = 16
            SELECT 1
            FROM pg_trigger
            WHERE
              pg_trigger.tgrelid = c.oid
              and (pg_trigger.tgtype::integer & 73) = 73
              -- TRIGGER_TYPE_ROW + TRIGGER_TYPE_INSTEAD + TRIGGER_TYPE_DELETE
          )
        )
      ) AS deletable
    FROM pg_class c
    JOIN pg_namespace n ON n.oid = c.relnamespace
    LEFT JOIN pg_catalog.pg_description as d on d.objoid = c.oid and d.objsubid = 0
-    WHERE c.relkind IN ('v','r','m','f')
+    WHERE c.relkind IN ('v','r','m','f','p')
-      AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+      AND n.nspname NOT IN ('pg_catalog', 'information_schema') |]
      <> relIsNotPartition pgVer <> [q|
    ORDER BY table_schema, table_name |]
-allColumns :: [Table] -> Bool -> H.Statement [Schema] [Column]
+relIsNotPartition :: PgVersion -> SqlQuery
 relIsNotPartition pgVer = if pgVer >= pgVersion100 then " AND not c.relispartition " else mempty
 allColumns :: [Table] -> Bool -> SQL.Statement [Schema] [Column]
 allColumns tabs =
- H.Statement sql (arrayParam HE.text) (decodeColumns tabs)
+ SQL.Statement sql (arrayParam HE.text) (decodeColumns tabs)
 where
  sql = [q|
    SELECT DISTINCT
@@ -559,7 +530,7 @@ allColumns tabs =
               pg_catalog.pg_namespace n
             WHERE
               r.contype IN ('f', 'p', 'u')
-               AND c.relkind IN ('r', 'v', 'f', 'm')
+               AND c.relkind IN ('r', 'v', 'f', 'm', 'p')
               AND r.conrelid = c.oid
               AND c.relnamespace = n.oid
               AND n.nspname <> ANY (ARRAY['pg_catalog', 'information_schema'] || $1)
@@ -617,7 +588,7 @@ allColumns tabs =
                NOT pg_is_other_temp_schema(nc.oid)
                AND a.attnum > 0
                AND NOT a.attisdropped
-                AND c.relkind in ('r', 'v', 'f', 'm')
+                AND c.relkind in ('r', 'v', 'f', 'm', 'p')
                -- Filter only columns that are FK/PK or in the api schema:
                AND (nc.nspname = ANY ($1) OR kc.r_oid IS NOT NULL)
        )
@@ -659,9 +630,9 @@ columnFromRow tabs (s, t, n, desc, nul, typ, l, d, e) = buildColumn <$> table
    parseEnum :: Maybe Text -> [Text]
    parseEnum = maybe [] (split (==','))
-allM2ORels :: [Table] -> [Column] -> Bool -> H.Statement () [Relationship]
+allM2ORels :: [Table] -> [Column] -> Bool -> SQL.Statement () [Relationship]
 allM2ORels tabs cols =
-  H.Statement sql HE.noParams (decodeRels tabs cols)
+  SQL.Statement sql HE.noParams (decodeRels tabs cols)
 where
  sql = [q|
    SELECT ns1.nspname AS table_schema,
@@ -697,9 +668,9 @@ relFromRow allTabs allCols (rs, rt, cn, rcs, frs, frt, frcs) =
    cols  = mapM (findCol rs rt) rcs
    colsF = mapM (findCol frs frt) frcs
-allPrimaryKeys :: [Table] -> Bool -> H.Statement () [PrimaryKey]
+allPrimaryKeys :: [Table] -> Bool -> SQL.Statement () [PrimaryKey]
 allPrimaryKeys tabs =
-  H.Statement sql HE.noParams (decodePks tabs)
+  SQL.Statement sql HE.noParams (decodePks tabs)
 where
  sql = [q|
    -- CTE to replace information_schema.table_constraints to remove owner limit
@@ -716,7 +687,7 @@ allPrimaryKeys tabs =
            nc.oid = c.connamespace
            AND nr.oid = r.relnamespace
            AND c.conrelid = r.oid
-            AND r.relkind = 'r'
+            AND r.relkind IN ('r', 'p')
            AND NOT pg_is_other_temp_schema(nr.oid)
            AND c.contype = 'p'
    ),
@@ -753,7 +724,7 @@ allPrimaryKeys tabs =
                AND r.oid = c.conrelid
                AND nc.oid = c.connamespace
                AND c.contype in ('p', 'u', 'f')
-                AND r.relkind = 'r'
+                AND r.relkind IN ('r', 'p')
                AND NOT pg_is_other_temp_schema(nr.oid)
            ) ss
        WHERE
@@ -778,9 +749,9 @@ pkFromRow tabs (s, t, n) = PrimaryKey <$> table <*> pure n
  where table = find (\tbl -> tableSchema tbl == s && tableName tbl == t) tabs
 -- returns all the primary and foreign key columns which are referenced in views
-pfkSourceColumns :: [Column] -> Bool -> H.Statement ([Schema], [Schema]) [SourceColumn]
+pfkSourceColumns :: [Column] -> Bool -> SQL.Statement ([Schema], [Schema]) [SourceColumn]
 pfkSourceColumns cols =
-  H.Statement sql (contrazip2 (arrayParam HE.text) (arrayParam HE.text)) (decodeSourceColumns cols)
+  SQL.Statement sql (contrazip2 (arrayParam HE.text) (arrayParam HE.text)) (decodeSourceColumns cols)
  -- query explanation at:
  --  * rationale: https://gist.github.com/wolfgangwalther/5425d64e7b0d20aad71f6f68474d9f19
  --  * json transformation: https://gist.github.com/wolfgangwalther/3a8939da680c24ad767e93ad2c183089
@@ -825,7 +796,6 @@ pfkSourceColumns cols =
            replace(
            replace(
            replace(
            replace(
            regexp_replace(
            replace(
            replace(
@@ -836,6 +806,7 @@ pfkSourceColumns cols =
            replace(
            replace(
            replace(
            replace(
            replace(
              view_definition::text,
            -- This conversion to json is heavily optimized for performance.
@@ -847,13 +818,19 @@ pfkSourceColumns cols =
            -- -----------------------------------------------
            -- pattern           | replacement         | flags
            -- -----------------------------------------------
            -- `<>` in pg_node_tree is the same as `null` in JSON, but due to very poor performance of json_typeof
            -- we need to make this an empty array here to prevent json_array_elements from throwing an error
            -- when the targetList is null.
            -- We'll need to put it first, to make the node protection below work for node lists that start with
            -- null: `(<> ...`, too. This is the case for coldefexprs, when the first column does not have a default value.
               '<>'              , '()'
            -- `,` is not part of the pg_node_tree format, but used in the regex.
            -- This removes all `,` that might be part of column names.
-               ','               , ''
+            ), ','               , ''
            -- The same applies for `{` and `}`, although those are used a lot in pg_node_tree.
            -- We remove the escaped ones, which might be part of column names again.
-            ), '\{'              , ''
+            ), E'\\{'            , ''
-            ), '\}'              , ''
+            ), E'\\}'            , ''
            -- The fields we need are formatted as json manually to protect them from the regex.
            ), ' :targetList '   , ',"targetList":'
            ), ' :resno '        , ',"resno":'
@@ -884,10 +861,6 @@ pfkSourceColumns cols =
            ), ')'               , ']'
            -- pg_node_tree has ` ` between list items, but JSON uses `,`
            ), ' '             , ','
            -- `<>` in pg_node_tree is the same as `null` in JSON, but due to very poor performance of json_typeof
            -- we need to make this an empty array here to prevent json_array_elements from throwing an error
            -- when the targetList is null.
            ), '<>'              , '[]'
          )::json as view_definition
        from views
      ),
@@ -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
+dumpQi :: QualifiedIdentifier -> Text
-  show (QualifiedIdentifier s i) =
+dumpQi (QualifiedIdentifier s i) =
-    (if T.null s then mempty else toS s <> ".") <> toS 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
@@ -2,37 +2,25 @@
 {-# LANGUAGE DeriveGeneric  #-}
 module PostgREST.DbStructure.Proc
-  ( PgArg(..)
+  ( PgType(..)
  , PgType(..)
  , ProcDescription(..)
  , ProcParam(..)
  , ProcVolatility(..)
  , ProcsMap
  , RetType(..)
  , procReturnsScalar
  , procReturnsSingle
  , procTableName
  , specifiedProcArgs
  ) where
 import qualified Data.Aeson          as JSON
 import qualified Data.HashMap.Strict as M
 import qualified Data.Set            as S
-import PostgREST.DbStructure.Identifiers (FieldName,
+import PostgREST.DbStructure.Identifiers (QualifiedIdentifier (..),
                                          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,32 +41,32 @@ data ProcDescription = ProcDescription
  { pdSchema      :: Schema
  , pdName        :: Text
  , pdDescription :: Maybe Text
-  , pdArgs        :: [PgArg]
+  , pdParams      :: [ProcParam]
  , pdReturnType  :: 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
+  ProcDescription schema1 name1 des1 prms1 rt1 vol1 hasVar1 `compare` ProcDescription schema2 name2 des2 prms2 rt2 vol2 hasVar2
-    | schema1 == schema2 && name1 == name2 && length args1 < length args2  = LT
+    | schema1 == schema2 && name1 == name2 && length prms1 < length prms2  = LT
-    | schema2 == schema2 && name1 == name2 && length args1 > length args2  = GT
+    | schema2 == schema2 && name1 == name2 && length prms1 > length prms2  = GT
-    | otherwise = (schema1, name1, des1, args1, rt1, vol1, hasVar1) `compare` (schema2, name2, des2, args2, rt2, vol2, hasVar2)
+    | 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
 procReturnsScalar :: ProcDescription -> Bool
 procReturnsScalar proc = case proc of
  ProcDescription{pdReturnType = (Single Scalar)} -> True
@@ -16,10 +16,13 @@ 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 Data.Text.Encoding        as T
-import qualified Hasql.Session             as H
+import qualified Data.Text.Encoding.Error  as T
-import qualified Network.HTTP.Types.Status as HT
+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)
@@ -29,19 +32,18 @@ import Network.HTTP.Types.Header (Header)
 import           PostgREST.ContentType (ContentType (..))
 import qualified PostgREST.ContentType as ContentType
-import PostgREST.DbStructure.Proc         (PgArg (..),
+import PostgREST.DbStructure.Proc         (ProcDescription (..),
-                                           ProcDescription (..))
+                                           ProcParam (..))
 import PostgREST.DbStructure.Relationship (Cardinality (..),
                                           Junction (..),
                                           Relationship (..))
 import PostgREST.DbStructure.Table        (Column (..), Table (..))
-import Protolude      hiding (toS)
+import Protolude
 import Protolude.Conv (toS, toSL)
 class (JSON.ToJSON a) => PgrstError a where
-  status   :: a -> HT.Status
+  status   :: a -> HTTP.Status
  headers  :: a -> [Header]
  errorPayload :: a -> LByteString
@@ -60,25 +62,25 @@ data ApiRequestError
  | NoRelBetween Text Text
  | AmbiguousRelBetween Text Text [Relationship]
  | AmbiguousRpc [ProcDescription]
-  | NoRpc Text Text [Text] Bool
+  | NoRpc Text Text [Text] Bool ContentType Bool
  | InvalidFilters
  | UnacceptableSchema [Text]
  | ContentTypeError [ByteString]
  | UnsupportedVerb                -- Unreachable?
 instance PgrstError ApiRequestError where
-  status InvalidRange            = HT.status416
+  status InvalidRange            = HTTP.status416
-  status InvalidFilters          = HT.status405
+  status InvalidFilters          = HTTP.status405
-  status (InvalidBody _)         = HT.status400
+  status (InvalidBody _)         = HTTP.status400
-  status UnsupportedVerb         = HT.status405
+  status UnsupportedVerb         = HTTP.status405
-  status ActionInappropriate     = HT.status405
+  status ActionInappropriate     = HTTP.status405
-  status (ParseRequestError _ _) = HT.status400
+  status (ParseRequestError _ _) = HTTP.status400
-  status (NoRelBetween _ _)      = HT.status400
+  status (NoRelBetween _ _)      = HTTP.status400
-  status AmbiguousRelBetween{}   = HT.status300
+  status AmbiguousRelBetween{}   = HTTP.status300
-  status (AmbiguousRpc _)        = HT.status300
+  status (AmbiguousRpc _)        = HTTP.status300
-  status NoRpc{}                 = HT.status404
+  status NoRpc{}                 = HTTP.status404
-  status (UnacceptableSchema _)  = HT.status406
+  status (UnacceptableSchema _)  = HTTP.status406
-  status (ContentTypeError _)    = HT.status415
+  status (ContentTypeError _)    = HTTP.status415
  headers _ = [ContentType.toHeader CTApplicationJSON]
@@ -88,22 +90,30 @@ instance JSON.ToJSON ApiRequestError where
  toJSON ActionInappropriate = JSON.object [
    "message" .= ("Bad Request" :: Text)]
  toJSON (InvalidBody errorMessage) = JSON.object [
-    "message" .= (toS errorMessage :: Text)]
+    "message" .= T.decodeUtf8 errorMessage]
  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),
+    "hint"    .= ("Try changing '" <> child <> "' to one of the following: " <> relHint rels <> ". Find the desired relationship in the 'details' key." :: Text),
-    "message" .= ("More than one relationship was found for " <> parent <> " and " <> child :: Text),
+    "message" .= ("Could not embed because 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),
+    "hint"    .= ("Try renaming the parameters or the function itself in the database so function overloading can be resolved" :: 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])]
+    "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])]
-  toJSON (NoRpc schema procName payloadKeys hasPreferSingleObject)  = JSON.object [
+  toJSON (NoRpc schema procName argumentKeys hasPreferSingleObject contentType isInvPost)  =
-    "hint"    .= ("If a new function was created in the database with this name and arguments, try reloading the schema cache." :: Text),
+    let prms = "(" <> T.intercalate ", " argumentKeys <> ")" in JSON.object [
-    "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")]
+    "hint"    .= ("If a new function was created in the database with this name and parameters, try reloading the schema cache." :: Text),
    "message" .= ("Could not find the " <> schema <> "." <> procName <>
      (case (hasPreferSingleObject, isInvPost, contentType) of
        (True, _, _)                 -> " function with a single json or jsonb parameter"
        (_, True, CTTextPlain)       -> " function with a single unnamed text parameter"
        (_, True, CTOctetStream)     -> " function with a single unnamed bytea parameter"
        (_, True, CTApplicationJSON) -> prms <> " function or the " <> schema <> "." <> procName <>" function with a single unnamed json or jsonb parameter"
        _                            -> prms <> " function") <>
      " in the schema cache")]
  toJSON UnsupportedVerb = JSON.object [
    "message" .= ("Unsupported HTTP verb" :: Text)]
  toJSON InvalidFilters = JSON.object [
@@ -111,148 +121,155 @@ instance JSON.ToJSON ApiRequestError where
  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)]
+    "message" .= ("None of these Content-Types are available: " <> T.intercalate ", " (map T.decodeUtf8 cts))]
 compressedRel :: Relationship -> JSON.Value
 compressedRel Relationship{..} =
  let
-    fmtTbl Table{..} = tableSchema <> "." <> tableName
+    fmtEls els = "(" <> T.intercalate ", " els <> ")"
    fmtEls els = "[" <> T.intercalate ", " els <> "]"
  in
-  JSON.object $ [
+  JSON.object $
-    "origin"      .= fmtTbl relTable
+    ("embedding" .= (tableName relTable <> " with " <> tableName relForeignTable :: Text))
-  , "target"      .= fmtTbl relForeignTable
+    : case relCardinality of
-  ] ++
+        M2M Junction{..} -> [
-  case relCardinality of
+            "cardinality" .= ("many-to-many" :: Text)
-    M2M Junction{..} -> [
+          , "relationship" .= (tableName junTable <> " using " <> junConstraint1 <> fmtEls (colName <$> junColumns1) <> " and " <> junConstraint2 <> fmtEls (colName <$> junColumns2))
-        "cardinality" .= ("m2m" :: Text)
+          ]
-      , "relationship" .= (fmtTbl junTable <> fmtEls [junConstraint1] <> fmtEls [junConstraint2])
+        M2O cons -> [
-      ]
+            "cardinality" .= ("many-to-one" :: Text)
-    M2O cons -> [
+          , "relationship" .= (cons <> " using " <> tableName relTable <> fmtEls (colName <$> relColumns) <> " and " <> tableName relForeignTable <> fmtEls (colName <$> relForeignColumns))
-        "cardinality" .= ("m2o" :: Text)
+          ]
-      , "relationship" .= (cons <> fmtEls (colName <$> relColumns) <> fmtEls (colName <$> relForeignColumns))
+        O2M cons -> [
-      ]
+            "cardinality" .= ("one-to-many" :: Text)
-    O2M cons -> [
+          , "relationship" .= (cons <> " using " <> tableName relTable <> fmtEls (colName <$> relColumns) <> " and " <> tableName relForeignTable <> fmtEls (colName <$> relForeignColumns))
-        "cardinality" .= ("o2m" :: Text)
+          ]
      , "relationship" .= (cons <> fmtEls (colName <$> relColumns) <> fmtEls (colName <$> relForeignColumns))
      ]
-data PgError = PgError Authenticated P.UsageError
+relHint :: [Relationship] -> Text
 relHint rels = T.intercalate ", " (hintList <$> rels)
  where
    hintList Relationship{..} =
      let buildHint rel = "'" <> tableName relForeignTable <> "!" <> rel <> "'" in
      case relCardinality of
        M2M Junction{..} -> buildHint (tableName junTable)
        M2O cons         -> buildHint cons
        O2M cons         -> buildHint cons
 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
+    if status err == HTTP.status401
       then [ContentType.toHeader CTApplicationJSON, ("WWW-Authenticate", "Bearer") :: Header]
       else [ContentType.toHeader CTApplicationJSON]
 instance JSON.ToJSON PgError where
  toJSON (PgError _ usageError) = JSON.toJSON usageError
-instance JSON.ToJSON P.UsageError where
+instance JSON.ToJSON SQL.UsageError where
-  toJSON (P.ConnectionError e) = JSON.object [
+  toJSON (SQL.ConnectionError e) = JSON.object [
    "code"    .= ("" :: Text),
    "message" .= ("Database connection error. Retrying the connection." :: Text),
-    "details" .= (toSL $ fromMaybe "" e :: Text)]
+    "details" .= (T.decodeUtf8With T.lenientDecode $ fromMaybe "" e :: Text)]
-  toJSON (P.SessionError e) = JSON.toJSON e -- H.Error
+  toJSON (SQL.SessionError e) = JSON.toJSON e -- SQL.Error
-instance JSON.ToJSON H.QueryError where
+instance JSON.ToJSON SQL.QueryError where
-  toJSON (H.QueryError _ _ e) = JSON.toJSON e
+  toJSON (SQL.QueryError _ _ e) = JSON.toJSON e
-instance JSON.ToJSON H.CommandError where
+instance JSON.ToJSON SQL.CommandError where
-  toJSON (H.ResultError (H.ServerError c m d h)) = case toS c of
+  toJSON (SQL.ResultError (SQL.ServerError c m d h)) = case BS.unpack c of
    'P':'T':_ -> JSON.object [
-        "details" .= (fmap toS d :: Maybe Text),
+        "details" .= fmap T.decodeUtf8 d,
-        "hint"    .= (fmap toS h :: Maybe Text)]
+        "hint"    .= fmap T.decodeUtf8 h]
    _         -> JSON.object [
-        "code"    .= (toS c      :: Text),
+        "code"    .= (T.decodeUtf8 c      :: Text),
-        "message" .= (toS m      :: Text),
+        "message" .= (T.decodeUtf8 m      :: Text),
-        "details" .= (fmap toS d :: Maybe Text),
+        "details" .= (fmap T.decodeUtf8 d :: Maybe Text),
-        "hint"    .= (fmap toS h :: Maybe Text)]
+        "hint"    .= (fmap T.decodeUtf8 h :: Maybe Text)]
-  toJSON (H.ResultError (H.UnexpectedResult m)) = JSON.object [
+  toJSON (SQL.ResultError (SQL.UnexpectedResult m)) = JSON.object [
    "message" .= (m :: Text)]
-  toJSON (H.ResultError (H.RowError i H.EndOfInput)) = JSON.object [
+  toJSON (SQL.ResultError (SQL.RowError i SQL.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 [
+  toJSON (SQL.ResultError (SQL.RowError i SQL.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 [
+  toJSON (SQL.ResultError (SQL.RowError i (SQL.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 [
+  toJSON (SQL.ResultError (SQL.UnexpectedAmountOfRows i)) = JSON.object [
    "message" .= ("Unexpected amount of rows" :: Text),
    "details" .= i]
-  toJSON (H.ClientError d) = JSON.object [
+  toJSON (SQL.ClientError d) = JSON.object [
    "message" .= ("Database client error. Retrying the connection." :: Text),
-    "details" .= (fmap toS d :: Maybe Text)]
+    "details" .= (fmap T.decodeUtf8 d :: Maybe Text)]
-pgErrorStatus :: Bool -> P.UsageError -> HT.Status
+pgErrorStatus :: Bool -> SQL.UsageError -> HTTP.Status
-pgErrorStatus _      (P.ConnectionError _)                                      = HT.status503
+pgErrorStatus _      (SQL.ConnectionError _)                                      = HTTP.status503
-pgErrorStatus _      (P.SessionError (H.QueryError _ _ (H.ClientError _)))      = HT.status503
+pgErrorStatus _      (SQL.SessionError (SQL.QueryError _ _ (SQL.ClientError _)))      = HTTP.status503
-pgErrorStatus authed (P.SessionError (H.QueryError _ _ (H.ResultError rError))) =
+pgErrorStatus authed (SQL.SessionError (SQL.QueryError _ _ (SQL.ResultError rError))) =
  case rError of
-    (H.ServerError c m _ _) ->
+    (SQL.ServerError c m _ _) ->
-      case toS c of
+      case BS.unpack c of
-        '0':'8':_ -> HT.status503 -- pg connection err
+        '0':'8':_ -> HTTP.status503 -- pg connection err
-        '0':'9':_ -> HT.status500 -- triggered action exception
+        '0':'9':_ -> HTTP.status500 -- triggered action exception
-        '0':'L':_ -> HT.status403 -- invalid grantor
+        '0':'L':_ -> HTTP.status403 -- invalid grantor
-        '0':'P':_ -> HT.status403 -- invalid role specification
+        '0':'P':_ -> HTTP.status403 -- invalid role specification
-        "23503"   -> HT.status409 -- foreign_key_violation
+        "23503"   -> HTTP.status409 -- foreign_key_violation
-        "23505"   -> HT.status409 -- unique_violation
+        "23505"   -> HTTP.status409 -- unique_violation
-        "25006"   -> HT.status405 -- read_only_sql_transaction
+        "25006"   -> HTTP.status405 -- read_only_sql_transaction
-        '2':'5':_ -> HT.status500 -- invalid tx state
+        '2':'5':_ -> HTTP.status500 -- invalid tx state
-        '2':'8':_ -> HT.status403 -- invalid auth specification
+        '2':'8':_ -> HTTP.status403 -- invalid auth specification
-        '2':'D':_ -> HT.status500 -- invalid tx termination
+        '2':'D':_ -> HTTP.status500 -- invalid tx termination
-        '3':'8':_ -> HT.status500 -- external routine exception
+        '3':'8':_ -> HTTP.status500 -- external routine exception
-        '3':'9':_ -> HT.status500 -- external routine invocation
+        '3':'9':_ -> HTTP.status500 -- external routine invocation
-        '3':'B':_ -> HT.status500 -- savepoint exception
+        '3':'B':_ -> HTTP.status500 -- savepoint exception
-        '4':'0':_ -> HT.status500 -- tx rollback
+        '4':'0':_ -> HTTP.status500 -- tx rollback
-        '5':'3':_ -> HT.status503 -- insufficient resources
+        '5':'3':_ -> HTTP.status503 -- insufficient resources
-        '5':'4':_ -> HT.status413 -- too complex
+        '5':'4':_ -> HTTP.status413 -- too complex
-        '5':'5':_ -> HT.status500 -- obj not on prereq state
+        '5':'5':_ -> HTTP.status500 -- obj not on prereq state
-        '5':'7':_ -> HT.status500 -- operator intervention
+        '5':'7':_ -> HTTP.status500 -- operator intervention
-        '5':'8':_ -> HT.status500 -- system error
+        '5':'8':_ -> HTTP.status500 -- system error
-        'F':'0':_ -> HT.status500 -- conf file error
+        'F':'0':_ -> HTTP.status500 -- conf file error
-        'H':'V':_ -> HT.status500 -- foreign data wrapper error
+        'H':'V':_ -> HTTP.status500 -- foreign data wrapper error
-        "P0001"   -> HT.status400 -- default code for "raise"
+        "P0001"   -> HTTP.status400 -- default code for "raise"
-        'P':'0':_ -> HT.status500 -- PL/pgSQL Error
+        'P':'0':_ -> HTTP.status500 -- PL/pgSQL Error
-        'X':'X':_ -> HT.status500 -- internal Error
+        'X':'X':_ -> HTTP.status500 -- internal Error
-        "42883"   -> HT.status404 -- undefined function
+        "42883"   -> HTTP.status404 -- undefined function
-        "42P01"   -> HT.status404 -- undefined table
+        "42P01"   -> HTTP.status404 -- undefined table
-        "42501"   -> if authed then HT.status403 else HT.status401 -- insufficient privilege
+        "42501"   -> if authed then HTTP.status403 else HTTP.status401 -- insufficient privilege
-        'P':'T':n -> fromMaybe HT.status500 (HT.mkStatus <$> readMaybe n <*> pure m)
+        'P':'T':n -> fromMaybe HTTP.status500 (HTTP.mkStatus <$> readMaybe n <*> pure m)
-        _         -> HT.status400
+        _         -> 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
+  where isAuthFailureMessage = "FATAL:  password authentication failed" `isPrefixOf` failureMessage
-        failureMessage = fromMaybe mempty e
+        failureMessage = BS.unpack $ fromMaybe mempty e
-checkIsFatal (PgError _ (P.SessionError (H.QueryError _ _ (H.ResultError serverError))))
+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
@@ -273,16 +290,16 @@ data Error
  | PgErr PgError
 instance PgrstError Error where
-  status GucHeadersError         = HT.status500
+  status GucHeadersError         = HTTP.status500
-  status GucStatusError          = HT.status500
+  status GucStatusError          = HTTP.status500
-  status (BinaryFieldError _)    = HT.status406
+  status (BinaryFieldError _)    = HTTP.status406
-  status ConnectionLostError     = HT.status503
+  status ConnectionLostError     = HTTP.status503
-  status PutMatchingPkError      = HT.status400
+  status PutMatchingPkError      = HTTP.status400
-  status PutRangeNotAllowedError = HT.status400
+  status PutRangeNotAllowedError = HTTP.status400
-  status JwtTokenMissing         = HT.status500
+  status JwtTokenMissing         = HTTP.status500
-  status (JwtTokenInvalid _)     = HT.unauthorized401
+  status (JwtTokenInvalid _)     = HTTP.unauthorized401
-  status (SingularityError _)    = HT.status406
+  status (SingularityError _)    = HTTP.status406
-  status NotFound                = HT.status404
+  status NotFound                = HTTP.status404
  status (PgErr err)             = status err
  status (ApiRequestError err)   = status err
@@ -298,7 +315,7 @@ instance JSON.ToJSON Error where
  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)]
+    "message" .= ((T.decodeUtf8 (ContentType.toMime ct) <> " requested but more than one column was selected") :: Text)]
  toJSON ConnectionLostError       = JSON.object [
    "message" .= ("Database connection lost. Retrying the connection." :: Text)]
@@ -309,7 +326,7 @@ instance JSON.ToJSON Error where
  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"]]
+    "details" .= T.unwords ["Results contain", show n, "rows,", T.decodeUtf8 (ContentType.toMime CTSingularJSON), "requires 1 row"]]
  toJSON JwtTokenMissing           = JSON.object [
    "message" .= ("Server lacks JWT secret" :: Text)]
@@ -10,8 +10,7 @@ import qualified Data.HashMap.Strict  as M
 import Network.HTTP.Types.Header (Header)
-import Protolude      hiding (toS)
+import Protolude
 import Protolude.Conv (toS)
 {-|
@@ -21,11 +20,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
+  parseJSON (JSON.Object o) =
-    Just (k, JSON.String s) | M.size o == 1 -> pure $ GucHeader (CI.mk $ toS k, toS s)
+    case M.toList o of
-                            | otherwise     -> mzero
+      [(k, JSON.String s)] -> pure $ GucHeader (CI.mk $ toUtf8 k, toUtf8 s)
-    _ -> mzero
+      _ -> mzero
-  parseJSON _          = mzero
+  parseJSON _ = mzero
 unwrapGucHeader :: GucHeader -> Header
 unwrapGucHeader (GucHeader (k, v)) = (k, v)
@@ -0,0 +1,28 @@
 {-|
 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 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)
      }
@@ -2,44 +2,30 @@
 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.Aeson                        as JSON
-import qualified Data.ByteString.Char8                as BS
+import qualified Data.ByteString.Lazy.Char8        as LBS
-import qualified Data.CaseInsensitive                 as CI
+import qualified Data.HashMap.Strict               as M
-import qualified Data.HashMap.Strict                  as M
+import qualified Data.Text                         as T
-import qualified Data.Text                            as T
+import qualified Data.Text.Encoding                as T
-import qualified Hasql.Decoders                       as HD
+import qualified Hasql.Decoders                    as HD
-import qualified Hasql.DynamicStatements.Snippet      as H hiding
+import qualified Hasql.DynamicStatements.Snippet   as SQL hiding (sql)
-                                                           (sql)
+import qualified Hasql.DynamicStatements.Statement as SQL
-import qualified Hasql.DynamicStatements.Statement    as H
+import qualified Hasql.Transaction                 as SQL
-import qualified Hasql.Transaction                    as H
+import qualified Network.Wai                       as Wai
 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 Data.Function             (id)
+import Control.Arrow ((***))
 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 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,
@@ -48,124 +34,63 @@ import PostgREST.Request.ApiRequest (ApiRequest (..), Target (..))
 import PostgREST.Request.Preferences
-import Protolude      hiding (head, toS)
+import Protolude
 import Protolude.Conv (toS)
 -- | 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 -> ExceptT Error SQL.Transaction Wai.Response) ->
-               ApiRequest  -> ByteString -> ExceptT Error H.Transaction Wai.Response
+               ApiRequest  -> ByteString -> PgVersion -> ExceptT Error SQL.Transaction Wai.Response
-runPgLocals conf claims app req jsonDbS = do
+runPgLocals conf claims app req jsonDbS actualPgVersion = do
-  lift $ H.statement mempty $ H.dynamicallyParameterized
+  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
+    headersSql = if usesLegacyGucs
-    cookiesSql = setConfigLocal "request.cookie." <$> iCookies req
+                   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)
    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]
+    claimsSql = if usesLegacyGucs
-    roleSql = maybeToList $ (\x -> setConfigLocal mempty ("role", toS $ unquoted x)) <$> M.lookup "role" claimsWithRole
+                  then setConfigLocal "request.jwt.claim." <$> [(toUtf8 c, toUtf8 $ unquoted v) | (c,v) <- M.toList claimsWithRole]
-    appSettingsSql = setConfigLocal mempty <$> (join bimap toS <$> configAppSettings conf)
+                  else [setConfigLocal mempty ("request.jwt.claims", LBS.toStrict $ JSON.encode claimsWithRole)]
    roleSql = maybeToList $ (\x -> setConfigLocal mempty ("role", toUtf8 $ unquoted x)) <$> M.lookup "role" claimsWithRole
    appSettingsSql = setConfigLocal mempty <$> (join bimap toUtf8 <$> configAppSettings conf)
    searchPathSql =
      let schemas = T.intercalate ", " (iSchema req : configDbExtraSearchPath conf) in
-      setConfigLocal mempty ("search_path", toS schemas)
+      setConfigLocal mempty ("search_path", toUtf8 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.
+    usesLegacyGucs = configDbUseLegacyGucs conf && actualPgVersion < pgVersion140
    setConfigLocal :: ByteString -> (ByteString, ByteString) -> H.Snippet
    setConfigLocal prefix (k, v) =
      "set_config(" <> unknownEncoder (prefix <> k) <> ", " <> unknownEncoder v <> ", true)"
-- | Log in apache format. Only requests that have a status greater than minStatus are logged.
+    unquoted :: JSON.Value -> Text
-- | 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.
+    unquoted (JSON.String t) = t
-- | So here we copy wai-logger apacheLogStr function: https://github.com/kazu-yamamoto/logger/blob/a4f51b909a099c51af7a3f75cf16e19a06f9e257/wai-logger/Network/Wai/Logger/Apache.hs#L45
+    unquoted (JSON.Number n) =
-- | TODO: Add the ability to filter apache logs on wai-extra and remove this function.
+      toS $ formatScientific Fixed (if isInteger n then Just 0 else Nothing) n
-pgrstFormat :: Status -> Wai.OutputFormatter
+    unquoted (JSON.Bool b) = show b
-pgrstFormat minStatus date req status responseSize =
+    unquoted v = T.decodeUtf8 . LBS.toStrict $ JSON.encode v
  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
 -- | 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 SQL.Transaction Wai.Response
-  -> ExceptT Error H.Transaction Wai.Response
+  -> ExceptT Error SQL.Transaction Wai.Response
 optionalRollback AppConfig{..} ApiRequest{..} transaction = do
  resp <- catchError transaction $ return . errorResponseFor
-  when (shouldRollback || (configDbTxRollbackAll && not shouldCommit))
+  when (shouldRollback || (configDbTxRollbackAll && not shouldCommit)) $ lift do
-    (lift H.condemn)
+    SQL.sql "SET CONSTRAINTS ALL IMMEDIATE"
    SQL.condemn
  return $ Wai.mapResponseHeaders preferenceApplied resp
  where
    shouldCommit =
@@ -175,9 +100,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 . M.fromList . arrayByteStringToText
    arrayByteStringToText :: [(ByteString, ByteString)] -> [(Text,Text)]
    arrayByteStringToText keyVal = (T.decodeUtf8 *** T.decodeUtf8) <$> keyVal
@@ -7,11 +7,13 @@ Description : Generates the OpenAPI output
 {-# LANGUAGE RecordWildCards #-}
 module PostgREST.OpenAPI (encode) where
-import qualified Data.Aeson           as JSON
+import qualified Data.Aeson            as JSON
-import qualified Data.ByteString.Lazy as LBS
+import qualified Data.ByteString.Char8 as BS
-import qualified Data.HashMap.Strict  as HashMap
+import qualified Data.ByteString.Lazy  as LBS
-import qualified Data.HashSet.InsOrd  as Set
+import qualified Data.HashMap.Strict   as M
-import qualified Data.Text            as T
+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)
@@ -27,8 +29,8 @@ import PostgREST.Config                   (AppConfig (..), Proxy (..),
                                           isMalformedProxyUri, toURI)
 import PostgREST.DbStructure              (DbStructure (..),
                                           tableCols, tablePKCols)
-import PostgREST.DbStructure.Proc         (PgArg (..),
+import PostgREST.DbStructure.Proc         (ProcDescription (..),
-                                           ProcDescription (..))
+                                           ProcParam (..))
 import PostgREST.DbStructure.Relationship (Cardinality (..),
                                           PrimaryKey (..),
                                           Relationship (..))
@@ -37,35 +39,47 @@ import PostgREST.Version                  (docsVersion, prettyVersion)
 import PostgREST.ContentType
-import Protolude      hiding (Proxy, get, toS)
+import Protolude hiding (Proxy, get)
 import Protolude.Conv (toS)
-encode :: AppConfig -> DbStructure -> [Table] -> HashMap.HashMap k [ProcDescription] -> Maybe Text -> LBS.ByteString
+encode :: AppConfig -> DbStructure -> [Table] -> M.HashMap k [ProcDescription] -> Maybe Text -> LBS.ByteString
 encode conf dbStructure tables procs schemaDescription =
  JSON.encode $
    postgrestSpec
      (dbRelationships dbStructure)
-      (concat $ HashMap.elems procs)
+      (concat $ M.elems procs)
      (openApiTableInfo dbStructure <$> tables)
      (proxyUri conf)
      schemaDescription
      (dbPrimaryKeys dbStructure)
 makeMimeList :: [ContentType] -> MimeList
-makeMimeList cs = MimeList $ fmap (fromString . toS . toMime) cs
+makeMimeList cs = MimeList $ fmap (fromString . BS.unpack . toMime) cs
-toSwaggerType :: Text -> SwaggerType t
+toSwaggerType :: Text -> Maybe (SwaggerType t)
-toSwaggerType "character varying" = SwaggerString
+toSwaggerType "character varying" = Just SwaggerString
-toSwaggerType "character"         = SwaggerString
+toSwaggerType "character"         = Just SwaggerString
-toSwaggerType "text"              = SwaggerString
+toSwaggerType "text"              = Just SwaggerString
-toSwaggerType "boolean"           = SwaggerBoolean
+toSwaggerType "boolean"           = Just SwaggerBoolean
-toSwaggerType "smallint"          = SwaggerInteger
+toSwaggerType "smallint"          = Just SwaggerInteger
-toSwaggerType "integer"           = SwaggerInteger
+toSwaggerType "integer"           = Just SwaggerInteger
-toSwaggerType "bigint"            = SwaggerInteger
+toSwaggerType "bigint"            = Just SwaggerInteger
-toSwaggerType "numeric"           = SwaggerNumber
+toSwaggerType "numeric"           = Just SwaggerNumber
-toSwaggerType "real"              = SwaggerNumber
+toSwaggerType "real"              = Just SwaggerNumber
-toSwaggerType "double precision"  = SwaggerNumber
+toSwaggerType "double precision"  = Just SwaggerNumber
-toSwaggerType _                   = SwaggerString
+toSwaggerType "ARRAY"             = Just SwaggerArray
 toSwaggerType "json"              = Nothing
 toSwaggerType "jsonb"             = Nothing
 toSwaggerType _                   = Just SwaggerString
 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 :: [Relationship] -> [PrimaryKey] -> (Table, [Column], [Text]) -> (Text, Schema)
 makeTableDef rels pks (t, cs, _) =
@@ -107,26 +121,26 @@ makeProperty rels pks c = (colName c, Inline s)
        colDescription c
    s =
      (mempty :: Schema)
-        & default_ .~ (JSON.decode . toS =<< colDefault c)
+        & default_ .~ (JSON.decode . toUtf8Lazy . parseDefault (colType c) =<< colDefault c)
        & description .~ d
        & enum_ .~ e
        & format ?~ colType c
        & maxLength .~ (fromIntegral <$> colMaxLen c)
-        & type_ ?~ toSwaggerType (colType c)
+        & type_ .~ toSwaggerType (colType c)
 makeProcSchema :: ProcDescription -> Schema
 makeProcSchema pd =
  (mempty :: Schema)
  & description .~ pdDescription pd
  & type_ ?~ SwaggerObject
-  & properties .~ fromList (fmap makeProcProperty (pdArgs pd))
+  & properties .~ fromList (fmap makeProcProperty (pdParams pd))
-  & required .~ fmap pgaName (filter pgaReq (pdArgs pd))
+  & required .~ fmap ppName (filter ppReq (pdParams pd))
-makeProcProperty :: PgArg -> (Text, Referenced Schema)
+makeProcProperty :: ProcParam -> (Text, Referenced Schema)
-makeProcProperty (PgArg n t _ _) = (n, Inline s)
+makeProcProperty (ProcParam n t _ _) = (n, Inline s)
  where
    s = (mempty :: Schema)
-          & type_ ?~ toSwaggerType t
+          & type_ .~ toSwaggerType t
          & format ?~ t
 makePreferParam :: [Text] -> Param
@@ -313,7 +327,7 @@ postgrestSpec rels pds ti (s, h, p, b) sd pks = (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)
@@ -17,30 +17,27 @@ 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,
+import PostgREST.DbStructure.Identifiers  (QualifiedIdentifier (..))
-                                           QualifiedIdentifier (..))
+import PostgREST.DbStructure.Proc         (ProcParam (..))
 import PostgREST.DbStructure.Proc         (PgArg (..))
 import PostgREST.DbStructure.Relationship (Cardinality (..),
                                           Relationship (..))
 import PostgREST.DbStructure.Table        (Table (..))
-import PostgREST.Request.ApiRequest       (PayloadJSON (..))
+import PostgREST.Request.Preferences      (PreferResolution (..))
 import PostgREST.Request.Preferences      (PreferParameters (..),
                                           PreferResolution (..))
 import PostgREST.Query.SqlFragment
 import PostgREST.Request.Types
 import Protolude
-readRequestToQuery :: ReadRequest -> H.Snippet
+readRequestToQuery :: ReadRequest -> SQL.Snippet
 readRequestToQuery (Node (Select colSelects mainQi tblAlias implJoins logicForest joinConditions_ ordts range, _) forest) =
  "SELECT " <>
  intercalateSnippet ", " ((pgFmtSelectItem qi <$> colSelects) ++ selects) <>
-  "FROM " <> H.sql (BS.intercalate ", " (tabl : implJs)) <> " " <>
+  "FROM " <> SQL.sql (BS.intercalate ", " (tabl : implJs)) <> " " <>
  intercalateSnippet " " joins <> " " <>
  (if null logicForest && null joinConditions_ then mempty else "WHERE " <> intercalateSnippet " AND " (map (pgFmtLogicTree qi) logicForest ++ map pgFmtJoinCondition joinConditions_))
  <> " " <>
@@ -52,33 +49,46 @@ readRequestToQuery (Node (Select colSelects mainQi tblAlias implJoins logicFores
    qi = maybe mainQi (QualifiedIdentifier mempty) tblAlias
    (joins, selects) = foldr getJoinsSelects ([],[]) forest
-getJoinsSelects :: ReadRequest -> ([H.Snippet], [H.Snippet]) -> ([H.Snippet], [H.Snippet])
+getJoinsSelects :: ReadRequest -> ([SQL.Snippet], [SQL.Snippet]) -> ([SQL.Snippet], [SQL.Snippet])
-getJoinsSelects rr@(Node (_, (name, Just Relationship{relCardinality=card,relTable=Table{tableName=table}}, alias, _, _)) _) (j,s) =
+getJoinsSelects rr@(Node (_, (name, Just Relationship{relCardinality=card,relTable=Table{tableName=table}}, alias, _, joinType, _)) _) (joins,selects) =
  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)
+          sel = SQL.sql ("row_to_json(" <> localTableName <> ".*) AS " <> pgFmtIdent aliasOrName)
-          joi = " LEFT JOIN LATERAL( " <> subquery <> " ) AS " <> H.sql localTableName <> " ON TRUE " in
+          joi = (if joinType == Just JTInner then " INNER" else " LEFT")
-      (joi:j,sel:s)
+            <> " JOIN LATERAL( " <> subquery <> " ) AS " <> SQL.sql localTableName <> " ON TRUE " in
-    _ ->
+      (joi:joins,sel:selects)
-      let sel = "COALESCE (("
+    _ -> case joinType of
-             <> "SELECT json_agg(" <> H.sql (pgFmtIdent table) <> ".*) "
+      Just JTInner ->
-             <> "FROM (" <> subquery <> ") " <> H.sql (pgFmtIdent table) <> " "
+        let aliasOrName = fromMaybe name alias
-             <> "), '[]') AS " <> H.sql (pgFmtIdent (fromMaybe name alias)) in
+            locTblName = table <> "_" <> aliasOrName
-      (j,sel:s)
+            localTableName = pgFmtIdent locTblName
-getJoinsSelects (Node (_, (_, Nothing, _, _, _)) _) _ = ([], [])
+            internalTableName = pgFmtIdent $ "_" <> locTblName
            sel = SQL.sql $ localTableName <> "." <> internalTableName <> " AS " <> pgFmtIdent aliasOrName
            joi = "INNER JOIN LATERAL(" <>
                    "SELECT json_agg(" <> SQL.sql internalTableName <> ") AS " <> SQL.sql internalTableName <>
                    "FROM (" <> subquery <> " ) AS " <> SQL.sql internalTableName <>
                  ") AS " <> SQL.sql localTableName <> " ON " <> SQL.sql localTableName <> "IS NOT NULL" in
        (joi:joins,sel:selects)
      _ ->
        let sel = "COALESCE (("
               <> "SELECT json_agg(" <> SQL.sql (pgFmtIdent table) <> ".*) "
               <> "FROM (" <> subquery <> ") " <> SQL.sql (pgFmtIdent table) <> " "
               <> "), '[]') AS " <> SQL.sql (pgFmtIdent (fromMaybe name alias)) in
        (joins,sel:selects)
 getJoinsSelects (Node (_, (_, Nothing, _, _, _, _)) _) _ = ([], [])
-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 <> ") ") <>
+  "INSERT INTO " <> SQL.sql (fromQi mainQi) <> SQL.sql (if S.null iCols then " " else "(" <> cols <> ") ") <>
-  "SELECT " <> H.sql cols <> " " <>
+  "SELECT " <> SQL.sql cols <> " " <>
-  H.sql ("FROM json_populate_recordset (null::" <> fromQi mainQi <> ", " <> selectBody <> ") _ ") <>
+  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
@@ -100,13 +110,13 @@ mutateRequestToQuery (Update mainQi uCols body logicForest returnings) =
    -- 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")
+    then SQL.sql ("SELECT " <> emptyBodyReturnedColumns <> " FROM " <> fromQi mainQi <> " WHERE false")
    else
      "WITH " <> normalizedBody body <> " " <>
-      "UPDATE " <> H.sql (fromQi mainQi) <> " SET " <> H.sql cols <> " " <>
+      "UPDATE " <> SQL.sql (fromQi mainQi) <> " SET " <> SQL.sql cols <> " " <>
-      "FROM (SELECT * FROM json_populate_recordset (null::" <> H.sql (fromQi mainQi) <> " , " <> H.sql selectBody <> " )) _ " <>
+      "FROM (SELECT * FROM json_populate_recordset (null::" <> SQL.sql (fromQi mainQi) <> " , " <> SQL.sql selectBody <> " )) _ " <>
      (if null logicForest then mempty else "WHERE " <> intercalateSnippet " AND " (pgFmtLogicTree mainQi <$> logicForest)) <> " " <>
-      H.sql (returningF mainQi returnings)
+      SQL.sql (returningF mainQi returnings)
  where
    cols = BS.intercalate ", " (pgFmtIdent <> const " = _." <> pgFmtIdent <$> S.toList uCols)
    emptyBodyReturnedColumns :: SqlFragment
@@ -114,42 +124,39 @@ mutateRequestToQuery (Update mainQi uCols body logicForest returnings) =
      | null returnings = "NULL"
      | otherwise       = BS.intercalate ", " (pgFmtColumn (QualifiedIdentifier mempty $ qiName mainQi) <$> returnings)
 mutateRequestToQuery (Delete mainQi logicForest returnings) =
-  "DELETE FROM " <> H.sql (fromQi mainQi) <> " " <>
+  "DELETE FROM " <> SQL.sql (fromQi mainQi) <> " " <>
  (if null logicForest then mempty else "WHERE " <> intercalateSnippet " AND " (map (pgFmtLogicTree mainQi) logicForest)) <> " " <>
-  H.sql (returningF mainQi returnings)
+  SQL.sql (returningF mainQi returnings)
-requestToCallProcQuery :: QualifiedIdentifier -> [PgArg] -> Maybe PayloadJSON -> Bool -> Maybe PreferParameters -> [FieldName] -> H.Snippet
+requestToCallProcQuery :: CallRequest -> SQL.Snippet
-requestToCallProcQuery qi pgArgs pj returnsScalar preferParams returnings =
+requestToCallProcQuery (FunctionCall qi params args returnsScalar multipleCall returnings) =
-  argsCTE <> sourceBody
+  prmsCTE <> argsBody
  where
-    body = pjRaw <$> pj
+    (prmsCTE, argFrag) = case params of
-    paramsAsSingleObject    = preferParams == Just SingleObject
+      OnePosParam prm -> ("WITH pgrst_args AS (SELECT NULL)", singleParameter args (encodeUtf8 $ ppType prm))
-    paramsAsMultipleObjects = preferParams == Just MultipleObjects
+      KeyParams []    -> (mempty, mempty)
-
+      KeyParams prms  -> (
-    (argsCTE, args)
+          "WITH " <> normalizedBody args <> ", " <>
-      | null pgArgs = (mempty, mempty)
+          SQL.sql (
      | paramsAsSingleObject = ("WITH pgrst_args AS (SELECT NULL)", jsonPlaceHolder body)
      | otherwise = (
          "WITH " <> normalizedBody body <> ", " <>
          H.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
+         , SQL.sql $ if multipleCall
-             then fmtArgs varadicPrefix (\a -> " := pgrst_args." <> pgFmtIdent (pgaName a))
+             then fmtParams prms varadicPrefix (\a -> " := pgrst_args." <> pgFmtIdent (ppName a))
-             else fmtArgs varadicPrefix (\a -> " := (SELECT " <> pgFmtIdent (pgaName a) <> " FROM pgrst_args LIMIT 1)")
+             else fmtParams prms varadicPrefix (\a -> " := (SELECT " <> pgFmtIdent (ppName a) <> " FROM pgrst_args LIMIT 1)")
        )
-    fmtArgs :: (PgArg -> SqlFragment) -> (PgArg -> SqlFragment) -> SqlFragment
+    fmtParams :: [ProcParam] -> (ProcParam -> SqlFragment) -> (ProcParam -> SqlFragment) -> SqlFragment
-    fmtArgs argFragPre argFragSuf = BS.intercalate ", " ((\a -> argFragPre a <> pgFmtIdent (pgaName a) <> argFragSuf a) <$> pgArgs)
+    fmtParams prms prmFragPre prmFragSuf = BS.intercalate ", "
      ((\a -> prmFragPre a <> pgFmtIdent (ppName a) <> prmFragSuf a) <$> prms)
-    varadicPrefix :: PgArg -> SqlFragment
+    varadicPrefix :: ProcParam -> SqlFragment
-    varadicPrefix a = if pgaVar a then "VARIADIC " else mempty
+    varadicPrefix a = if ppVar a then "VARIADIC " else mempty
-    sourceBody :: H.Snippet
+    argsBody :: SQL.Snippet
-    sourceBody
+    argsBody
-      | paramsAsMultipleObjects =
+      | multipleCall =
          if returnsScalar
            then "SELECT " <> callIt <> " AS pgrst_scalar FROM pgrst_args"
            else "SELECT pgrst_lat_args.* FROM pgrst_args, " <>
@@ -159,23 +166,41 @@ requestToCallProcQuery qi pgArgs pj returnsScalar preferParams returnings =
            then "SELECT " <> callIt <> " AS pgrst_scalar"
            else "SELECT " <> returnedColumns <> " FROM " <> callIt
-    callIt :: H.Snippet
+    callIt :: SQL.Snippet
-    callIt = H.sql (fromQi qi) <> "(" <> args <> ")"
+    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
+-- If the request contains INNER JOINs, then the COUNT of the root node will change.
-readRequestToCountQuery (Node (Select{from=qi, where_=logicForest}, _) _) =
+-- For this case, we use a WHERE EXISTS instead of an INNER JOIN on the count query.
- "SELECT 1 " <> "FROM " <> H.sql (fromQi qi) <> " " <>
+-- See https://github.com/PostgREST/postgrest/issues/2009#issuecomment-977473031
- if null logicForest then mempty else "WHERE " <> intercalateSnippet " AND " (map (pgFmtLogicTree qi) logicForest)
+-- Only for the nodes that have an INNER JOIN linked to the root level.
 readRequestToCountQuery :: ReadRequest -> SQL.Snippet
 readRequestToCountQuery (Node (Select{from=qi, implicitJoins=implJoins, where_=logicForest, joinConditions=joinConditions_}, _) forest) =
  "SELECT 1 FROM " <> SQL.sql (BS.intercalate ", " (fromQi qi:(fromQi <$> implJoins))) <>
  (if null logicForest && null joinConditions_ && null subQueries
    then mempty
    else " WHERE " ) <>
  intercalateSnippet " AND " (
    map (pgFmtLogicTree qi) logicForest ++
    map pgFmtJoinCondition joinConditions_ ++
    subQueries
  )
  where
    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 mempty
-limitedQuery :: H.Snippet -> Maybe Integer -> H.Snippet
+limitedQuery :: SQL.Snippet -> Maybe Integer -> SQL.Snippet
-limitedQuery query maxRows = query <> H.sql (maybe mempty (\x -> " LIMIT " <> BS.pack (show x)) maxRows)
+limitedQuery query maxRows = query <> SQL.sql (maybe mempty (\x -> " LIMIT " <> BS.pack (show x)) maxRows)
@@ -16,7 +16,6 @@ module PostgREST.Query.SqlFragment
  , countF
  , fromQi
  , ftsOperators
  , jsonPlaceHolder
  , limitOffsetF
  , locationF
  , normalizedBody
@@ -31,22 +30,22 @@ module PostgREST.Query.SqlFragment
  , responseStatusF
  , returningF
  , selectBody
  , singleParameter
  , sourceCTEName
  , unknownEncoder
  , intercalateSnippet
  ) where
 import qualified Data.ByteString.Char8           as BS
-import qualified Data.ByteString.Lazy            as BL
+import qualified Data.ByteString.Lazy            as LBS
-import qualified Data.HashMap.Strict             as HM
+import qualified Data.HashMap.Strict             as M
 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.RangeQuery              (NonnegRange, allRange,
@@ -55,12 +54,16 @@ import PostgREST.Request.Types           (Alias, Field, Filter (..),
                                          JoinCondition (..),
                                          JsonOperand (..),
                                          JsonOperation (..),
-                                          JsonPath, LogicTree (..),
+                                          JsonPath,
-                                          OpExpr (..), Operation (..),
+                                          LogicOperator (..),
-                                          OrderTerm (..), SelectItem)
+                                          LogicTree (..), OpExpr (..),
                                          Operation (..),
                                          OrderDirection (..),
                                          OrderNulls (..),
                                          OrderTerm (..), SelectItem,
                                          TrileanVal (..))
-import Protolude      hiding (cast, toS)
+import Protolude hiding (cast)
 import Protolude.Conv (toS)
 -- | A part of a SQL query that cannot be executed independently
@@ -72,8 +75,8 @@ noLocationF = "array[]::text[]"
 sourceCTEName :: SqlFragment
 sourceCTEName = "pgrst_source"
-operators :: HM.HashMap Text SqlFragment
+operators :: M.HashMap Text SqlFragment
-operators = HM.union (HM.fromList [
+operators = M.union (M.fromList [
  ("eq", "="),
  ("gte", ">="),
  ("gt", ">"),
@@ -93,8 +96,8 @@ operators = HM.union (HM.fromList [
  ("nxl", "&>"),
  ("adj", "-|-")]) ftsOperators
-ftsOperators :: HM.HashMap Text SqlFragment
+ftsOperators :: M.HashMap Text SqlFragment
-ftsOperators = HM.fromList [
+ftsOperators = M.fromList [
  ("fts", "@@ to_tsquery"),
  ("plfts", "@@ plainto_tsquery"),
  ("phfts", "@@ phraseto_tsquery"),
@@ -105,10 +108,11 @@ ftsOperators = HM.fromList [
 -- 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), " <>
+  "pgrst_payload AS (SELECT " <> jsonPlaceHolder <> " AS json_data), " <>
-  H.sql (BS.unwords [
+  SQL.sql (BS.unwords [
    "pgrst_body AS (",
      "SELECT",
        "CASE WHEN json_typeof(json_data) = 'array'",
@@ -116,24 +120,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"
+singleParameter :: Maybe LBS.ByteString -> ByteString -> SQL.Snippet
-- | TODO: At this stage there shouldn't be a Maybe since ApiRequest should ensure that an INSERT/UPDATE has a body
+singleParameter body typ =
-jsonPlaceHolder :: Maybe BL.ByteString -> H.Snippet
+  if typ == "bytea"
-jsonPlaceHolder body =
+    -- TODO: Hasql fails when using HE.unknown with bytea(pg tries to utf8 encode).
-  H.encoderAndParam (HE.nullable HE.unknown) (toS <$> body) <> "::json"
+    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
+-- Here we build the pg array literal, e.g '{"Hebdon, John","Other","Another"}', manually.
-pgFmtLit x =
+-- This is necessary to pass an "unknown" array and let pg infer the type.
- let trimmed = trimNullChars x
+-- There are backslashes here, but since this value is parametrized and is not a string constant
-     escaped = "'" <> T.replace "'" "''" trimmed <> "'"
+-- https://www.postgresql.org/docs/current/sql-syntax-lexical.html#SQL-SYNTAX-STRINGS
-     slashed = T.replace "\\" "\\\\" escaped in
+-- we don't need to use the E'string' form for C-style escapes
- encodeUtf8 $ if "\\" `T.isInfixOf` escaped
+-- https://www.postgresql.org/docs/current/sql-syntax-lexical.html#SQL-SYNTAX-STRINGS-ESCAPE
-   then "E" <> slashed
+pgBuildArrayLiteral :: [Text] -> Text
-   else slashed
+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
@@ -161,10 +172,10 @@ 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"
+  | returnsScalar = "coalesce((json_agg(_postgrest_t.pgrst_scalar)->0)::text, 'null')"
-  | otherwise     = "coalesce(string_agg(to_json(_postgrest_t)::text, ','), '')::character varying"
+  | otherwise     = "coalesce((json_agg(_postgrest_t)->0)::text, 'null')"
 asBinaryF :: FieldName -> SqlFragment
 asBinaryF fieldName = "coalesce(string_agg(_postgrest_t." <> pgFmtIdent fieldName <> ", ''), '')"
@@ -189,67 +200,77 @@ pgFmtColumn :: QualifiedIdentifier -> Text -> SqlFragment
 pgFmtColumn table "*" = fromQi table <> ".*"
 pgFmtColumn table c   = fromQi table <> "." <> pgFmtIdent c
-pgFmtField :: QualifiedIdentifier -> Field -> H.Snippet
+pgFmtField :: QualifiedIdentifier -> Field -> SQL.Snippet
-pgFmtField table (c, jp) = H.sql (pgFmtColumn table c) <> pgFmtJsonPath jp
+pgFmtField table (c, jp) = SQL.sql (pgFmtColumn table c) <> pgFmtJsonPath jp
-pgFmtSelectItem :: QualifiedIdentifier -> SelectItem -> H.Snippet
+pgFmtSelectItem :: QualifiedIdentifier -> SelectItem -> SQL.Snippet
-pgFmtSelectItem table (f@(fName, jp), Nothing, alias, _) = pgFmtField table f <> H.sql (pgFmtAs fName jp alias)
+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 [
+  SQL.sql (BS.unwords [
-    BS.pack $ maybe mempty show $ otDirection ot,
+    maybe mempty direction $ otDirection ot,
-    BS.pack $ maybe mempty show $ otNullOrder 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
     _       -> 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 <> " " <>
+   In vals -> pgFmtField table fld <> " " <> case vals of
    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.
+      _    -> "= ANY (" <> unknownLiteral (pgBuildArrayLiteral vals) <> ") "
      -- 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) <> "}") <> ")"
   Fts op lang val ->
     pgFmtFieldOp 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
+   sqlOperator o = SQL.sql $ M.lookupDefault "=" o operators
   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 :: QualifiedIdentifier -> LogicTree -> SQL.Snippet
-pgFmtLogicTree qi (Expr hasNot op forest) = H.sql notOp <> " (" <> intercalateSnippet (" " <> BS.pack (show op) <> " ") (pgFmtLogicTree qi <$> forest) <> ")"
+pgFmtLogicTree qi (Expr hasNot op forest) = SQL.sql notOp <> " (" <> intercalateSnippet (opSql op) (pgFmtLogicTree qi <$> forest) <> ")"
-  where notOp =  if hasNot then "NOT" else mempty
+  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 +291,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 +307,31 @@ 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 :: SqlFragment
-responseHeadersF pgVer =
+responseHeadersF = currentSettingF "response.headers"
  if pgVer >= pgVersion96
    then currentSettingF "response.headers"
    else "null"
-responseStatusF :: PgVersion -> SqlFragment
+responseStatusF :: SqlFragment
-responseStatusF pgVer =
+responseStatusF = currentSettingF "response.status"
  if pgVer >= pgVersion96
    then currentSettingF "response.status"
    else "null"
-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), '')"
 -- Hasql Snippet utilities
-unknownEncoder :: ByteString -> H.Snippet
+unknownEncoder :: ByteString -> SQL.Snippet
-unknownEncoder = H.encoderAndParam (HE.nonNullable HE.unknown)
+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
@@ -19,26 +19,25 @@ module PostgREST.Query.Statements
 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.Snippet   as SQL
-import qualified Hasql.DynamicStatements.Statement as H
+import qualified Hasql.DynamicStatements.Statement as SQL
-import qualified Hasql.Statement                   as H
+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.Error            (Error (..))
+import PostgREST.GucHeader (GucHeader)
 import PostgREST.GucHeader        (GucHeader)
 import PostgREST.DbStructure.Identifiers (FieldName)
 import PostgREST.Query.SqlFragment
 import PostgREST.Request.Preferences
-import Protolude      hiding (toS)
+import Protolude
 import Protolude.Conv (toS)
 {-| The generic query result format used by API responses. The location header
    is represented as a list of strings containing variable bindings like
@@ -46,22 +45,22 @@ import Protolude.Conv (toS)
 -}
 type ResultsWithCount = (Maybe Int64, Int64, [BS.ByteString], BS.ByteString, Either Error [GucHeader], Either Error (Maybe Status))
-createWriteStatement :: H.Snippet -> H.Snippet -> Bool -> Bool -> Bool ->
+createWriteStatement :: SQL.Snippet -> SQL.Snippet -> Bool -> Bool -> Bool ->
-                        PreferRepresentation -> [Text] -> PgVersion -> Bool ->
+                        PreferRepresentation -> [Text] -> Bool ->
-                        H.Statement () ResultsWithCount
+                        SQL.Statement () ResultsWithCount
-createWriteStatement selectQuery mutateQuery wantSingle isInsert asCsv rep pKeys pgVer =
+createWriteStatement selectQuery mutateQuery wantSingle isInsert asCsv rep pKeys =
-  H.dynamicallyParameterized snippet decodeStandard
+  SQL.dynamicallyParameterized snippet decodeStandard
 where
  snippet =
-    "WITH " <> H.sql sourceCTEName <> " AS (" <> mutateQuery <> ") " <>
+    "WITH " <> SQL.sql sourceCTEName <> " AS (" <> mutateQuery <> ") " <>
-    H.sql (
+    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, " <>
+      responseHeadersF <> " AS response_headers, " <>
-      responseStatusF pgVer  <> " AS response_status "
+      responseStatusF  <> " AS response_status "
    ) <>
    "FROM (" <> selectF <> ") _postgrest_t"
@@ -82,29 +81,29 @@ createWriteStatement selectQuery mutateQuery wantSingle isInsert asCsv rep pKeys
  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)
+    | rep `elem` [None, HeadersOnly] = SQL.sql ("SELECT * FROM " <> sourceCTEName)
    | otherwise                      = selectQuery
  decodeStandard :: HD.Result ResultsWithCount
  decodeStandard =
   fromMaybe (Nothing, 0, [], mempty, Right [], Right Nothing) <$> HD.rowMaybe standardRow
-createReadStatement :: H.Snippet -> H.Snippet -> Bool -> Bool -> Bool -> Maybe FieldName -> PgVersion -> Bool ->
+createReadStatement :: SQL.Snippet -> SQL.Snippet -> Bool -> Bool -> Bool -> Maybe FieldName -> Bool ->
-                       H.Statement () ResultsWithCount
+                       SQL.Statement () ResultsWithCount
-createReadStatement selectQuery countQuery isSingle countTotal asCsv binaryField pgVer =
+createReadStatement selectQuery countQuery isSingle countTotal asCsv binaryField =
-  H.dynamicallyParameterized snippet decodeStandard
+  SQL.dynamicallyParameterized snippet decodeStandard
 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, " <>
+      responseHeadersF <> " AS response_headers, " <>
-      responseStatusF pgVer <> " AS response_status " <>
+      responseStatusF <> " AS response_status " <>
    "FROM ( SELECT * FROM " <> sourceCTEName <> " ) _postgrest_t")
  (countCTEF, countResultF) = countF countQuery countTotal
@@ -131,22 +130,22 @@ standardRow = (,,,,,) <$> nullableColumn HD.int8 <*> column HD.int8
 type ProcResults = (Maybe Int64, Int64, ByteString, Either Error [GucHeader], Either Error (Maybe Status))
-callProcStatement :: Bool -> Bool -> H.Snippet -> H.Snippet -> H.Snippet -> Bool ->
+callProcStatement :: Bool -> Bool -> SQL.Snippet -> SQL.Snippet -> SQL.Snippet -> Bool ->
-                     Bool -> Bool -> Bool -> Maybe FieldName -> PgVersion -> Bool ->
+                     Bool -> Bool -> Bool -> Maybe FieldName -> Bool ->
-                     H.Statement () ProcResults
+                     SQL.Statement () ProcResults
-callProcStatement returnsScalar returnsSingle callProcQuery selectQuery countQuery countTotal asSingle asCsv multObjects binaryField pgVer =
+callProcStatement returnsScalar returnsSingle callProcQuery selectQuery countQuery countTotal asSingle asCsv multObjects binaryField =
-  H.dynamicallyParameterized snippet decodeProc
+  SQL.dynamicallyParameterized snippet decodeProc
  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, " <>
+        responseHeadersF <> " AS response_headers, " <>
-        responseStatusF pgVer <> " AS response_status ") <>
+        responseStatusF <> " AS response_status ") <>
      "FROM (" <> selectQuery <> ") _postgrest_t"
    (countCTEF, countResultF) = countF countQuery countTotal
@@ -170,9 +169,9 @@ callProcStatement returnsScalar returnsSingle callProcQuery selectQuery countQue
                         <*> (fromMaybe defGucHeaders <$> nullableColumn decodeGucHeaders)
                         <*> (fromMaybe defGucStatus <$> nullableColumn decodeGucStatus)
-createExplainStatement :: H.Snippet -> Bool -> H.Statement () (Maybe Int64)
+createExplainStatement :: SQL.Snippet -> Bool -> SQL.Statement () (Maybe Int64)
 createExplainStatement countQuery =
-  H.dynamicallyParameterized snippet decodeExplain
+  SQL.dynamicallyParameterized snippet decodeExplain
  where
    snippet = "EXPLAIN (FORMAT JSON) " <> countQuery
    -- |
@@ -189,7 +188,7 @@ createExplainStatement countQuery =
      (^? L.nth 0 . L.key "Plan" .  L.key "Plan Rows" . L._Integral) <$> row
 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
@@ -26,8 +26,7 @@ import Data.Ranged.Ranges
 import Network.HTTP.Types.Header
 import Network.HTTP.Types.Status
-import Protolude      hiding (toS)
+import Protolude
 import Protolude.Conv (toS)
 type NonnegRange = Range Integer
@@ -37,7 +36,7 @@ rangeParse range = do
  case listToMaybe (range =~ rangeRegex :: [[BS.ByteString]]) of
    Just parsedRange ->
-      let [_, mLower, mUpper] = readMaybe . toS <$> parsedRange
+      let [_, mLower, mUpper] = readMaybe . BS.unpack <$> parsedRange
          lower         = maybe emptyRange rangeGeq mLower
          upper         = maybe allRange rangeLeq mUpper in
      rangeIntersection lower upper
@@ -3,7 +3,6 @@ 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 #-}
@@ -13,25 +12,26 @@ module PostgREST.Request.ApiRequest
  , ContentType(..)
  , Action(..)
  , Target(..)
-  , PayloadJSON(..)
+  , Payload(..)
  , userApiRequest
  ) where
-import qualified Data.Aeson           as JSON
+import qualified Data.Aeson            as JSON
-import qualified Data.ByteString      as BS
+import qualified Data.ByteString.Char8 as BS
-import qualified Data.ByteString.Lazy as BL
+import qualified Data.ByteString.Lazy  as LBS
-import qualified Data.CaseInsensitive as CI
+import qualified Data.CaseInsensitive  as CI
-import qualified Data.Csv             as CSV
+import qualified Data.Csv              as CSV
-import qualified Data.HashMap.Strict  as M
+import qualified Data.HashMap.Strict   as M
-import qualified Data.List            as L
+import qualified Data.List             as L
-import qualified Data.Set             as S
+import qualified Data.List.NonEmpty    as NonEmptyList
-import qualified Data.Text            as T
+import qualified Data.Set              as S
-import qualified Data.Vector          as V
+import qualified Data.Text             as T
 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.Maybe                (fromJust)
 import Data.Ranged.Boundaries    (Boundary (..))
 import Data.Ranged.Ranges        (Range (..), emptyRange,
@@ -51,9 +51,8 @@ import PostgREST.DbStructure             (DbStructure (..))
 import PostgREST.DbStructure.Identifiers (FieldName,
                                          QualifiedIdentifier (..),
                                          Schema)
-import PostgREST.DbStructure.Proc        (PgArg (..),
+import PostgREST.DbStructure.Proc        (ProcDescription (..),
-                                          ProcDescription (..),
+                                          ProcParam (..), ProcsMap)
                                          ProcsMap)
 import PostgREST.Error                   (ApiRequestError (..))
 import PostgREST.Query.SqlFragment       (ftsOperators, operators)
 import PostgREST.RangeQuery              (NonnegRange, allRange,
@@ -67,26 +66,27 @@ import PostgREST.Request.Preferences     (PreferCount (..),
                                          PreferResolution (..),
                                          PreferTransaction (..))
-import qualified PostgREST.ContentType as ContentType
+import qualified PostgREST.ContentType         as ContentType
 import qualified PostgREST.Request.Preferences as Preferences
-import Protolude      hiding (head, toS)
+import Protolude
 import Protolude.Conv (toS)
-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
 -- | Types of things a user wants to do to tables/views/procs
@@ -119,15 +119,15 @@ 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
+  if not $ pdHasVariadic proc then -- if proc has no variadic param, save steps and directly convert to json
    ProcessedJSON (JSON.encode $ M.fromList $ second JSON.toJSON <$> prms) (S.fromList $ fst <$> prms)
  else
    let paramsMap = M.fromListWith mergeParams $ toRpcParamValue proc <$> prms in
@@ -135,9 +135,9 @@ jsonRpcParams proc prms =
  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
@@ -152,10 +152,10 @@ targetToJsonRpcParams target params =
 -}
 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
+  , iRange                :: M.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
@@ -184,7 +184,7 @@ userApiRequest conf@AppConfig{..} dbStructure req reqBody
  | 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
+  | shouldParsePayload && isLeft payload = either (Left . InvalidBody) witness payload
  | isLeft parsedColumns = either Left witness parsedColumns
  | otherwise = do
     acceptContentType <- findAcceptContentType conf action path accepts
@@ -195,29 +195,20 @@ userApiRequest conf@AppConfig{..} dbStructure req reqBody
      , iRange = ranges
      , iTopLevelRange = topLevelRange
      , iPayload = relevantPayload
-      , iPreferRepresentation = representation
+      , iPreferRepresentation = fromMaybe None preferRepresentation
-      , iPreferParameters  = if | hasPrefer (show SingleObject)     -> Just SingleObject
+      , iPreferParameters = preferParameters
-                                | hasPrefer (show MultipleObjects)  -> Just MultipleObjects
+      , iPreferCount = preferCount
-                                | otherwise                         -> Nothing
+      , iPreferResolution = preferResolution
-      , iPreferCount       = if | hasPrefer (show ExactCount)       -> Just ExactCount
+      , iPreferTransaction = preferTransaction
                                | 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)
      , iColumns = payloadColumns
      , iOrder = [(toS k, toS $ fromJust v) | (k,v) <- qParams, isJust v, endingIn ["order"] k ]
-      , iCanonicalQS = toS $ urlEncodeVars
+      , iCanonicalQS = BS.pack $ urlEncodeVars
        . L.sortOn fst
-        . map (join (***) toS . second (fromMaybe BS.empty))
+        . map (join (***) BS.unpack . second (fromMaybe mempty))
        $ qString
      , iJWT = tokenStr
      , iHeaders = [ (CI.foldedCase k, v) | (k,v) <- hdrs, k /= hCookie]
@@ -254,7 +245,7 @@ userApiRequest conf@AppConfig{..} dbStructure req reqBody
  isTargetingDefaultSpec = case path of
    PathInfo{pIsDefaultSpec=True} -> True
    _                             -> False
-  contentType = ContentType.decodeContentType . fromMaybe "application/json" $ lookupHeader "content-type"
+  contentType = maybe CTApplicationJSON ContentType.decodeContentType $ lookupHeader "content-type"
  columns
    | action `elem` [ActionCreate, ActionUpdate, ActionInvoke InvPost] = toS <$> join (lookup "columns" qParams)
    | otherwise = Nothing
@@ -263,27 +254,30 @@ userApiRequest conf@AppConfig{..} dbStructure req reqBody
    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
+      (CTUrlEncoded, _)         -> S.fromList $ map (T.decodeUtf8 . fst) $ parseSimpleQuery $ LBS.toStrict reqBody
      _ -> case (relevantPayload, fromRight Nothing parsedColumns) of
-        (Just ProcessedJSON{pjKeys}, _) -> pjKeys
+        (Just ProcessedJSON{payKeys}, _) -> payKeys
-        (Just RawJSON{}, Just cls)      -> cls
+        (Just RawJSON{}, Just cls)       -> cls
-        _                               -> S.empty
+        _                                -> S.empty
  payload :: Either ByteString Payload
  payload = case contentType of
    CTApplicationJSON ->
      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 && isTargetingProc
                     then Right emptyObject
-                     else JSON.eitherDecode reqBody
+                     else first BS.pack $ JSON.eitherDecode reqBody
    CTTextCSV -> do
-      json <- csvToJson <$> CSV.decodeByName reqBody
+      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
+      let paramsMap = M.fromList $ (T.decodeUtf8 *** JSON.String . T.decodeUtf8) <$> parseSimpleQuery (LBS.toStrict reqBody) in
      Right $ ProcessedJSON (JSON.encode paramsMap) $ S.fromList (M.keys paramsMap)
    ct ->
-      Left $ toS $ "Content-Type not acceptable: " <> ContentType.toMime ct
+      if isTargetingProc && ct `elem` [CTTextPlain, CTOctetStream]
        then Right $ RawPay reqBody
        else Left $ "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
@@ -304,7 +298,7 @@ userApiRequest conf@AppConfig{..} dbStructure req reqBody
      "OPTIONS" -> ActionInfo
      _         -> ActionInspect{isHead=False}
-  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
@@ -317,12 +311,14 @@ userApiRequest conf@AppConfig{..} dbStructure req reqBody
        ActionInvoke InvPost -> contentProfile
        _                    -> acceptProfile
    where
-      contentProfile = Just $ maybe defaultSchema toS $ lookupHeader "Content-Profile"
+      contentProfile = Just $ maybe defaultSchema T.decodeUtf8 $ lookupHeader "Content-Profile"
-      acceptProfile = Just $ maybe defaultSchema toS $ lookupHeader "Accept-Profile"
+      acceptProfile = Just $ maybe defaultSchema T.decodeUtf8 $ lookupHeader "Accept-Profile"
  schema = fromMaybe defaultSchema profile
  target =
    let
-      callFindProc procSch procNam = findProc (QualifiedIdentifier procSch procNam) payloadColumns (hasPrefer (show SingleObject)) $ dbProcs dbStructure
+      callFindProc procSch procNam = findProc
        (QualifiedIdentifier procSch procNam) payloadColumns (preferParameters == Just SingleObject) (dbProcs dbStructure)
        contentType (action == ActionInvoke InvPost)
    in
    case path of
      PathInfo{pSchema, pName, pHasRpc, pIsRootSpec, pIsDefaultSpec}
@@ -339,7 +335,7 @@ userApiRequest conf@AppConfig{..} dbStructure req reqBody
    -- 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)
+    (CTUrlEncoded, ActionInvoke InvPost) -> targetToJsonRpcParams (rightToMaybe target) $ (T.decodeUtf8 *** T.decodeUtf8) <$> parseSimpleQuery (LBS.toStrict reqBody)
    _ | shouldParsePayload               -> rightToMaybe payload
      | otherwise                        -> Nothing
  path =
@@ -353,20 +349,11 @@ userApiRequest conf@AppConfig{..} dbStructure req reqBody
      _              -> PathUnknown
  method          = requestMethod req
  hdrs            = requestHeaders req
-  qParams         = [(toS k, v)|(k,v) <- qString]
+  qParams         = [(T.decodeUtf8 k, T.decodeUtf8 <$> v)|(k,v) <- qString]
  lookupHeader    = flip lookup hdrs
-  hasPrefer :: Text -> Bool
+  Preferences.Preferences{..} = Preferences.fromHeaders hdrs
  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
+  tokenStr = case T.split (== ' ') (T.decodeUtf8 auth) of
    ("Bearer" : t : _) -> t
    ("bearer" : t : _) -> t
    _                  -> ""
@@ -376,10 +363,10 @@ userApiRequest conf@AppConfig{..} dbStructure req reqBody
  headerRange = rangeRequested hdrs
  replaceLast x s = T.intercalate "." $ L.init (T.split (=='.') s) ++ [x]
-  limitParams :: M.HashMap ByteString NonnegRange
+  limitParams :: M.HashMap Text NonnegRange
-  limitParams  = M.fromList [(toS (replaceLast "limit" k), restrictRange (readMaybe . toS =<< v) allRange) | (k,v) <- qParams, isJust v, endingIn ["limit"] k]
+  limitParams  = M.fromList [(toS (replaceLast "limit" k), restrictRange (readMaybe =<< v) allRange) | (k,v) <- qParams, isJust v, endingIn ["limit"] k]
-  offsetParams :: M.HashMap ByteString NonnegRange
+  offsetParams :: M.HashMap Text NonnegRange
-  offsetParams = M.fromList [(toS (replaceLast "limit" k), maybe allRange rangeGeq (readMaybe . toS =<< v)) | (k,v) <- qParams, isJust v, endingIn ["offset"] k]
+  offsetParams = M.fromList [(toS (replaceLast "limit" k), maybe allRange rangeGeq (readMaybe =<< v)) | (k,v) <- qParams, isJust v, endingIn ["offset"] k]
  urlRange = M.unionWith f limitParams offsetParams
    where
@@ -402,7 +389,7 @@ mutuallyAgreeable sProduces cAccepts =
     then listToMaybe sProduces
     else exact
-type CsvData = V.Vector (M.HashMap Text BL.ByteString)
+type CsvData = V.Vector (M.HashMap Text LBS.ByteString)
 {-|
  Converts CSV like
@@ -424,10 +411,10 @@ csvToJson (_, vals) =
    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
@@ -480,37 +467,52 @@ rawContentTypes AppConfig{..} =
  (ContentType.decodeContentType <$> configRawMediaTypes) `union` [CTOctetStream, CTTextPlain]
 {-|
-  Search a pg procedure by its parameters. Since a function can be overloaded, the name is not enough to find it.
+  Search a pg proc by matching name and arguments keys to parameters. Since a function can be overloaded,
-  An overloaded function can have a different volatility or even a different return type.
+  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 :: QualifiedIdentifier -> S.Set Text -> Bool -> ProcsMap -> ContentType -> Bool -> Either ApiRequestError ProcDescription
-findProc qi payloadKeys paramsAsSingleObject allProcs =
+findProc qi argumentsKeys paramsAsSingleObject allProcs contentType isInvPost =
-  case bestMatch of
+  case matchProc of
-    []     -> Left $ NoRpc (qiSchema qi) (qiName qi) (S.toList payloadKeys) paramsAsSingleObject
+    ([], [])     -> Left $ NoRpc (qiSchema qi) (qiName qi) (S.toList argumentsKeys) paramsAsSingleObject contentType isInvPost
-    [proc] -> Right proc
+    -- If there are no functions with named arguments, fallback to the single unnamed argument function
-    procs  -> Left $ AmbiguousRpc (toList procs)
+    ([], [proc]) -> Right proc
    ([], procs)  -> Left $ AmbiguousRpc (toList procs)
    -- Matches the functions with named arguments
    ([proc], _)  -> Right proc
    (procs, _)   -> Left $ AmbiguousRpc (toList procs)
  where
-    bestMatch =
+    matchProc = overloadedProcPartition $ M.lookupDefault mempty qi allProcs -- first find the proc by name
-      case M.lookup qi allProcs of
+    -- The partition obtained has the form (overloadedProcs,fallbackProcs)
-        Nothing     -> []
+    -- where fallbackProcs are functions with a single unnamed parameter
-        Just [proc] -> [proc | matches proc]
+    overloadedProcPartition procs = foldr select ([],[]) procs
-        Just procs  -> filter matches procs
+    select proc ~(ts,fs)
-    -- Find the exact arguments match
+      | matchesParams proc         = (proc:ts,fs)
-    matches proc
+      | hasSingleUnnamedParam proc = (ts,proc:fs)
-      | paramsAsSingleObject = case pdArgs proc of
+      | otherwise                  = (ts,fs)
-                               [arg] -> pgaType arg `elem` ["json", "jsonb"]
+    -- If the function is called with post and has a single unnamed parameter
-                               _     -> False
+    -- it can be called depending on content type and the parameter type
-      | otherwise            = case pdArgs proc of
+    hasSingleUnnamedParam proc = isInvPost && case pdParams proc of
-                               []   -> null payloadKeys
+      [ProcParam "" ppType _ _]
-                               args -> matchesArg args
+        | contentType == CTApplicationJSON -> ppType `elem` ["json", "jsonb"]
-    matchesArg args =
+        | contentType == CTTextPlain       -> ppType == "text"
-      -- The function's required arguments are separated from the ones with a default value assigned.
+        | contentType == CTOctetStream     -> ppType == "bytea"
-      -- The set of names of those arguments is compared to the set of keys supplied by the client
+        | otherwise                        -> False
-      -- 1. If only required arguments are found, the keys must be exactly the same as those arguments
+      _ -> False
-      -- 2. If only optional arguments are found, the keys must be a subset of those arguments
+    matchesParams proc =
-      -- 3. If both required and optional arguments are found, the result of taking away the optional arguments
+      let params = pdParams proc in
-      --    from the keys must be exactly the same as the required arguments
+      -- exceptional case for Prefer: params=single-object
-      case L.partition pgaReq args of
+      if paramsAsSingleObject
-        (reqArgs, [])      -> payloadKeys == S.fromList (pgaName <$> reqArgs)
+        then length params == 1 && (ppType <$> headMay params) `elem` [Just "json", Just "jsonb"]
-        ([], defArgs)      -> payloadKeys `S.isSubsetOf` S.fromList (pgaName <$> defArgs)
+      -- If the function has no parameters, the arguments keys must be empty as well
-        (reqArgs, defArgs) -> payloadKeys `S.difference` S.fromList (pgaName <$> defArgs) == S.fromList (pgaName <$> reqArgs)
+      else if null params
        then null argumentsKeys && not (isInvPost && contentType `elem` [CTTextPlain, CTOctetStream])
      -- 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)
@@ -18,7 +18,7 @@ resource.
 module PostgREST.Request.DbRequestBuilder
  ( readRequest
  , mutateRequest
-  , returningCols
+  , callRequest
  ) where
 import qualified Data.HashMap.Strict as M
@@ -33,6 +33,9 @@ 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 (..))
@@ -45,7 +48,7 @@ import PostgREST.RangeQuery               (NonnegRange, allRange,
                                           restrictRange)
 import PostgREST.Request.ApiRequest       (Action (..),
                                           ApiRequest (..),
-                                           PayloadJSON (..))
+                                           Payload (..))
 import PostgREST.Request.Parsers
 import PostgREST.Request.Preferences
@@ -53,7 +56,7 @@ import PostgREST.Request.Types
 import qualified PostgREST.DbStructure.Relationship as Relationship
-import Protolude hiding (from)
+import Protolude hiding (from, isInfixOf)
 -- | Builds the ReadRequest tree on a number of stages.
 -- | Adds filters, order, limits on its respective nodes.
@@ -97,16 +100,16 @@ initReadRequest rootQi =
    rootDepth = 0
    rootSchema = qiSchema rootQi
    rootName = qiName rootQi
-    initial = Node (Select [] rootQi Nothing [] [] [] [] allRange, (rootName, Nothing, Nothing, Nothing, rootDepth)) []
+    initial = Node (Select [] rootQi Nothing [] [] [] [] 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)) [])
+                (fn, Nothing, alias, hint, joinType, nxtDepth)) [])
              fldForest:rForest
 -- | Enforces the `max-rows` config on the result
@@ -122,16 +125,16 @@ augmentRequestWithJoin schema allRels request =
  >>= addJoinConditions Nothing
 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 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
+          newReadNode = (\r -> (query{from=newFrom r}, (nodeName, Just r, alias, hint, joinType, depth))) <$> rel
          rel = findRel schema allRels (qiName parentNodeQi) 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]
@@ -147,7 +150,7 @@ addRels schema allRels parentNode (Node (query@Select{from=tbl}, (nodeName, _, a
 -- 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
+findRel :: Schema -> [Relationship] -> NodeName -> NodeName -> Maybe Hint -> Either ApiRequestError Relationship
 findRel schema allRels origin target hint =
  case rel of
    []  -> Left $ NoRelBetween origin target
@@ -207,7 +210,7 @@ findRel schema allRels origin target hint =
 -- 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) =
+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
@@ -304,7 +307,7 @@ addProperty f (targetNodeName:remainingPath, a) (Node rn forest) =
    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)
  where
-    pathNode = find (\(Node (_,(nodeName,_,alias,_,_)) _) -> nodeName == targetNodeName || alias == Just targetNodeName) forest
+    pathNode = find (\(Node (_,(nodeName,_,alias,_,_, _)) _) -> nodeName == targetNodeName || alias == Just targetNodeName) forest
 mutateRequest :: Schema -> TableName -> ApiRequest -> [FieldName] -> ReadRequest -> Either Error MutateRequest
 mutateRequest schema tName apiRequest pkCols readReq = mapLeft ApiRequestError $
@@ -341,7 +344,25 @@ mutateRequest schema tName apiRequest pkCols readReq = mapLeft ApiRequestError $
    -- 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
+    body = payRaw <$> iPayload apiRequest -- 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 params = filter (\x -> ppName x `S.member` iColumns apiReq) params
 returningCols :: ReadRequest -> [FieldName] -> [FieldName]
 returningCols rr@(Node _ forest) pkCols
@@ -358,7 +379,7 @@ 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{relColumns=cols}, _, _, _, _)) _ -> Just cols
        _                                                        -> Nothing
      ) forest
    -- However if the "client_id" is present, e.g. mutateRequest to
@@ -47,8 +47,7 @@ import PostgREST.RangeQuery              (NonnegRange)
 import PostgREST.Request.Types
-import Protolude      hiding (intercalate, option, replace, toS, try)
+import Protolude hiding (intercalate, option, replace, try)
 import Protolude.Conv (toS)
 pRequestSelect :: Text -> Either ApiRequestError [Tree SelectItem]
 pRequestSelect selStr =
@@ -73,7 +72,7 @@ pRequestOrder (k, v) = mapError $ (,) <$> path <*> ord'
    path = fst <$> treePath
    ord' = parse pOrder ("failed to parse order (" ++ toS v ++ ")") $ toS v
-pRequestRange :: (ByteString, NonnegRange) -> Either ApiRequestError (EmbedPath, NonnegRange)
+pRequestRange :: (Text, 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
@@ -117,7 +116,7 @@ pFieldForest = pFieldTree `sepBy1` lexeme (char ',')
                  Node <$> pFieldSelect <*> pure []
 pStar :: Parser Text
-pStar = toS <$> (string "*" $> ("*"::ByteString))
+pStar = string "*" $> "*"
 pFieldName :: Parser Text
 pFieldName =
@@ -158,13 +157,23 @@ pRelationSelect :: Parser SelectItem
 pRelationSelect = lexeme $ try ( do
    alias <- optionMaybe ( try(pFieldName <* aliasSeparator) )
    fld <- pField
-    hint <- optionMaybe (
+    prm1 <- optionMaybe pEmbedParam
-        try ( char '!' *> pFieldName) <|>
+    prm2 <- optionMaybe pEmbedParam
-        -- deprecated, remove in next major version
+    return (fld, Nothing, alias, embedParamHint prm1 <|> embedParamHint prm2, embedParamJoin prm1 <|> embedParamJoin prm2)
        try ( char '.' *> pFieldName)
      )
    return (fld, Nothing, alias, hint)
  )
  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 $
@@ -173,11 +182,11 @@ pFieldSelect = lexeme $
      alias <- optionMaybe ( try(pFieldName <* aliasSeparator) )
      fld <- pField
      cast' <- optionMaybe (string "::" *> many letter)
-      return (fld, toS <$> cast', alias, Nothing)
+      return (fld, toS <$> cast', alias, Nothing, Nothing)
  )
  <|> do
    s <- pStar
-    return ((s, []), Nothing, Nothing, Nothing)
+    return ((s, []), Nothing, Nothing, Nothing, Nothing)
 pOpExpr :: Parser SingleVal -> Parser OpExpr
 pOpExpr pSVal = try ( string "not" *> pDelimiter *> (OpExpr True <$> pOperation)) <|> OpExpr False <$> pOperation
@@ -186,17 +195,30 @@ pOpExpr pSVal = try ( string "not" *> pDelimiter *> (OpExpr True <$> pOperation)
    pOperation =
          Op . toS <$> foldl1 (<|>) (try . ((<* pDelimiter) . string) . toS <$> M.keys ops) <*> pSVal
      <|> In <$> (try (string "in" *> pDelimiter) *> pListVal)
      <|> Is <$> (try (string "is" *> pDelimiter) *> pTriVal)
      <|> pFts
      <?> "operator (eq, gt, ...)"
    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
      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
+    ops = M.filterWithKey (const . flip notElem ("in":"is":ftsOps)) operators
    ftsOps = M.keys ftsOperators
    -- 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
@@ -207,7 +229,9 @@ pListElement :: Parser Text
 pListElement = try (pQuotedValue <* notFollowedBy (noneOf ",)")) <|> (toS <$> many (noneOf ",)"))
 pQuotedValue :: Parser Text
-pQuotedValue = toS <$> (char '"' *> many (noneOf "\"") <* char '"')
+pQuotedValue = toS <$> (char '"' *> many pCharsOrSlashed <* char '"')
  where
    pCharsOrSlashed = noneOf "\\\"" <|> (char '\\' *> anyChar)
 pDelimiter :: Parser Char
 pDelimiter = char '.' <?> "delimiter (.)"
@@ -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
+instance ToHeaderValue PreferResolution where
-  show MergeDuplicates  = "resolution=merge-duplicates"
+  toHeaderValue MergeDuplicates  = "resolution=merge-duplicates"
-  show IgnoreDuplicates = "resolution=ignore-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).
  | 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
+instance ToHeaderValue PreferRepresentation where
-  show Full        = "return=representation"
+  toHeaderValue Full        = "return=representation"
-  show None        = "return=minimal"
+  toHeaderValue None        = "return=minimal"
-  show HeadersOnly = "return=headers-only"
+  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
+  = 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
+  | MultipleObjects -- ^ Pass an array of json objects as params to a stored procedure.
  deriving Eq
-instance Show PreferParameters where
+instance ToHeaderValue PreferParameters where
-  show SingleObject    = "params=single-object"
+  toHeaderValue SingleObject    = "params=single-object"
-  show MultipleObjects = "params=multiple-objects"
+  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
+instance ToHeaderValue PreferCount where
-  show ExactCount     = "count=exact"
+  toHeaderValue ExactCount     = "count=exact"
-  show PlannedCount   = "count=planned"
+  toHeaderValue PlannedCount   = "count=planned"
-  show EstimatedCount = "count=estimated"
+  toHeaderValue EstimatedCount = "count=estimated"
 -- | Whether to commit or roll back transactions.
 data PreferTransaction
-  = Commit   -- Commit transaction - the default.
+  = Commit   -- ^ Commit transaction - the default.
-  | Rollback -- Rollback transaction after sending the response - does not persist changes, e.g. for running tests.
+  | Rollback -- ^ Rollback transaction after sending the response - does not persist changes, e.g. for running tests.
  deriving Eq
-instance Show PreferTransaction where
+instance ToHeaderValue PreferTransaction where
-  show Commit   = "tx=commit"
+  toHeaderValue Commit   = "tx=commit"
-  show Rollback = "tx=rollback"
+  toHeaderValue Rollback = "tx=rollback"
 instance ToAppliedHeader PreferTransaction
@@ -2,11 +2,16 @@
 module PostgREST.Request.Types
  ( Alias
  , Depth
-  , EmbedHint
+  , EmbedParam(..)
  , EmbedPath
  , Field
  , Filter(..)
  , Hint
  , CallQuery(..)
  , CallParams(..)
  , CallRequest
  , JoinCondition(..)
  , JoinType(..)
  , JsonOperand(..)
  , JsonOperation(..)
  , JsonPath
@@ -26,18 +31,18 @@ module PostgREST.Request.Types
  , ReadRequest
  , SelectItem
  , SingleVal
  , TrileanVal(..)
  , fstFieldNames
  ) where
-import qualified Data.ByteString.Lazy as BL
+import qualified Data.ByteString.Lazy as LBS
 import qualified Data.Set             as S
 import Data.Tree (Tree (..))
 import qualified GHC.Show (show)
 import PostgREST.DbStructure.Identifiers  (FieldName,
                                           QualifiedIdentifier)
 import PostgREST.DbStructure.Proc         (ProcParam (..))
 import PostgREST.DbStructure.Relationship (Relationship)
 import PostgREST.RangeQuery               (NonnegRange)
 import PostgREST.Request.Preferences      (PreferResolution)
@@ -47,9 +52,10 @@ import Protolude
 type ReadRequest = Tree ReadNode
 type MutateRequest = MutateQuery
 type CallRequest = CallQuery
 type ReadNode =
-  (ReadQuery, (NodeName, Maybe Relationship, Maybe Alias, Maybe EmbedHint, Depth))
+  (ReadQuery, (NodeName, Maybe Relationship, Maybe Alias, Maybe Hint, Maybe JoinType, Depth))
 type NodeName = Text
 type Depth = Integer
@@ -86,24 +92,16 @@ 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 MutateQuery
  = Insert
      { in_        :: QualifiedIdentifier
      , insCols    :: S.Set FieldName
-      , insBody    :: Maybe BL.ByteString
+      , insBody    :: Maybe LBS.ByteString
      , onConflict :: Maybe (PreferResolution, [FieldName])
      , where_     :: [LogicTree]
      , returning  :: [FieldName]
@@ -111,7 +109,7 @@ data MutateQuery
  | Update
      { in_       :: QualifiedIdentifier
      , updCols   :: S.Set FieldName
-      , updBody   :: Maybe BL.ByteString
+      , updBody   :: Maybe LBS.ByteString
      , where_    :: [LogicTree]
      , returning :: [FieldName]
      }
@@ -121,17 +119,38 @@ data MutateQuery
      , returning :: [FieldName]
      }
 data CallQuery = FunctionCall
  { funCQi           :: QualifiedIdentifier
  , funCParams       :: CallParams
  , funCArgs         :: Maybe LBS.ByteString
  , funCScalar       :: Bool
  , funCMultipleCall :: Bool
  , funCReturning    :: [FieldName]
  }
 data CallParams
  = KeyParams [ProcParam] -- ^ Call with key params: func(a := val1, b:= val2)
  | OnePosParam ProcParam -- ^ Call with positional params(only one supported): func(val)
 -- | The select value in `/tbl?select=alias:field::cast`
-type SelectItem = (Field, Maybe Cast, Maybe Alias, Maybe EmbedHint)
+type SelectItem = (Field, Maybe Cast, Maybe Alias, Maybe Hint, Maybe JoinType)
 type Field = (FieldName, JsonPath)
 type Cast = Text
 type Alias = Text
 type Hint = Text
-- | Disambiguates an embedding operation when there's multiple relationships
+data EmbedParam
-- between two tables. Can be the name of a foreign key constraint, column
+  -- | Disambiguates an embedding operation when there's multiple relationships
-- name or the junction in an m2m relationship.
+  -- between two tables. Can be the name of a foreign key constraint, column
-type EmbedHint = Text
+  -- 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"]
@@ -158,7 +177,7 @@ data JsonOperand
 -- 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
+  fst . (\(f, _, _, _, _) -> f) <$> select sel
 -- | Boolean logic expression tree e.g. "and(name.eq.N,or(id.eq.1,id.eq.2))" is:
@@ -178,10 +197,6 @@ data LogicOperator
  | Or
  deriving Eq
 instance Show LogicOperator where
  show And = "AND"
  show Or  = "OR"
 data Filter = Filter
  { field  :: Field
  , opExpr :: OpExpr
@@ -195,6 +210,7 @@ data OpExpr =
 data Operation
  = Op Operator SingleVal
  | In ListVal
  | Is TrileanVal
  | Fts Operator (Maybe Language) SingleVal
  deriving (Eq)
@@ -206,3 +222,11 @@ 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
@@ -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
+-- | User friendly version number such as '1.1.1'.
-prettyVersion :: Text
+-- 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"
+      if $(gitHash) == ("UNKNOWN" :: Text) then
-        then mempty
+        mempty
-        else " (" <> T.take 7 $(gitHash) <> ")"
+      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
@@ -9,13 +9,15 @@ module PostgREST.Workers
 import qualified Data.Aeson                 as JSON
 import qualified Data.ByteString            as BS
-import qualified Hasql.Connection           as C
+import qualified Data.ByteString.Lazy       as LBS
-import qualified Hasql.Notifications        as N
+import qualified Data.Text.Encoding         as T
-import qualified Hasql.Pool                 as P
+import qualified Hasql.Notifications        as SQL
-import qualified Hasql.Transaction.Sessions as HT
+import qualified Hasql.Pool                 as SQL
 import qualified Hasql.Transaction.Sessions as SQL
-import Control.Retry (RetryStatus, capDelay, exponentialBackoff,
+import Control.Retry    (RetryStatus, capDelay, exponentialBackoff,
-                      retrying, rsPreviousDelay)
+                         retrying, rsPreviousDelay)
 import Hasql.Connection (acquire)
 import PostgREST.AppState         (AppState)
 import PostgREST.Config           (AppConfig (..), readAppConfig)
@@ -27,8 +29,7 @@ import PostgREST.Error            (PgError (PgError), checkIsFatal,
 import qualified PostgREST.AppState as AppState
-import Protolude      hiding (head, toS)
+import Protolude
 import Protolude.Conv (toS)
 -- | Current database connection status data ConnectionStatus
@@ -108,7 +109,7 @@ connectionWorker appState = do
 connectionStatus :: AppState -> IO ConnectionStatus
 connectionStatus appState =
  retrying retrySettings shouldRetry $
-    const $ P.release pool >> getConnectionStatus
+    const $ SQL.release pool >> getConnectionStatus
  where
    pool = AppState.getPool appState
    retrySettings = capDelay delayMicroseconds $ exponentialBackoff backoffMicroseconds
@@ -117,11 +118,11 @@ connectionStatus appState =
    getConnectionStatus :: IO ConnectionStatus
    getConnectionStatus = do
-      pgVersion <- P.use pool queryPgVersion
+      pgVersion <- SQL.use pool 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 +145,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 +153,14 @@ loadSchemaCache :: AppState -> IO SCacheStatus
 loadSchemaCache appState = do
  AppConfig{..} <- AppState.getConfig appState
  result <-
-    let transaction = if configDbPreparedStatements then HT.transaction else HT.unpreparedTransaction in
+    let transaction = if configDbPreparedStatements then SQL.transaction else SQL.unpreparedTransaction in
-    P.use (AppState.getPool appState) . transaction HT.ReadCommitted HT.Read $
+    SQL.use (AppState.getPool 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"
@@ -172,8 +174,8 @@ loadSchemaCache appState = do
    Right dbStructure -> do
      AppState.putDbStructure appState dbStructure
-      when (isJust configDbRootSpec) $
+      when (isJust configDbRootSpec) .
-        AppState.putJsonDbS appState $ toS $ JSON.encode dbStructure
+        AppState.putJsonDbS appState . LBS.toStrict $ JSON.encode dbStructure
      AppState.logWithZTime appState "Schema cache loaded"
      return SCLoaded
@@ -193,12 +195,12 @@ 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
+        SQL.listen db $ SQL.toPgIdentifier dbChannel
-        N.waitForNotifications handleNotification db
+        SQL.waitForNotifications handleNotification db
      _ ->
        die $ "Could not listen for notifications on the " <> dbChannel <> " channel"
  where
@@ -233,7 +235,7 @@ reReadConfig startingUp appState = do
        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
@@ -1,4 +1,4 @@
-resolver: lts-18.2 # 2021-07-10, GHC 8.10.4
+resolver: lts-18.14 # 2021-10-24, GHC 8.10.7
 nix:
  packages:
@@ -12,4 +12,8 @@ nix:
 extra-deps:
  - hasql-dynamic-statements-0.3.1@sha256:c3a2c89c4a8b3711368dbd33f0ccfe46a493faa7efc2c85d3e354c56a01dfc48,2673
  - hasql-implicits-0.1.0.2@sha256:5d54e09cb779a209681b139fb3cc726bae75134557932156340cc0a56dd834a8,1361
  - protolude-0.3.1@sha256:1cc9e5a5c26c33a43c52b554443dd9779fef13974eaa0beec7ca6d2551b400da,2647
  - ptr-0.16.8.1@sha256:525219ec5f5da5c699725f7efcef91b00a7d44120fc019878b85c09440bf51d6,2686
  - wai-extra-3.1.8@sha256:bf3dbe8f4c707b502b2a88262ed71c807220651597b76b56983f864af6197890,7280
  - wai-logger-2.3.7@sha256:19a0dc5122e22d274776d80786fb9501956f5e75b8f82464bbdad5604d154d82,1671
  - warp-3.3.19@sha256:c6a47029537d42844386170d732cdfe6d85b2f4279bbaefdd9b50caff6faeebb,10910
@@ -5,29 +5,57 @@
 packages:
 - completed:
    hackage: hasql-dynamic-statements-0.3.1@sha256:c3a2c89c4a8b3711368dbd33f0ccfe46a493faa7efc2c85d3e354c56a01dfc48,2673
    pantry-tree:
      size: 641
      sha256: b1b9a6a26ec765e5fe29f9a670a5c9ec7067ea00dee8491f0819284ff0201b6f
      size: 641
    hackage: hasql-dynamic-statements-0.3.1@sha256:c3a2c89c4a8b3711368dbd33f0ccfe46a493faa7efc2c85d3e354c56a01dfc48,2673
  original:
    hackage: hasql-dynamic-statements-0.3.1@sha256:c3a2c89c4a8b3711368dbd33f0ccfe46a493faa7efc2c85d3e354c56a01dfc48,2673
 - completed:
    hackage: hasql-implicits-0.1.0.2@sha256:5d54e09cb779a209681b139fb3cc726bae75134557932156340cc0a56dd834a8,1361
    pantry-tree:
      size: 310
      sha256: 2f00d1467d0e226b966c2cd7bac433c8948e2f7bbdf8a44936029f66fc20b5f3
      size: 310
    hackage: hasql-implicits-0.1.0.2@sha256:5d54e09cb779a209681b139fb3cc726bae75134557932156340cc0a56dd834a8,1361
  original:
    hackage: hasql-implicits-0.1.0.2@sha256:5d54e09cb779a209681b139fb3cc726bae75134557932156340cc0a56dd834a8,1361
 - completed:
    hackage: ptr-0.16.8.1@sha256:525219ec5f5da5c699725f7efcef91b00a7d44120fc019878b85c09440bf51d6,2686
    pantry-tree:
-      size: 1089
+      sha256: 6452a6ca8d395f7d810139779bb0fd16fc1dbb00f1862630bc08ef5a100430f9
      size: 1645
    hackage: protolude-0.3.1@sha256:1cc9e5a5c26c33a43c52b554443dd9779fef13974eaa0beec7ca6d2551b400da,2647
  original:
    hackage: protolude-0.3.1@sha256:1cc9e5a5c26c33a43c52b554443dd9779fef13974eaa0beec7ca6d2551b400da,2647
 - completed:
    pantry-tree:
      sha256: d2b8440a738719ef8430ec38fe33b129e3940e4ccf2c016a727a1110a43656bb
      size: 1089
    hackage: ptr-0.16.8.1@sha256:525219ec5f5da5c699725f7efcef91b00a7d44120fc019878b85c09440bf51d6,2686
  original:
    hackage: ptr-0.16.8.1@sha256:525219ec5f5da5c699725f7efcef91b00a7d44120fc019878b85c09440bf51d6,2686
 - completed:
    pantry-tree:
      sha256: a544ea95288d188e893322a8e6d68f2b1f844f772dbea1f26e5c0c1a74694f56
      size: 4053
    hackage: wai-extra-3.1.8@sha256:bf3dbe8f4c707b502b2a88262ed71c807220651597b76b56983f864af6197890,7280
  original:
    hackage: wai-extra-3.1.8@sha256:bf3dbe8f4c707b502b2a88262ed71c807220651597b76b56983f864af6197890,7280
 - completed:
    pantry-tree:
      sha256: 52b5abf5c4c09bcfbc06e01f761a75c32cbd3e6ba23c8843981933fcc31ed53c
      size: 474
    hackage: wai-logger-2.3.7@sha256:19a0dc5122e22d274776d80786fb9501956f5e75b8f82464bbdad5604d154d82,1671
  original:
    hackage: wai-logger-2.3.7@sha256:19a0dc5122e22d274776d80786fb9501956f5e75b8f82464bbdad5604d154d82,1671
 - completed:
    pantry-tree:
      sha256: 99ff839445ba2c9e29a294b45904e3f4575336c7d2b4504ce310d611661c761d
      size: 3973
    hackage: warp-3.3.19@sha256:c6a47029537d42844386170d732cdfe6d85b2f4279bbaefdd9b50caff6faeebb,10910
  original:
    hackage: warp-3.3.19@sha256:c6a47029537d42844386170d732cdfe6d85b2f4279bbaefdd9b50caff6faeebb,10910
 snapshots:
 - completed:
-    size: 585392
+    sha256: 87842ecbaa8ca9cee59a7e6be52369dbed82ed075cb4e0d152614a627e8fd488
-    url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/18/2.yaml
+    size: 586069
-    sha256: 7abb45c0cc5eb349448b66d8753655542d45d387ad26970419282eab3d860724
+    url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/18/14.yaml
-  original: lts-18.2
+  original: lts-18.14
@@ -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
@@ -1,71 +0,0 @@
 #! /usr/bin/env bash
 usage() {
  echo "$0 <db-uri> <test-database>"
  exit 1
 }
 if [ -z "$1" ]; then
  echo "Please supply the connection uri for the user with create database privileges"
  usage
 fi
 if [ -z "$2" ]; then
  echo "Please supply the test database name"
  usage
 fi
 if [[ $1 != postgres://* ]]; then
  echo "Please use a valid connection URI (https://www.postgresql.org/docs/current/static/libpq-connect.html#AEN45347)"
  usage
 fi
 BASEPATH=$( cd "$(dirname "$0")" && pwd -P )
 URI="$1"
 #Extract host and port--we need this to form the new connection string
 HOST_PORT=$(echo "$URI" | cut -d'/' -f3 | cut -d'@' -f2 )
 DB=$2
 # Specify the username of choice, or let the script create a random unique user by appending the database name
 TEST_USER_NAME=postgrest_test_authenticator
 # New password will get assigned only if the user does not already exist
 # Otherwise make sure to provide the correct password for the existing user
 TEST_USER_PASS=$(< /dev/urandom env LC_CTYPE=C tr -dc 'a-zA-Z0-9' | fold -w 16 | head -n 1)
 if ! PGOPTIONS='-c client_min_messages=WARNING' psql "$URI" -Xq >/dev/null -c 'select rolcreatedb from pg_authid where rolname = current_user;' 2>/dev/null;
 then
  echo "ERROR: Please specify the user with 'Create DB' permissions, and ensure that the default database for the username exists."
  exit 1
 fi
 # plpgsql does not like psql variables, easier to pull this part off with bash variables
 PGOPTIONS='-c client_min_messages=WARNING' psql "$URI" -Xq >/dev/null <<EOF
 SELECT pg_terminate_backend(pg_stat_activity.pid)
 FROM pg_stat_activity
 WHERE pg_stat_activity.datname = '$DB'
  AND pid <> pg_backend_pid();
 DROP DATABASE IF EXISTS $DB;
 DROP ROLE IF EXISTS $TEST_USER_NAME;
 CREATE USER $TEST_USER_NAME WITH SUPERUSER LOGIN NOINHERIT PASSWORD '$TEST_USER_PASS' CREATEROLE;
 ALTER ROLE postgrest_test_authenticator SET default_text_search_config TO english;
 CREATE DATABASE $DB OWNER $TEST_USER_NAME LC_COLLATE 'POSIX' LC_CTYPE 'POSIX' TEMPLATE template0;
 \\connect $DB
 ALTER SCHEMA public OWNER TO $TEST_USER_NAME;
 ALTER DATABASE $DB SET LC_MESSAGES = 'POSIX';
 ALTER DATABASE $DB SET LC_MONETARY = 'POSIX';
 ALTER DATABASE $DB SET LC_NUMERIC = 'POSIX';
 ALTER DATABASE $DB SET LC_TIME = 'POSIX';
 \i $BASEPATH/fixtures/load.sql
 EOF
 #Remove database path from the connection uri--prevents setting up the new database name with PGDATABASE
 URI=$(echo "$URI" | cut -d'/' -f1-3)
 # Create a new connection string to use with the test runner
 export PGRST_DB_URI="postgres://${TEST_USER_NAME}:$TEST_USER_PASS@$HOST_PORT/$DB"
 export PGRST_DB_ANON_ROLE="postgrest_test_anonymous"
 export PGRST_DB_SCHEMAS="test"
 shift 2
 "$@"
@@ -0,0 +1,17 @@
 module Main (main) where
 import Test.DocTest (doctest)
 import Protolude
 main :: IO ()
 main =
  doctest
    [ "--verbose"
    , "-XOverloadedStrings"
    , "-XNoImplicitPrelude"
    , "-XStandaloneDeriving"
    , "-isrc"
    , "src/PostgREST/Request/Preferences.hs"
    ]
@@ -1,62 +0,0 @@
 \set AUTHENTICATOR current_user
 DROP ROLE IF EXISTS postgrest_test_anonymous, postgrest_test_default_role, postgrest_test_author;
 CREATE ROLE postgrest_test_anonymous;
 CREATE ROLE postgrest_test_default_role;
 CREATE ROLE postgrest_test_author;
 GRANT postgrest_test_anonymous, postgrest_test_default_role, postgrest_test_author TO :USER;
 -- reloadable config options for io tests
 ALTER ROLE postgrest_test_authenticator SET pgrst.jwt_aud = 'https://example.org';
 ALTER ROLE postgrest_test_authenticator SET pgrst.openapi_server_proxy_uri = 'https://example.org/api';
 ALTER ROLE postgrest_test_authenticator SET pgrst.raw_media_types = 'application/vnd.pgrst.db-config';
 ALTER ROLE postgrest_test_authenticator SET pgrst.jwt_secret = 'REALLYREALLYREALLYREALLYVERYSAFE';
 ALTER ROLE postgrest_test_authenticator SET pgrst.jwt_secret_is_base64 = 'true';
 ALTER ROLE postgrest_test_authenticator SET pgrst.jwt_role_claim_key = '."a"."role"';
 ALTER ROLE postgrest_test_authenticator SET pgrst.db_tx_end = 'commit-allow-override';
 ALTER ROLE postgrest_test_authenticator SET pgrst.db_schemas = 'test, tenant1, tenant2';
 ALTER ROLE postgrest_test_authenticator SET pgrst.db_root_spec = 'root';
 ALTER ROLE postgrest_test_authenticator SET pgrst.db_prepared_statements = 'false';
 ALTER ROLE postgrest_test_authenticator SET pgrst.db_pre_request = 'test.custom_headers';
 ALTER ROLE postgrest_test_authenticator SET pgrst.db_max_rows = '1000';
 ALTER ROLE postgrest_test_authenticator SET pgrst.db_extra_search_path = 'public, extensions';
 -- override with database specific setting
 ALTER ROLE postgrest_test_authenticator IN DATABASE :DBNAME SET pgrst.jwt_secret = 'OVERRIDEREALLYREALLYREALLYREALLYVERYSAFE';
 ALTER ROLE postgrest_test_authenticator IN DATABASE :DBNAME SET pgrst.db_extra_search_path = 'public, extensions, private';
 -- other database settings that should be ignored
 DROP DATABASE IF EXISTS other;
 CREATE DATABASE other;
 ALTER ROLE postgrest_test_authenticator IN DATABASE other SET pgrst.db_max_rows = '1111';
 -- non-reloadable configs for io tests
 ALTER ROLE postgrest_test_authenticator SET pgrst.server_host = 'ignored';
 ALTER ROLE postgrest_test_authenticator SET pgrst.server_port = 'ignored';
 ALTER ROLE postgrest_test_authenticator SET pgrst.server_unix_socket = 'ignored';
 ALTER ROLE postgrest_test_authenticator SET pgrst.server_unix_socket_mode = 'ignored';
 ALTER ROLE postgrest_test_authenticator SET pgrst.log_level = 'ignored';
 ALTER ROLE postgrest_test_authenticator SET pgrst.db_anon_role = 'ignored';
 ALTER ROLE postgrest_test_authenticator SET pgrst.db_uri = 'postgresql://ignored';
 ALTER ROLE postgrest_test_authenticator SET pgrst.db_channel_enabled = 'ignored';
 ALTER ROLE postgrest_test_authenticator SET pgrst.db_channel = 'ignored';
 ALTER ROLE postgrest_test_authenticator SET pgrst.db_pool = 'ignored';
 ALTER ROLE postgrest_test_authenticator SET pgrst.db_pool_timeout = 'ignored';
 ALTER ROLE postgrest_test_authenticator SET pgrst.db_config = 'ignored';
 -- other authenticator reloadable config options for io tests
 CREATE ROLE other_authenticator LOGIN NOINHERIT;
 ALTER ROLE other_authenticator SET pgrst.jwt_aud = 'https://otherexample.org';
 ALTER ROLE other_authenticator SET pgrst.openapi_server_proxy_uri = 'https://otherexample.org/api';
 ALTER ROLE other_authenticator SET pgrst.raw_media_types = 'application/vnd.pgrst.other-db-config';
 ALTER ROLE other_authenticator SET pgrst.jwt_secret = 'ODERREALLYREALLYREALLYREALLYVERYSAFE';
 ALTER ROLE other_authenticator SET pgrst.jwt_secret_is_base64 = 'true';
 ALTER ROLE other_authenticator SET pgrst.jwt_role_claim_key = '."other"."role"';
 ALTER ROLE other_authenticator SET pgrst.db_tx_end = 'rollback-allow-override';
 ALTER ROLE other_authenticator SET pgrst.db_schemas = 'test, other_tenant1, other_tenant2';
 ALTER ROLE other_authenticator SET pgrst.db_root_spec = 'other_root';
 ALTER ROLE other_authenticator SET pgrst.db_prepared_statements = 'false';
 ALTER ROLE other_authenticator SET pgrst.db_pre_request = 'test.other_custom_headers';
 ALTER ROLE other_authenticator SET pgrst.db_max_rows = '100';
 ALTER ROLE other_authenticator SET pgrst.db_extra_search_path = 'public, extensions, other';
 ALTER ROLE other_authenticator SET pgrst.openapi_mode = 'disabled';
@@ -1,4 +0,0 @@
 db-pool = 1
 server-unix-socket = "$(POSTGREST_TEST_SOCKET)"
 jwt-secret = "reallyreallyreallyreallyverysafe"
 db-config = false
@@ -1,5 +1,2 @@
 db-pool = 1
 db-pool-timeout = 1
 app.settings.external_api_secret = "0123456789abcdef"
 db-config = false
@@ -1,5 +1,3 @@
 db-pool = 1
 # Read secret from a file: /dev/stdin (alias for standard input)
 jwt-secret = "@/dev/stdin"
 jwt-secret-is-base64 = true
@@ -1,4 +1,3 @@
 db-uri = "@/dev/stdin"
 db-pool = 1
 jwt-secret = "reallyreallyreallyreallyverysafe"
 db-config = false
@@ -9,9 +9,10 @@ db-pre-request = "check_alias"
 db-prepared-statements = true
 db-root-spec = "open_alias"
 db-schemas = "provided_through_alias"
-db-config = "false"
+db-config = false
 db-tx-end = "commit"
 db-uri = "required"
 db-use-legacy-gucs = true
 jwt-aud = ""
 jwt-role-claim-key = ".\"aliased\""
 jwt-secret = ""
@@ -9,9 +9,10 @@ db-pre-request = ""
 db-prepared-statements = false
 db-root-spec = ""
 db-schemas = "required"
-db-config = "false"
+db-config = false
 db-tx-end = "commit"
 db-uri = "required"
 db-use-legacy-gucs = true
 jwt-aud = ""
 jwt-role-claim-key = ".\"role\""
 jwt-secret = ""
@@ -9,9 +9,10 @@ db-pre-request = ""
 db-prepared-statements = false
 db-root-spec = ""
 db-schemas = "required"
-db-config = "false"
+db-config = false
 db-tx-end = "commit"
 db-uri = "required"
 db-use-legacy-gucs = true
 jwt-aud = ""
 jwt-role-claim-key = ".\"role\""
 jwt-secret = ""
@@ -9,9 +9,10 @@ db-pre-request = ""
 db-prepared-statements = true
 db-root-spec = ""
 db-schemas = "required"
-db-config = "false"
+db-config = false
 db-tx-end = "commit"
 db-uri = "required"
 db-use-legacy-gucs = true
 jwt-aud = ""
 jwt-role-claim-key = ".\"role\""
 jwt-secret = ""
@@ -9,9 +9,10 @@ db-pre-request = "test.other_custom_headers"
 db-prepared-statements = false
 db-root-spec = "other_root"
 db-schemas = "test,other_tenant1,other_tenant2"
-db-config = "true"
+db-config = true
 db-tx-end = "rollback-allow-override"
 db-uri = "<REPLACED_WITH_DB_URI>"
 db-use-legacy-gucs = false
 jwt-aud = "https://otherexample.org"
 jwt-role-claim-key = ".\"other\".\"role\""
 jwt-secret = "ODERREALLYREALLYREALLYREALLYVERYSAFE"
@@ -9,13 +9,14 @@ db-pre-request = "test.custom_headers"
 db-prepared-statements = false
 db-root-spec = "root"
 db-schemas = "test,tenant1,tenant2"
-db-config = "true"
+db-config = true
 db-tx-end = "commit-allow-override"
 db-uri = "<REPLACED_WITH_DB_URI>"
 db-use-legacy-gucs = false
 jwt-aud = "https://example.org"
 jwt-role-claim-key = ".\"a\".\"role\""
-jwt-secret = "OVERRIDEREALLYREALLYREALLYREALLYVERYSAFE"
+jwt-secret = "OVERRIDE=REALLY=REALLY=REALLY=REALLY=VERY=SAFE"
-jwt-secret-is-base64 = true
+jwt-secret-is-base64 = false
 log-level = "info"
 openapi-mode = "ignore-privileges"
 openapi-server-proxy-uri = "https://example.org/api"
@@ -9,9 +9,10 @@ db-pre-request = "please_run_fast"
 db-prepared-statements = false
 db-root-spec = "openapi_v3"
 db-schemas = "multi,tenant,setup"
-db-config = "false"
+db-config = false
 db-tx-end = "rollback-allow-override"
 db-uri = "tmp_db"
 db-use-legacy-gucs = false
 jwt-aud = "https://postgrest.org"
 jwt-role-claim-key = ".\"user\"[0].\"real-role\""
 jwt-secret = "c2VjdXJpdHl0aHJvdWdob2JzY3VyaXR5"
@@ -9,9 +9,10 @@ db-pre-request = ""
 db-prepared-statements = true
 db-root-spec = ""
 db-schemas = "required"
-db-config = "true"
+db-config = true
 db-tx-end = "commit"
 db-uri = "required"
 db-use-legacy-gucs = true
 jwt-aud = ""
 jwt-role-claim-key = ".\"role\""
 jwt-secret = ""
@@ -14,6 +14,8 @@ PGRST_DB_SCHEMAS: multi,   tenant,setup
 PGRST_DB_CONFIG: false
 PGRST_DB_TX_END: rollback-allow-override
 PGRST_DB_URI: tmp_db
 PGRST_DB_EMBED_DEFAULT_JOIN: inner
 PGRST_DB_USE_LEGACY_GUCS: false
 PGRST_JWT_AUD: 'https://postgrest.org'
 PGRST_JWT_ROLE_CLAIM_KEY: '.user[0]."real-role"'
 PGRST_JWT_SECRET: c2VjdXJpdHl0aHJvdWdob2JzY3VyaXR5
@@ -9,9 +9,10 @@ db-pre-request = "please_run_fast"
 db-prepared-statements = false
 db-root-spec = "openapi_v3"
 db-schemas = "multi,   tenant,setup"
-db-config = "false"
+db-config = false
 db-tx-end = "rollback-allow-override"
 db-uri = "tmp_db"
 db-use-legacy-gucs = false
 jwt-aud = "https://postgrest.org"
 jwt-role-claim-key = ".user[0].\"real-role\""
 jwt-secret = "c2VjdXJpdHl0aHJvdWdob2JzY3VyaXR5"
@@ -1,4 +1,3 @@
 db-pool = 1
 jwt-role-claim-key = "$(ROLE_CLAIM_KEY)"
 jwt-secret = "reallyreallyreallyreallyverysafe"
 db-config = false
@@ -1,5 +1,3 @@
 db-pool = 1
 # Read secret from a file: /dev/stdin (alias for standard input)
 jwt-secret = "@/dev/stdin"
 jwt-secret-is-base64 = false
@@ -1,5 +1,3 @@
 db-pool = 1
 jwt-secret = "$(JWT_SECRET_FILE)"
 jwt-secret-is-base64 = false
 db-config = false
--- a/Show More
+++ b/Show More