Version 0.2.12.0

Merge pull request #330 from ruslantalpa/master
Fix for #321
2015-10-25 11:46:16 -07:00 · 2015-10-24 12:57:31 -07:00 · 2015-10-24 22:50:03 +03:00 · 2015-10-21 21:12:27 -07:00 · 2015-10-20 19:25:31 -07:00 · 2015-10-19 16:51:53 -07:00
58 changed files with 3582 additions and 656 deletions
@@ -1,3 +1,4 @@
+.DS_Store
 db
 dist
 .cabal-sandbox
@@ -5,3 +6,6 @@ cabal.sandbox.config
 hscope.out
 codex.tags
 .anvil
+.stack-work
+tags
+site
@@ -3,6 +3,48 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).

+## [0.2.12.0] - 2015-10-25
+
+### Added
+- Embed associations, e.g. `/film?select=*,director(*)` - @ruslantalpa
+- Filter columns, e.g. `?select=col1,col2` - @ruslantalpa
+- Does not execute the count total if header "Prefer: count=none" - @diogob
+
+### Fixed
+- Tolerate a missing role in user creation - @calebmer
+- Avoid unnecessary text re-encoding - @ruslantalpa
+
+## [0.2.11.1] - 2015-09-01
+
+### Fixed
+- Accepts `*/*` in Accept header - @diogob
+
+## [0.2.11.0] - 2015-08-28
+### Added
+- Negate any filter in a uniform way, e.g. `?col=not.eq=foo` - @diogob
+- Call stored procedures
+- Filter NOT IN values, e.g. `?col=notin.1,2,3` - @rall
+- CSV responses to GET requests with `Accept: text/csv` - @diogob
+- Debian init scripts - @mkhon
+- Allow filters by computed columns - @diogob
+
+### Fixed
+- Reset user role on error
+- Compatible with Stack
+- Add materialized views to results in GET / - @diogob
+- Indicate insertable=true for views that are insertable through triggers - @diogob
+- Builds under GHC 7.10
+- Allow the use of columns named "count" in relations queried - @diogob
+
+## [0.2.10.0] - 2015-06-03
+### Added
+- Full text search, eg `/foo?text_vector=@@.bar`
+- Include auth id as well as db role to views (for row-level security)
+
+## [0.2.9.1] - 2015-05-20
+### Fixed
+- Put -Werror behind a cabal flag (for CI) so Hackage accepts package
+
 ## [0.2.9.0] - 2015-05-20
 ### Added
 - Return range headers in PATCH
@@ -39,12 +39,17 @@ your contributions.
  committers. Continuous integration will check this as well on every
  pull request.

+* For help building the Haskell code on your computer check out the [building from
+source](https://github.com/begriffs/postgrest/wiki/Building-from-source)
+wiki page.
+
 ## Maintenance

 ### Schedule

 Currently I (@begriffs) am the sole maintainer, and while I am
 overjoyed to help resolve issues I also have to balance this with
-my other obligations.  I check and respond to github issues **once
-per week** (on Mondays). So if you don't get a response right away
-don't worry, I will definitely get to it.
+my other obligations.  If you don't get a response right away
+don't worry, I will definitely get to it. Also you can join the
+Gitter [chat room](https://gitter.im/begriffs/postgrest) to
+discuss issues you are having.
@@ -1,9 +1,10 @@
 ![Logo](static/logo.png "Logo")

-[![Build Status](https://circleci.com/gh/begriffs/postgrest.png?circle-token=f723c01686abf0364de1e2eaae5aff1f68bd3ff2)](https://circleci.com/gh/begriffs/postgrest/tree/master)
+[![Build Status](https://circleci.com/gh/begriffs/postgrest.png?style=shield&circle-token=f723c01686abf0364de1e2eaae5aff1f68bd3ff2)](https://circleci.com/gh/begriffs/postgrest/tree/master)
 <a href="https://heroku.com/deploy?template=https://github.com/begriffs/postgrest">
-  <img src="static/heroku.png" alt="Deploy">
+  <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)

 PostgREST serves a fully RESTful API from any existing PostgreSQL
 database. It provides a cleaner, more standards-compliant, faster
@@ -20,7 +21,7 @@ your own projects.

 ### Usage

-Download the binary ([OS X](http://bin.begriffs.com/dbapi/osx/postgrest-0.2.9.0.tar.xz) / [Linux](http://bin.begriffs.com/dbapi/heroku/postgrest-0.2.9.0.tar.xz)) and invoke like so:
+Download the binary ([latest release](https://github.com/begriffs/postgrest/releases/latest)) and invoke like so:

 ```bash
 postgrest  --db-host localhost  --db-port 5432     \
@@ -75,12 +76,14 @@ Other optimizations are possible, and some are outlined in the

 ### Security

-PostgREST handles authentication (HTTP Basic over SSL) and delegates
-authorization to the role information defined in the database. This
-ensures there is a single declarative source of truth for security.
-When dealing with the database the server assumes the identity of
-the currently authenticated user, and for the duration of the
-connection cannot do anything the user themselves couldn't.
+PostgREST handles authentication (HTTP Basic over SSL or [JSON Web
+Tokens](https://github.com/begriffs/postgrest/wiki/Security-and-Permissions#json-web-tokens))
+and delegates authorization to the role information defined in the
+database. This ensures there is a single declarative source of truth
+for security.  When dealing with the database the server assumes
+the identity of the currently authenticated user, and for the
+duration of the connection cannot do anything the user themselves
+couldn't.

 Postgres 9.5 will soon support true [row-level
 security](http://michael.otacoo.com/postgresql-2/postgres-9-5-feature-highlight-row-level-security/).
@@ -154,13 +157,21 @@ and the [guide to routing](https://github.com/begriffs/postgrest/wiki/Routing).
 * [Performance](https://github.com/begriffs/postgrest/wiki/Performance-and-Scaling)
 * [Security](https://github.com/begriffs/postgrest/wiki/Security-and-Permissions)
 * [Tutorial](http://blog.jonharrington.org/postgrest-introduction/) (external)
+* [Heroku](https://github.com/begriffs/postgrest/wiki/Heroku)

 ### Thanks

+* [Ruslan Talpa](https://github.com/ruslantalpa) for rewriting the
+  route parsing and query generation code to support resource embedding
 * [Adam Baker](https://github.com/adambaker) for code
  contributions and many fundamental design discussions
+* [Diogo Biazus](https://github.com/diogob) for many improvements
+  and deep postgresql knowledge
 * [Nikita Volkov](https://github.com/nikita-volkov) for writing the
  wonderful [Hasql](https://github.com/nikita-volkov/hasql) library
  and helping me use it
 * [Mikey Casalaina](https://github.com/casalaina) for the cool logo
-* [Jonathan Harrington](https://github.com/prio) for writing a nice tutorial
+* [Jonathan Harrington](https://github.com/prio) for writing a [nice
+  tutorial](http://blog.jonharrington.org/postgrest-introduction/)
+* [Federico Rampazzo](https://github.com/framp) for suggesting and
+  implementing [JWT](http://jwt.io/) support
@@ -10,7 +10,7 @@
    },
    "POSTGREST_VER": {
      "description": "Version of PostgREST to deploy",
-      "value": "0.2.9.0"
+      "value": "0.2.12.0"
    },
    "DB_NAME": {
      "description": "Database name",
@@ -41,6 +41,16 @@
      "description": "Maximum number of connections in database pool",
      "required": false,
      "value": "10"
+    },
+    "JWT_SECRET": {
+      "description": "Secret used to encrypt JSON Web Tokens",
+      "required": false,
+      "value": "secret"
+    },
+    "V1SCHEMA": {
+      "description": "DB schema selected whe no version (or version 1) requested",
+      "required": false,
+      "value": "1"
    }
  }
 }
@@ -0,0 +1,52 @@
+# TODO list to build debian "official" package
+
+  It feels for free to modify, fix or take some task or all. 
+  
+## debian/control
+
+* Fill description field
+* Add Vcs-Browser
+* Add Vcs-Git
+* Add Uploaders field
+
+## debian/copyright 
+
+* Add more contributers 
+
+## Dependencies packages
+
+Some libraries dependencies aren't Debian package. Below is the list was built by [cabal-debian](https://wiki.debian.org/Haskell/CollabMaint/GettingStarted). These libraries are necessary to build Postgrest the right way. 
+
+* libghc-base64-string-dev
+* libghc-base64-string-prof
+* libghc-bcrypt-dev
+* libghc-bcrypt-prof
+* libghc-hasql-dev
+* libghc-hasql-prof
+* libghc-hasql-backend-dev
+* libghc-hasql-backend-prof
+* libghc-hasql-postgres-dev
+* libghc-hasql-postgres-prof
+* libghc-string-conversions-dev
+* libghc-string-conversions-prof
+* libghc-wai-cors-dev
+* libghc-wai-cors-prof
+* libghc-wai-middleware-static-dev
+* libghc-wai-middleware-static-prof
+* libghc-hasql-dev
+* libghc-hasql-backend-dev
+* libghc-hasql-postgres-dev
+* libghc-heredoc-dev
+* libghc-hspec-wai-dev
+* libghc-hspec-wai-json-dev
+* libghc-http-media-dev
+* libghc-packdeps-dev
+* libghc-base64-string-doc
+* libghc-bcrypt-doc
+* libghc-hasql-doc
+* libghc-hasql-backend-doc
+* libghc-hasql-postgres-doc
+* libghc-string-conversions-doc
+* libghc-wai-cors-doc
+* libghc-wai-middleware-static-doc
+
@@ -0,0 +1,5 @@
+haskell-postgrest (0.2.11.1-1) UNRELEASED; urgency=low
+
+  * Initial release
+
+ -- Debian Haskell Group <pkg-haskell-maintainers@lists.alioth.debian.org>  Wed, 30 Sep 2015 18:52:46 +0000
@@ -0,0 +1 @@
+9
@@ -0,0 +1,196 @@
+Source: haskell-postgrest
+Maintainer: Debian Haskell Group <pkg-haskell-maintainers@lists.alioth.debian.org>
+Priority: extra
+Section: haskell
+Build-Depends: debhelper (>= 9),
+ haskell-devscripts (>= 0.8),
+ cdbs,
+ ghc,
+ ghc-prof,
+ libghc-http-dev,
+ libghc-http-prof,
+ libghc-missingh-dev,
+ libghc-missingh-prof,
+ libghc-ranged-sets-dev,
+ libghc-ranged-sets-prof,
+ libghc-aeson-dev,
+ libghc-aeson-prof,
+ libghc-base64-string-dev,
+ libghc-base64-string-prof,
+ libghc-bcrypt-dev,
+ libghc-bcrypt-prof,
+ libghc-blaze-builder-dev,
+ libghc-blaze-builder-prof,
+ libghc-case-insensitive-dev,
+ libghc-case-insensitive-prof,
+ libghc-cassava-dev,
+ libghc-cassava-prof,
+ libghc-convertible-dev,
+ libghc-convertible-prof,
+ libghc-hasql-dev,
+ libghc-hasql-prof,
+ libghc-hasql-backend-dev,
+ libghc-hasql-backend-prof,
+ libghc-hasql-postgres-dev,
+ libghc-hasql-postgres-prof,
+ libghc-http-types-dev,
+ libghc-http-types-prof,
+ libghc-jwt-dev,
+ libghc-jwt-prof,
+ libghc-mtl-dev,
+ libghc-mtl-prof,
+ libghc-network-dev,
+ libghc-network-prof,
+ libghc-network-uri-dev,
+ libghc-network-uri-prof,
+ libghc-optparse-applicative-dev,
+ libghc-optparse-applicative-prof,
+ libghc-regex-base-dev,
+ libghc-regex-base-prof,
+ libghc-regex-tdfa-dev,
+ libghc-regex-tdfa-prof,
+ libghc-resource-pool-dev,
+ libghc-resource-pool-prof,
+ libghc-scientific-dev,
+ libghc-scientific-prof,
+ libghc-split-dev,
+ libghc-split-prof,
+ libghc-string-conversions-dev,
+ libghc-string-conversions-prof,
+ libghc-stringsearch-dev,
+ libghc-stringsearch-prof,
+ libghc-text-dev,
+ libghc-text-prof,
+ libghc-unordered-containers-dev,
+ libghc-unordered-containers-prof,
+ libghc-vector-dev,
+ libghc-vector-prof,
+ libghc-wai-dev,
+ libghc-wai-prof,
+ libghc-wai-cors-dev,
+ libghc-wai-cors-prof,
+ libghc-wai-extra-dev,
+ libghc-wai-extra-prof,
+ libghc-wai-middleware-static-dev,
+ libghc-wai-middleware-static-prof,
+ libghc-warp-dev,
+ libghc-warp-prof,
+ libghc-aeson-dev (>= 0.8),
+ libghc-bcrypt-dev (>= 0.0.6),
+ libghc-hasql-dev (>= 0.7.3),
+ libghc-hasql-dev (<< 0.8),
+ libghc-hasql-backend-dev (>= 0.4.1),
+ libghc-hasql-backend-dev (<< 0.5),
+ libghc-hasql-postgres-dev (>= 0.10.4),
+ libghc-hasql-postgres-dev (<< 0.11),
+ libghc-network-dev (>= 2.6),
+ libghc-network-uri-dev (>= 2.6),
+ libghc-optparse-applicative-dev (>= 0.11),
+ libghc-optparse-applicative-dev (<< 0.12),
+ libghc-wai-dev (>= 3.0.1),
+ libghc-wai-middleware-static-dev (>= 0.6.0),
+ libghc-warp-dev (>= 3.0.2),
+ libghc-quickcheck2-dev,
+ libghc-heredoc-dev,
+ libghc-hlint-dev,
+ libghc-hspec-dev (>= 2.1),
+ libghc-hspec-dev (<< 2.2),
+ libghc-hspec-wai-dev,
+ libghc-hspec-wai-json-dev,
+ libghc-http-media-dev,
+ libghc-packdeps-dev,
+Build-Depends-Indep: ghc-doc,
+ libghc-http-doc,
+ libghc-missingh-doc,
+ libghc-ranged-sets-doc,
+ libghc-aeson-doc,
+ libghc-base64-string-doc,
+ libghc-bcrypt-doc,
+ libghc-blaze-builder-doc,
+ libghc-case-insensitive-doc,
+ libghc-cassava-doc,
+ libghc-convertible-doc,
+ libghc-hasql-doc,
+ libghc-hasql-backend-doc,
+ libghc-hasql-postgres-doc,
+ libghc-http-types-doc,
+ libghc-jwt-doc,
+ libghc-mtl-doc,
+ libghc-network-doc,
+ libghc-network-uri-doc,
+ libghc-optparse-applicative-doc,
+ libghc-regex-base-doc,
+ libghc-regex-tdfa-doc,
+ libghc-resource-pool-doc,
+ libghc-scientific-doc,
+ libghc-split-doc,
+ libghc-string-conversions-doc,
+ libghc-stringsearch-doc,
+ libghc-text-doc,
+ libghc-unordered-containers-doc,
+ libghc-vector-doc,
+ libghc-wai-doc,
+ libghc-wai-cors-doc,
+ libghc-wai-extra-doc,
+ libghc-wai-middleware-static-doc,
+ libghc-warp-doc,
+Standards-Version: 3.9.6
+Homepage: https://github.com/begriffs/postgrest
+Description: REST API for any Postgres database
+ Reads the schema of a PostgreSQL database and creates RESTful routes
+ for the tables and views, supporting all HTTP verbs that security
+ permits.
+
+Package: libghc-postgrest-dev
+Architecture: any
+Depends: ${haskell:Depends},
+ ${misc:Depends},
+ ${shlibs:Depends},
+Recommends: ${haskell:Recommends},
+Suggests: ${haskell:Suggests},
+Conflicts: ${haskell:Conflicts},
+Provides: ${haskell:Provides},
+Description: ${haskell:ShortDescription}${haskell:ShortBlurb}
+ ${haskell:LongDescription}
+ .
+ ${haskell:Blurb}
+
+Package: libghc-postgrest-prof
+Architecture: any
+Depends: ${haskell:Depends},
+ ${misc:Depends},
+Recommends: ${haskell:Recommends},
+Suggests: ${haskell:Suggests},
+Conflicts: ${haskell:Conflicts},
+Provides: ${haskell:Provides},
+Description: ${haskell:ShortDescription}${haskell:ShortBlurb}
+ ${haskell:LongDescription}
+ .
+ ${haskell:Blurb}
+
+Package: libghc-postgrest-doc
+Architecture: all
+Section: doc
+Depends: ${haskell:Depends},
+ ${misc:Depends},
+Recommends: ${haskell:Recommends},
+Suggests: ${haskell:Suggests},
+Conflicts: ${haskell:Conflicts},
+Description: ${haskell:ShortDescription}${haskell:ShortBlurb}
+ ${haskell:LongDescription}
+ .
+ ${haskell:Blurb}
+
+Package: haskell-postgrest-utils
+Architecture: any
+Section: misc
+Depends: ${haskell:Depends},
+ ${misc:Depends},
+Recommends: ${haskell:Recommends},
+Suggests: ${haskell:Suggests},
+Conflicts: ${haskell:Conflicts},
+Provides: ${haskell:Provides},
+Description: ${haskell:ShortDescription}${haskell:ShortBlurb}
+ ${haskell:LongDescription}
+ .
+ ${haskell:Blurb}
@@ -0,0 +1,32 @@
+Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: postgrest
+Upstream-Contact: Joe Nelson <joe@begriffs.com>
+Source: https://hackage.haskell.org/package/postgrest
+
+Files: *
+Copyright: 2014-2015 Joe Nelson <joe@begriffs.com>
+License: Expat
+
+Files: debian/*
+Copyright: 2015 Fernando Ike <fike@midstorm.org>
+License: Expat
+
+License: Expat
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+ .
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+ .
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@@ -0,0 +1 @@
+dist-ghc/build/postgrest/postgrest usr/bin
@@ -0,0 +1,8 @@
+#!/bin/sh
+d=$(dirname $0)
+if [ -f /etc/default/postgrest ]; then
+	. /etc/default/postgrest
+fi
+POSTGREST_LOG=${POSTGREST_LOG:-/var/log/postgrest/postgrest.log}
+
+exec $d/postgrest "$@" >>$POSTGREST_LOG 2>&1 &
@@ -0,0 +1,23 @@
+# run service as
+#POSTGREST_USER=postgrest
+
+# log file
+#POSTGREST_LOG=/var/log/postgrest/postgrest.log
+
+# database host
+#POSTGREST_DBHOST=localhost
+
+# database to use
+#POSTGREST_DBNAME=
+
+# database user
+#POSTGREST_DBUSER=postgres
+
+# database password
+#POSTGREST_DBPASS=
+
+# database pool
+#POSTGREST_DBPOOL=10
+
+# additional options
+#POSTGREST_OPTS=
@@ -0,0 +1,78 @@
+#!/bin/sh
+### BEGIN INIT INFO
+# Provides:          postgrest
+# Required-Start:    $local_fs $network postgresql
+# Required-Stop:     $local_fs $network 
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Description:       PostgreSQL REST API daemon
+### END INIT INFO
+ 
+. /lib/lsb/init-functions
+if test -f /etc/default/postgrest; then
+    . /etc/default/postgrest
+fi
+POSTGREST=/usr/local/bin/postgrest
+POSTGREST_USER=${POSTGREST_USER:-postgrest}
+POSTGREST_DBNAME=${POSTGREST_DBNAME:-postgres}
+POSTGREST_DBUSER=${POSTGREST_DBUSER:-postgres}
+if [ -n "$POSTGREST_DBHOST" ]; then
+	POSTGREST_OPTS="$POSTGREST_OPTS --db-host $POSTGREST_DBHOST"
+fi
+if [ -n "$POSTGREST_DBNAME" ]; then
+	POSTGREST_OPTS="$POSTGREST_OPTS --db-name $POSTGREST_DBNAME"
+fi
+if [ -n "$POSTGREST_DBUSER" ]; then
+	POSTGREST_OPTS="$POSTGREST_OPTS --db-user $POSTGREST_DBUSER"
+	POSTGREST_OPTS="$POSTGREST_OPTS --anonymous $POSTGREST_DBUSER"
+fi
+if [ -n "$POSTGREST_DBPASS" ]; then
+	POSTGREST_OPTS="$POSTGREST_OPTS --db-pass $POSTGREST_DBPASS"
+fi
+if [ -n "$POSTGREST_DBPOOL" ]; then
+	POSTGREST_OPTS="$POSTGREST_OPTS --db-pool $POSTGREST_DBPOOL"
+fi
+POSTGREST_OPTS="$POSTGREST_OPTS --v1schema public"
+ 
+start()
+{
+	log_daemon_msg "Starting PostgreSQL REST API daemon" "postgrest" || true
+	if start-stop-daemon --start --quiet --oknodo --chuid ${POSTGREST_USER} --startas /usr/local/bin/postgrest-wrapper --exec $POSTGREST -- $POSTGREST_OPTS; then
+		log_end_msg 0 || true
+	else
+		log_end_msg 1 || true
+	fi
+}
+ 
+stop()
+{
+	log_daemon_msg "Stopping PostgreSQL REST API daemon" "postgrest" || true
+	if start-stop-daemon --stop --quiet --oknodo --exec $POSTGREST; then
+		log_end_msg 0 || true
+	else
+		log_end_msg 1 || true
+	fi
+}
+ 
+status()
+{
+	status_of_proc $POSTGREST postgrest && exit 0 || exit $?
+}
+
+case "$1" in
+start)
+	start
+	;;
+stop)
+	stop
+	;;
+restart)
+	stop
+	start
+	;;
+status)
+	status
+	;;
+*)
+	echo "Usage: $0 {start|stop|restart|status}"
+esac
@@ -0,0 +1,10 @@
+#!/usr/bin/make -f
+
+DEB_ENABLE_TESTS = yes
+DEB_CABAL_PACKAGE = postgrest
+DEB_DEFAULT_COMPILER = ghc
+
+include /usr/share/cdbs/1/rules/debhelper.mk
+include /usr/share/cdbs/1/class/hlibrary.mk
+
+build/haskell-postgrest-utils:: build-ghc-stamp
@@ -0,0 +1 @@
+3.0 (quilt)
@@ -0,0 +1,2 @@
+version=3
+http://hackage.haskell.org/package/postgrest/distro-monitor .*-([0-9\.]+)\.(?:zip|tgz|tbz|txz|(?:tar\.(?:gz|bz2|xz)))
@@ -0,0 +1 @@
+postgrest.com
@@ -0,0 +1,9 @@
+## Deployment
+
+### Heroku
+
+#### Getting Started
+
+#### Using Amazon RDS
+
+### Debian
@@ -0,0 +1,9 @@
+## Data Migration
+
+### Sqitch
+
+### Test-Driven Migrations
+
+#### Structural Tests
+
+#### Value Tests with pgTAP
@@ -0,0 +1,9 @@
+## Performance
+
+### Benchmarks
+
+### Caching
+
+### Quality of Service
+
+### Tips
@@ -0,0 +1,21 @@
+## Security
+
+### SSL
+
+### Database Roles
+
+### JSON Web Tokens
+
+#### Issuing via sql procedures
+
+### Row-Level Security
+
+#### Simulated - PostgreSQL <9.5
+
+#### Real - PostgreSQL >=9.5
+
+### Building Auth on top of JWT
+
+#### Basic Auth
+
+#### Github Sign-in
@@ -0,0 +1,9 @@
+## API Versioning
+
+### Schema Search Path
+
+### Changing a Resource
+
+### Removing a Resource
+
+### Avoiding DB and Client Coupling
@@ -0,0 +1,296 @@
+## Requesting Information
+
+### Tables and Views
+
+* ✅ Cacheable, prefetchable
+* ✅ Idempotent
+
+The list of accessible tables and views is provided at
+
+```HTTP
+GET /
+```
+
+Every view and table accessible by the active db role is exposed
+in a one-level deep route. For instance the full contents of a table
+`people` is returned at
+
+```HTTP
+GET /people
+```
+
+There are no `deeply/nested/routes`. Each route provides `OPTIONS`,
+`GET`, `POST`, `PUT`, `PATCH`, and `DELETE` verbs depending entirely
+on database permissions.
+
+<div class="admonition note">
+  <p class="admonition-title">Design Consideration</p>
+
+  <p>Why not provide nested routes? Many APIs allow nesting to
+  retrieve related information, such as <code>/films/1/director</code>.
+  We offer a more flexible mechanism instead to embed related
+  information, including many-to-many relationships. This is covered
+  in the section about Embedding.</p>
+</div>
+
+### Stored Procedures
+
+* ❌ Cannot necessarily be cached or prefetched
+* ❌ Not necessarily idempotent
+
+Every stored procedure is accessible under the `/rpc` prefix. The
+API endpoint supports only POST which executes the function.
+
+```HTTP
+POST /rpc/proc_name
+```
+
+PostgREST supports calling procedures with [named
+arguments](http://www.postgresql.org/docs/9.4/static/sql-syntax-calling-funcs.html#SQL-SYNTAX-CALLING-FUNCS-NAMED).
+To do so include a JSON object in the request payload and each
+key/value of the object will become an argument.
+
+<div class="admonition note">
+  <p class="admonition-title">Design Consideration</p>
+
+  <p>Why the /rpc prefix? One reason is to avoid name collisions
+  between views and procedures. It also helps emphasize to API
+  consumers that these functions are not normal restful things.
+  The functions can have arbitrary and surprising behavior, not
+  the standard "post creates a resource" thing that users expect
+  from the other routes.</p>
+
+  <p>We considered allowing GET requests for functions that are
+  marked non-volatile but could not reconcile how to pass in
+  parameters. Query string arguments are reserved for shaping/filtering
+  the output, not providing input.</p>
+</div>
+
+
+
+### Filtering
+
+#### Filtering Rows
+
+You can filter result rows by adding conditions on columns, each
+condition a query string parameter.  For instance, to return people
+aged under 13 years old:
+
+```HTTP
+GET /people?age=lt.13
+```
+
+Adding multiple parameters conjoins the conditions:
+
+```HTTP
+GET /people?age=gte.18&student=is.true
+```
+
+These operators are available:
+
+abbreviation | meaning
+------------ | -------
+eq           | equals
+gt           | greater than
+lt           | less than
+gte          | greater than or equal
+lte          | less than or equal
+like         | LIKE operator (use * in place of %)
+ilike        | ILIKE operator (use * in place of %)
+@@           | full-text search using to_tsquery
+is           | checking for exact equality (null,true,false)
+in           | one of a list of values e.g. `?a=in.1,2,3`
+not          | negates another operator, see below
+
+To negate any operator, prefix it with `not` like `?a=not.eq.2`.
+
+For more complicated filters (such as those involving condition 1
+*OR* condition 2) you will have to create a new view in the database.
+
+Filters may be applied to [computed
+columns](http://www.postgresql.org/docs/current/interactive/xfunc-sql.html#XFUNC-SQL-COMPOSITE-FUNCTIONS)
+as well as actual table/view columns, even though the computed
+columns will not appear in the output.
+
+#### Filtering Columns
+
+You can customize which columns are returned by using the `select`
+parameter:
+
+```HTTP
+GET /people?select=age,height,weight
+```
+
+To cast the column types, add a double colon
+
+```HTTP
+GET /people?select=age::text,height,weight
+```
+
+Not all type coercions are possible, and you will get an error
+describing any problems from selection or type casting.
+
+The `select` keyword is reserved. You thus cannot filter rows based
+on a column named select. Then again it is a reserved SQL keyword
+too, hence an unlikely column name.
+
+#### Inside JSONB
+
+PostgreSQL >=9.4.2 supports native JSON columns and can even index
+them by internal keys using the `jsonb` column type. PostgREST
+allows you to filter results by internal JSON object values. Use
+the single- and double-arrows to path into and obtain values, e.g.
+
+```HTTP
+GET /stuff?json_col->a->>b=eq.2
+```
+
+This query finds rows in `stuff` where `json_col->'a'->>'b'` is
+equal to 2 (or "2" -- it coerces as needed). The final arrow must
+be the double kind, `->>`, or else PostgREST will not attempt to
+look inside the JSON.
+
+### Ordering
+
+The reserved word `order` reorders the response rows.  It uses a
+comma-separated list of columns and directions:
+
+```HTTP
+GET /people?order=age.desc,height.asc
+```
+
+If no direction is specified it defaults to descending order:
+
+```HTTP
+GET /people?order=age
+```
+
+If you care where nulls are sorted, add `nullsfirst` or `nullslast`:
+
+```HTTP
+GET /people?order=age.nullsfirst
+```
+
+### Limiting and Pagination
+
+#### Pagination by Limit-Offset
+
+PostgREST uses HTTP range headers for limiting and describing the
+size of results. Every response contains the current range and total
+results:
+
+```
+Range-Unit: items
+Content-Range → 0-14/15
+```
+
+This means items zero through fourteen are returned out of a total
+of fifteen -- i.e. all of them. This information is available in
+every response and can help you render pagination controls on the
+client. This is a RFC7233-compliant solution that keeps the response
+JSON cleaner.
+
+The client can set the limit and offset of a request by setting the
+`Range` header. Translate the limit and offset into a range. To
+request the first five elements, include these request headers:
+
+```
+Range-Unit: items
+Range: 0-4
+```
+
+You can also use open-ended ranges for an offset with no limit:
+`Range: 10-`.
+
+#### Suppressing Counts
+
+Sometimes knowing the total row count of a query is unnecessary and
+only adds extra cost to the database query. So you can skip the
+count total using a ```Prefer``` header as:
+
+```
+Prefer: count=none
+```
+
+So the PostgREST response will be something like:
+
+```
+Range-Unit: items
+Content-Range → 0-14/*
+```
+
+### Embedding Foreign Entities
+
+Suppose you have a `projects` table which references `clients` through
+a foreign key called `client_id`. When listing projects through the
+API you can have it embed the client within each project response.
+For example,
+
+```HTTP
+GET /projects?id=eq.1&select=id, name, clients(*)
+```
+
+Notice this is the same `select` keyword which is used to choose
+which columns to include. When a column name is followed by parentheses
+that means to fetch the entire record and nest it. You include a
+list of columns inside the parens, or asterisk to request all
+columns.
+
+The embedding works for 1-N, N-1, and N-N relationships. That means
+you could also ask for a client and all their projects:
+
+```HTTP
+GET /clients?id=eq.42&select=id, name, projects(*)
+```
+
+### Response Format
+
+Query responses default to JSON but you can get them in CSV as well. Just make your request with the header
+
+```HTTP
+Accept: text/csv
+```
+
+### Singular vs Plural
+
+Many APIs distinguish plural and singular resources, e.g.`/stories`
+vs `/stories/1`. Why do we use `/stories?id=eq.1`? It is because a
+single resource is for us a row determined by a primary key, and
+primary keys can be *compound* (meaning defined across more than
+one column). The common urls come from a degenerate case of simple
+(and overwhelmingly numeric) primary keys often introduced automatically
+be Object Relational Mapping.
+
+For consistency's sake all these endpoints return a JSON array,
+`/stories`, `/stories?genre=eq.mystery`, `/stories?id=eq.1`. They
+are all filtering a bigger array. However you might want the
+last one to return a single JSON object, not an array with one
+element. There is currently an open issue to enable this.
+
+### Data Schema
+
+As well as issuing a `GET /` to obtain a list of the tables, views,
+and stored procedures available, you can get more information about
+any particular endpoint.
+
+```HTTP
+OPTIONS /my_view
+```
+
+This will include the row names, their types, primary key
+information, and foreign keys for the given table or view.
+
+<div class="admonition danger">
+    <p class="admonition-title">Deprecation Warning</p>
+
+    <p>Although we currently use the OPTIONS verb for this, some
+    people <a
+    href="https://www.mnot.net/blog/2012/10/29/NO_OPTIONS">argue</a> that
+    this is inappropriate. We are considering a <code>describedby</code>
+    header link instead.</p>
+</div>
+
+### CORS
+
+PostgREST sets highly permissive cross origin resource sharing.  It
+accepts Ajax requests from any domain.
@@ -0,0 +1,131 @@
+## Updating Data
+
+### Record Creation
+
+* ❌ Cannot be cached or prefetched
+* ❌ Not idempotent
+
+To create a row in a database table post a JSON object whose keys
+are the names of the columns you would like to create. Missing keys
+will be set to default values when applicable.
+
+```HTTP
+POST /table_name
+{ "col1": "value1", "col2": "value2" }
+```
+
+The response will include a `Location` header describing where to
+find the new object. If you would like to get the full object back
+in the response to your request, include the header `Prefer:
+return=representation`. That way you won't have to make another
+HTTP call to discover properties that may have been filled in on
+the server side.
+
+### Bulk Insertion
+
+* ❌ Cannot be cached or prefetched
+* ❌ Not idempotent
+
+While regular insertion uses JSON to encode the value, bulk insertion
+uses CSV. Simply post to a table route with `Content-Type: text/csv`
+and include the names of the columns as the first row. For instance
+
+```HTTP
+POST /people
+name,age,height
+J Doe,62,70
+Jonas,10,55
+```
+
+An empty field (`,,`) is coerced to an empty string and the reserved
+word `NULL` is mapped to the SQL null value. Note that there should
+be no spaces between the column names and commas.
+
+The server sends a multipart response for bulk insertions. Each part
+contains a Location header with URL of each created resource.
+
+```HTTP
+Content-Type: application/json
+Location: /festival?name=eq.Venice%20Film%20Festival
+
+
+--postgrest_boundary
+Content-Type: application/json
+Location: /festival?name=eq.Cannes%20Film%20Festival
+```
+
+### Upsertion
+
+* ❌ Cannot be cached or prefetched
+* ✅ Idempotent
+
+To insert or update a single row use the `PUT` verb on a properly
+filtered table url:
+
+```HTTP
+PUT /table_name?primary_key=eq.foo
+{ "col1": "value1", "col2": "value2" }
+```
+
+The request must satisfy two things. First all columns must be
+specified (because a default value might be a changing value which
+would violate idempotence). Second the URL must match the URL you
+would use to get the value of the resource. This means that all
+primary key columns must be included in the filter (there are more
+than one when the primary key is compound).
+
+If you would like to get the full object back in the response to
+your request, include the header `Prefer: return=representation`.
+It will of match exactly the object you sent though.
+
+### Bulk Updates
+
+* ❌ Cannot be cached or prefetched
+* ❌ Not idempotent
+
+To change parts of a resource or resources use the `PATCH` verb.
+For instance, here is how to mark all young people as children.
+
+```HTTP
+PATCH /people?age=lt.13
+{
+  "person_type": "child"
+}
+```
+
+This affects any rows matched by the url param filters, overwrites
+any fields specified in in the payload JSON and leaves the other
+fields unaffected. Note that although the payload is not in the
+JSON patch format specified by
+[RFC6902](https://tools.ietf.org/html/rfc6902), HTTP does not specify
+which patch format to use. Our format is more pleasant, meant for
+basic field replacements, and not at all "incorrect."
+
+### Deletion
+
+* ❌ Cannot be cached or prefetched
+* ✅ Idempotent
+
+Simply use the `DELETE` verb. All recors that match your filter
+will be removed. For instance deleting inactive users:
+
+```HTTP
+DELETE /user?active=eq.false
+```
+
+### Protecting Dangerous Actions
+
+Notice that it is very easy to delete or update many records at
+once. In fact forgetting a filter will affect an entire table!
+
+
+<div class="admonition warning">
+    <p class="admonition-title">Invitation to Contribute</p>
+
+    <p>We would like to investigate nginx rules to guard dangerous
+    actions, perhaps requiring a confirmation header or query param
+    to perform the action.</p>
+
+    <p>You're invited to research this option and contribute to
+    this documentation.</p>
+</div>
@@ -0,0 +1,346 @@
+## Getting Started
+
+### Your First (simple) API
+
+Let's start with the simplest thing possible. We will expose some tables directly for reading and writing by anyone.
+
+Start by making a database
+
+```sh
+createdb demo1
+```
+
+We'll set it up with a film example (courtesy of [Jonathan Harrington](http://blog.jonharrington.org/postgrest-introduction/)). Copy the following into your clipboard:
+
+```sql
+BEGIN;
+
+CREATE TABLE director
+(
+  name text NOT NULL PRIMARY KEY
+);
+
+CREATE TABLE film
+(
+  id serial PRIMARY KEY,
+  title text NOT NULL,
+  year date NOT NULL,
+  director text,
+  rating real NOT NULL DEFAULT 0,
+  language text NOT NULL,
+  CONSTRAINT film_director_fkey FOREIGN KEY (director)
+      REFERENCES director (name) MATCH SIMPLE
+      ON UPDATE CASCADE ON DELETE CASCADE
+);
+
+CREATE TABLE festival
+(
+  name text NOT NULL PRIMARY KEY
+);
+
+CREATE TABLE competition
+(
+  id serial PRIMARY KEY,
+  name text NOT NULL,
+  festival text NOT NULL,
+  year date NOT NULL,
+
+  CONSTRAINT comp_festival_fkey FOREIGN KEY (festival)
+      REFERENCES festival (name) MATCH SIMPLE
+      ON UPDATE CASCADE ON DELETE CASCADE
+);
+
+CREATE TABLE film_nomination
+(
+  id serial PRIMARY KEY,
+  competition integer NOT NULL,
+  film integer NOT NULL,
+  won boolean NOT NULL DEFAULT true,
+
+  CONSTRAINT nomination_competition_fkey FOREIGN KEY (competition)
+     REFERENCES competition (id) MATCH SIMPLE
+     ON UPDATE NO ACTION ON DELETE NO ACTION,
+  CONSTRAINT nomination_film_fkey FOREIGN KEY (film)
+     REFERENCES film (id) MATCH SIMPLE
+     ON UPDATE CASCADE ON DELETE CASCADE
+);
+
+COMMIT;
+```
+
+Apply it to your new database by running
+
+```sh
+# On OS X
+pbpaste | psql demo1
+
+# Or Linux
+# xclip -selection clipboard -o | psql demo1
+```
+
+Start the PostgREST server and point it at the new database.
+
+```sh
+postgrest -d demo1 -U postgres -a postgres --v1schema public
+```
+
+<div class="admonition note">
+    <p class="admonition-title">Note about database users</p>
+
+    <p>If you installed PostgreSQL with Homebrew on Mac then the
+    database username may be your own login rather than
+    <code>postgres</code>.</p>
+</div>
+
+Let's use PostgREST to populate the database. Install a REST client such as [Postman](https://chrome.google.com/webstore/detail/postman/fhbjgbiflinjbdggehcddcbncdddomop?hl=en). Now let's insert some data as a bulk post in CSV format:
+
+```HTTP
+POST http://localhost:3000/festival
+Content-Type: text/csv
+
+name
+Venice Film Festival
+Cannes Film Festival
+```
+
+In Postman it will look like this
+
+![Festival bulk insert in postman](/img/post-festivals.png)
+
+Notice that the post type is `raw` and that `Content-Type: text/csv` set in the Headers tab. 
+
+Note that the server returns a multipart response with URL of each created resource.
+
+```HTTP
+Content-Type: application/json
+Location: /festival?name=eq.Venice%20Film%20Festival
+
+
+--postgrest_boundary
+Content-Type: application/json
+Location: /festival?name=eq.Cannes%20Film%20Festival
+```
+
+If you send a GET request to `/festival` it should return
+
+```json
+[
+  {
+    "name": "Venice Film Festival"
+  },
+  {
+    "name": "Cannes Film Festival"
+  }
+]
+```
+
+Now that you've seen how to do a bulk insert, let's do some more and fully populate the database.
+
+Post the following to `/competition`:
+
+```csv
+name,festival,year
+Golden Lion,Venice Film Festival,2014-01-01
+Palme d'Or,Cannes Film Festival,2014-01-01
+```
+
+Now `/director`:
+
+```csv
+name
+Bertrand Bonello
+Atom Egoyan
+David Gordon Green
+Andrey Konchalovskiy
+Mario Martone
+Mike Leigh
+Roy Andersson
+Saverio Costanzo
+Alix Delaporte
+Jean-Pierre Dardenne
+Xiaoshuai Wang
+Kaan Müjdeci
+Tommy Lee Jones
+Nuri Bilge Ceylan
+Michel Hazanavicius
+Xavier Dolan
+Ramin Bahrani
+Alice Rohrwacher
+Andrew Niccol
+Rakhshan Bani-Etemad
+David Oelhoffen
+Bennett Miller
+David Cronenberg
+Shin'ya Tsukamoto
+Joshua Oppenheimer
+Olivier Assayas
+Jean-Luc Godard
+Alejandro González Iñárritu
+Benoît Jacquot
+Fatih Akin
+Francesco Munzi
+Ken Loach
+Abel Ferrara
+Xavier Beauvois
+Naomi Kawase
+```
+
+And `/film`:
+
+```csv
+title,year,director,rating,language
+Chuang ru zhe,2014-01-01,Xiaoshuai Wang,6.19999981,english
+The Look of Silence,2014-01-01,Joshua Oppenheimer,8.30000019,Indonesian
+Fires on the Plain,2014-01-01,Shin'ya Tsukamoto,5.80000019,Japanese
+Far from Men,2014-01-01,David Oelhoffen,7.5,english
+Good Kill,2014-01-01,Andrew Niccol,6.0999999,english
+Leopardi,2014-01-01,Mario Martone,6.9000001,english
+Sivas,2014-01-01,Kaan Müjdeci,7.69999981,english
+Black Souls,2014-01-01,Francesco Munzi,7.0999999,english
+Three Hearts,2014-01-01,Benoît Jacquot,5.80000019,French
+Pasolini,2014-01-01,Abel Ferrara,5.80000019,english
+Le dernier coup de marteau,2014-01-01,Alix Delaporte,6.5,english
+Manglehorn,2014-01-01,David Gordon Green,7.0999999,english
+Hungry Hearts,2014-01-01,Saverio Costanzo,6.4000001,English
+Belye nochi pochtalona Alekseya Tryapitsyna,2014-01-01,Andrey Konchalovskiy,6.9000001,Russian
+99 Homes,2014-01-01,Ramin Bahrani,7.30000019,english
+The Cut,2014-01-01,Fatih Akin,6,Armenian
+Birdman: Or (The Unexpected Virtue of Ignorance),2014-01-01,Alejandro González Iñárritu,8,English
+La rançon de la gloire,2014-01-01,Xavier Beauvois,5.69999981,French
+A Pigeon Sat on a Branch Reflecting on Existence,2014-01-01,Roy Andersson,7.19999981,english
+Tales,2014-01-01,Rakhshan Bani-Etemad,6.80000019,english
+The Wonders,2014-01-01,Alice Rohrwacher,6.80000019,Italian
+Foxcatcher,2014-01-01,Bennett Miller,7.19999981,English
+Mr. Turner,2014-01-01,Mike Leigh,7,English
+Jimmy's Hall,2014-01-01,Ken Loach,6.69999981,English
+The Homesman,2014-01-01,Tommy Lee Jones,6.5999999,English
+The Captive,2014-01-01,Atom Egoyan,5.9000001,english
+Goodbye to Language,2014-01-01,Jean-Luc Godard,6.19999981,French
+The Search,2014-01-01,Michel Hazanavicius,6.9000001,French
+Still the Water,2014-01-01,Naomi Kawase,6.9000001,Japanese
+Mommy,2014-01-01,Xavier Dolan,8.30000019,French
+"Two Days, One Night",2014-01-01,Jean-Pierre Dardenne,7.4000001,French
+Maps to the Stars,2014-01-01,David Cronenberg,6.4000001,English
+Saint Laurent,2014-01-01,Bertrand Bonello,6.5,French
+Clouds of Sils Maria,2014-01-01,Olivier Assayas,6.9000001,english
+Winter Sleep,2014-01-01,Nuri Bilge Ceylan,8.5,Turkish
+```
+
+Finally `/film_nomination`:
+
+```csv
+competition,film,won
+1,1,f
+1,2,f
+1,3,f
+1,4,f
+1,5,f
+1,6,f
+1,7,f
+1,8,f
+1,9,f
+1,10,f
+1,11,f
+1,12,f
+1,13,f
+1,14,f
+1,15,f
+1,16,f
+1,17,f
+1,18,f
+1,19,f
+1,20,f
+2,21,f
+2,22,f
+2,23,f
+2,24,f
+2,25,f
+2,26,f
+2,27,f
+2,28,f
+2,29,f
+2,30,f
+2,31,f
+2,32,f
+2,33,f
+2,34,f
+2,35,f
+```
+
+At this point nominations are fully specified but it's not a convenient interface for a rest client. Let's make a view they can use. Paste this into `psql demo1`.
+
+```sql
+create or replace view nomination as
+select comp.festival,  
+       comp.name as competition,
+       comp.year,
+       film.title,
+       film.director,
+       film.rating
+ from film_nomination as nom
+ left join film on nom.film = film.id
+ left join competition as comp on nom.competition = comp.id
+ order by comp.year desc, comp.festival, competition;
+```
+
+Time to try it out. Let's get the contents of the new view, ordered by film rating
+
+```
+GET http://localhost:3000/nomination?order=rating.desc
+```
+
+If you find it more human readable, add an `Accept: text/csv` header.
+
+### Releasing a New Version
+
+Suppose we want this endpoint to cater to those moviegoers with attention deficit disorder. In today's busy world we don't have time to read an extra couple words or compare nuanced reviews. In API version two we will truncate the names and round the ratings!
+
+Each version lives in a numbered schema, so let's make a schema for version two.
+
+```sql
+CREATE SCHEMA "2";
+GRANT USAGE ON SCHEMA "2" TO PUBLIC;
+ALTER DATABASE demo1 SET search_path = "2", "public";
+```
+
+To override the `films` endpoint create a view in the "2" schema with that name:
+
+```sql
+create or replace view "2".film as
+select id, substring(f.title from 1 for 10) as title,
+       year, director, round(f.rating) as rating, language
+from "public".film as f;
+```
+
+We select the desired version as part of content negotiation. Try this get request:
+
+```HTTP
+GET http://localhost:3000/film
+Accept: text/csv; version=2
+```
+
+Then try toggling the version string in the Accept header and watch the results change. Pretty good, now how about writing values? PostgreSQL's nice feature called auto-updatable views allows writes to pass through views. Sadly this view is not eligible because truncation and rounding cannot be uniquely reversed. If we attempt to post a new result it complains:
+
+```json
+{
+  "hint": null,
+  "details": "View columns that are not columns of their base relation are not updatable.",
+  "code": "0A000",
+  "message": "cannot insert into column \"title\" of view \"film\""
+}
+```
+
+This is a case where we need explicit triggers
+
+```sql
+-- TODO - FIX THIS
+
+-- CREATE OR REPLACE RULE insert_v2_films AS
+--   ON INSERT TO "2".film
+--   DO INSTEAD
+--      INSERT INTO public.film (id, title, year, director, rating, language)
+--      VALUES (NEW.id,     NEW.title,
+--              NEW.year,   NEW.director,
+--              NEW.rating, NEW.language)
+--      RETURNING public.film.*;
+```
@@ -0,0 +1,68 @@
+![PostgREST logo](img/logo.png)
+
+## Introduction
+
+PostgREST is a standalone web server that turns your database directly into a RESTful API. The structural constraints and permissions in the database determine the API endpoints and operations.
+
+This guide explains how to install the software and provides practical examples of its use. You'll learn how to build a fast, versioned, secure API and how to deploy it to production.
+
+The project has a friendly and growing community. Here are some ways to get help or get involved:
+
+* The project [chat room](https://gitter.im/begriffs/postgrest)
+* Report or search [issues](https://github.com/begriffs/postgrest/issues)
+
+### Motivation
+
+Using PostgREST is an alternative to manual CRUD programming. Custom API servers suffer problems. Writing business logic often duplicates, ignores or hobbles database structure. Object-relational mapping is a leaky abstraction leading to slow imperative code. The PostgREST philosophy establishes a single declarative source of truth: the data itself.
+
+#### Declarative Programming
+
+It's easier to ask Postgres to join data for you and let its query planner figure out the details than to loop through rows yourself. It's easier to assign permissions to db objects than to add guards in controllers. (This is especially true for cascading permissions in data dependencies.) It's easier set constraints than to litter code with sanity checks.
+
+#### Leakproof Abstraction
+
+There is no ORM involved. Creating new views happens in SQL with known performance implications. A database administrator can now create an API from scratch with no custom programming. 
+
+#### Embracing the Relational Model
+
+In 1970 E. F. Codd criticized the then-dominant hierarchical model of databases in his article <a href="https://www.seas.upenn.edu/~zives/03f/cis550/codd.pdf">A Relational Model of Data for Large Shared Data Banks</a>. Reading the article reveals a striking similarity between hierarchical databases and nested http routes. With PostgREST we attempt to use flexible filtering and embedding rather than nested routes.
+
+#### One Thing Well
+
+PostgREST has a focused scope. It works well with other tools like Nginx. This forces you to cleanly separate the data-centric CRUD operations from other concerns. Use a collection of sharp tools rather than building a big ball of mud.
+
+#### Shared Improvements
+
+As with any open source project, we all gain from features and fixes in the tool. It's more beneficial than improvements locked inextricably within custom codebases.
+
+### Myths
+
+#### You have to make tons of stored procs and triggers
+
+Modern PostgreSQL features like auto-updatable views and computed columns make this mostly unnecessary. Triggers do play a part, but generally not for irksome boilerplate. When they are required triggers are preferable to ad-hoc app code anyway, since the former work reliably for any codepath.
+
+#### Exposing the database destroys encapsulation
+
+PostgREST does versioning through database schemas. This allows you to expose tables and views without making the app brittle. Underlying tables can be superseded and hidden behind public facing views. The chapter about versioning shows how to do this.
+
+### Conventions
+
+This guide contains highlighted notes and tangential information interspersed with the text.
+
+<div class="admonition note">
+    <p class="admonition-title">Design Consideration</p>
+
+    <p>Contains history which informed the current design. Sometimes it discusses unavoidable tradeoffs or a point of theory.</p>
+</div>
+
+<div class="admonition warning">
+    <p class="admonition-title">Invitation to Contribute</p>
+
+    <p>Points out things we know we want to add or improve. They might give you ideas for ways to contribute to the project.</p>
+</div>
+
+<div class="admonition danger">
+    <p class="admonition-title">Deprecation Warning</p>
+
+    <p>Alerts you to features which will be removed in the next major (breaking) release.</p>
+</div>
@@ -0,0 +1,23 @@
+## Ecosystem
+
+### Client-Side Libraries
+
+* [mithril.postgrest](https://github.com/catarse/mithril.postgrest) - Mithril plugin to create and authenticate requests
+* [lewisjared/postgrest-request](https://github.com/lewisjared/postgrest-request) - node interface to postgrest instances
+* [JarvusInnovations/jarvus-postgrest-apikit](https://github.com/JarvusInnovations/jarvus-postgrest-apikit) - Sencha framework package for binding models/stores/proxies to PostgREST tables
+
+### Extensions
+
+* [srid/spas](https://github.com/srid/spas) - allow file uploads and basic auth
+
+### Example Apps
+
+* [timwis/ext-postgrest-crud](https://github.com/timwis/ext-postgrest-crud) - browser-based spreadsheet
+* [srid/chronicle](https://github.com/srid/chronicle#deploying-to-heroku) - tracking a tree of personal memories
+* [begriffs/postgrest-example](https://github.com/begriffs/postgrest-example) - how to configure a db for use as an API
+* [marmelab/ng-admin-postgrest](https://github.com/marmelab/ng-admin-postgrest) - automatic database admin panel
+* [tyrchen/goodfilm](https://github.com/tyrchen/goodfilm) - example film api
+
+### In Production
+
+* [Catarse](https://www.catarse.me/)
@@ -0,0 +1,62 @@
+## Installation
+
+### Installing from Pre-Built Release
+
+The [release page](https://github.com/begriffs/postgrest/releases/latest) has precompiled binaries for Mac OS X and 64-bit Ubuntu. Next extract the tarball and run the binary inside with no arguments to see usage instructions:
+
+```sh
+# Untar the release (available at https://github.com/begriffs/postgrest/releases/latest)
+
+$ tar zxf postgrest-0.2.12.0-osx.tar.xz
+
+# Try running it
+$ ./postgrest
+
+# You should see a usage help message
+```
+
+<div class="admonition warning">
+    <p class="admonition-title">Invitation to Contribute</p>
+
+    <p>I currently build the binaries manually for each version. We need to set up an automated build matrix for various architectures. It should support 32- and 64-bit versions of
+
+    <ul><li>Scientific Linux 6</li><li>CentOS</li><li>RHEL 6</li></ul>
+
+    Also it would be good to create packages for Homebrew, and apt.</p>
+</div>
+
+We'll learn the meaning of the command line flags later, but here is a minimal example of running the app. It does all operations as user `postgres`, including for unauthenticated requests.
+
+```sh
+$ ./postgrest -d dbname -U postgres --a postgres --v1schema public
+```
+
+### Building from Source
+
+When a prebuilt binary does not exist for your system you can build the project from source. You'll also need to do this if you want to help with development. [Stack](https://github.com/commercialhaskell/stack) makes it easy. It will install any necessary Haskell dependencies on your system.
+
+* [Install Stack](https://github.com/commercialhaskell/stack#how-to-install) for your platform
+* Build the project
+
+```bash
+git clone https://github.com/begriffs/postgrest.git
+cd postgrest
+stack build
+```
+
+* Run the server
+
+```bash
+stack exec postgrest -- arg1 arg2
+# ... your arguments after the double dashes
+```
+
+If you want to run the test suite, stack can do that too: `stack test`.
+
+### Installing PostgreSQL
+
+To use PostgREST you will need an underlying database. You can use something like Amazon [RDS](https://aws.amazon.com/rds/) but installing your own locally is cheaper and more convenient for development.
+
+* [Instructions for OS X](http://exponential.io/blog/2015/02/21/install-postgresql-on-mac-os-x-via-brew/)
+* [Instructions for Ubuntu 14.04](https://www.digitalocean.com/community/tutorials/how-to-install-and-use-postgresql-on-ubuntu-14-04)
+
@@ -0,0 +1,24 @@
+site_name: PostgREST
+site_url: http://postgrest.com
+site_description: Building declarative APIs
+site_author: Joe Nelson
+site_favicon: favicon.ico
+
+repo_url: https://github.com/begriffs/postgrest
+
+pages:
+- Home: index.md
+- Install:
+  - The Server: install/server.md
+  - Ecosystem: install/ecosystem.md
+- API:
+  - Reading: api/reading.md
+  - Writing: api/writing.md
+- Admin:
+  - Security: admin/security.md
+  - Versioning: admin/versioning.md
+  - Migration: admin/migration.md
+  - Deployment: admin/deployment.md
+  - Performance: admin/performance.md
+- Examples:
+  - Getting Started: examples/start.md
@@ -2,7 +2,7 @@ name:                  postgrest
 description:           Reads the schema of a PostgreSQL database and creates RESTful routes
                       for the tables and views, supporting all HTTP verbs that security
                       permits.
-version:               0.2.9.1
+version:               0.2.12.0
 synopsis:              REST API for any Postgres database
 license:               MIT
 license-file:          LICENSE
@@ -27,21 +27,21 @@ executable postgrest
  default-language:    Haskell2010
  build-depends:       base >=4.6 && <5
                     , postgrest
-                     , hasql == 0.7.3.1, hasql-backend == 0.4.1
-                     , hasql-postgres == 0.10.3.1
+                     , hasql >= 0.7.3 && < 0.8
+                     , hasql-backend >= 0.4.1 && < 0.5
+                     , hasql-postgres >= 0.10.4 && < 0.11
                     , warp >= 3.0.2, wai >= 3.0.1
                     , wai-extra, wai-cors
                     , wai-middleware-static >= 0.6.0
                     , HTTP, convertible, http-types
                     , case-insensitive
                     , scientific, time
-                     , aeson, network >= 2.6
+                     , aeson >= 0.8, network >= 2.6
                     , bytestring, text, split, string-conversions
                     , stringsearch
                     , containers, unordered-containers
-                     , optparse-applicative == 0.11.*
+                     , optparse-applicative >= 0.11 && < 0.13
                     , regex-base, regex-tdfa
-                     , regex-tdfa-text
                     , Ranged-sets
                     , transformers, MissingH
                     , bcrypt >= 0.0.6, base64-string
@@ -52,6 +52,9 @@ executable postgrest
                     , mtl
                     , cassava
                     , jwt
+                     , parsec
+                     , errors
+                     , bifunctors
  hs-source-dirs:      src

 library
@@ -63,32 +66,39 @@ library
  default-language:    Haskell2010
  default-extensions:  OverloadedStrings, ScopedTypeVariables, QuasiQuotes
  build-depends:       base >=4.6 && <5
-                     , hasql == 0.7.3.1, hasql-backend == 0.4.1
-                     , hasql-postgres == 0.10.3.1
-                     , warp >= 3.0.2, wai >= 3.0.1
+                     , hasql, hasql-backend
+                     , hasql-postgres
+                     , warp, wai
                     , wai-extra, wai-cors
-                     , wai-middleware-static >= 0.6.0
+                     , wai-middleware-static
                     , HTTP, convertible, http-types
                     , case-insensitive
                     , scientific, time
-                     , aeson, network >= 2.6
+                     , aeson, network
                     , bytestring, text, split, string-conversions
                     , stringsearch
                     , containers, unordered-containers
-                     , optparse-applicative == 0.11.*
+                     , optparse-applicative
                     , regex-base, regex-tdfa
-                     , regex-tdfa-text
                     , Ranged-sets
                     , transformers, MissingH
-                     , bcrypt >= 0.0.6, base64-string
-                     , network-uri >= 2.6
+                     , bcrypt, base64-string
+                     , network-uri
                     , resource-pool
                     , blaze-builder
                     , vector
                     , mtl
                     , cassava
                     , jwt
+                     , parsec
+                     , errors
+                     , bifunctors
+
+  Other-Modules:       Paths_postgrest
  Exposed-Modules:     PostgREST.App
+                     , PostgREST.Types
+                     , PostgREST.Parsers
+                     , PostgREST.QueryBuilder
                     , PostgREST.Auth
                     , PostgREST.Config
                     , PostgREST.Error
@@ -109,6 +119,9 @@ Test-Suite spec
    ghc-options:       -Wall -W -O2
  Main-Is:             Main.hs
  Other-Modules:       PostgREST.App
+                     , PostgREST.Types
+                     , PostgREST.Parsers
+                     , PostgREST.QueryBuilder
                     , PostgREST.Auth
                     , PostgREST.Config
                     , PostgREST.Error
@@ -118,10 +131,11 @@ Test-Suite spec
                     , PostgREST.RangeQuery
                     , Spec
                     , SpecHelper
-  Build-Depends:       base, hspec >= 2.1.2, QuickCheck
-                     , hspec-wai >= 0.5.0, hspec-wai-json
-                     , hasql == 0.7.3.1, hasql-backend == 0.4.1
-                     , hasql-postgres == 0.10.3.1
+                     , Paths_postgrest
+  Build-Depends:       base, hspec == 2.1.*, QuickCheck
+                     , hspec-wai, hspec-wai-json
+                     , hasql, hasql-backend
+                     , hasql-postgres
                     , warp, wai
                     , packdeps, hlint
                     , HTTP, convertible
@@ -136,7 +150,6 @@ Test-Suite spec
                     , regex-base
                     , string-conversions
                     , http-media, regex-tdfa
-                     , regex-tdfa-text
                     , Ranged-sets
                     , transformers, MissingH, split
                     , bcrypt, base64-string
@@ -149,3 +162,6 @@ Test-Suite spec
                     , process
                     , heredoc
                     , jwt
+                     , parsec
+                     , errors
+                     , bifunctors
@@ -1,6 +1,6 @@
 export POSTGREST_VER=`grep ^version /app/postgrest.cabal | sed -En 's/.*\s+([0-9\.]+)/\1/p'`

-curl -L http://softlayer-ams.dl.sourceforge.net/project/s3tools/s3cmd/1.5.0-alpha1/s3cmd-1.5.0-alpha1.tar.gz | tar zx
+curl -L http://sourceforge.net/projects/s3tools/files/s3cmd/1.5.0-alpha1/s3cmd-1.5.0-alpha1.tar.gz | tar zx

 cp /app/dist/build/postgrest/postgrest postgrest-${POSTGREST_VER}
 tar cJf postgrest-${POSTGREST_VER}.tar.xz postgrest-${POSTGREST_VER}
@@ -1,95 +1,137 @@
-{-# LANGUAGE FlexibleContexts #-}
-module PostgREST.App (app, sqlError, isSqlError) where
+{-# LANGUAGE FlexibleContexts    #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+module PostgREST.App (
+  app
+, sqlError
+, isSqlError
+, contentTypeForAccept
+, jsonH
+, requestedSchema
+, TableOptions(..)
+) where

-import Control.Monad (join)
-import Control.Arrow ((***), second)
-import Control.Applicative
+import qualified Blaze.ByteString.Builder  as BB
+import           Control.Applicative
+import           Control.Arrow             (second, (***))
+import           Control.Monad             (join)
+import           Data.Bifunctor            (first)
+import qualified Data.ByteString.Char8     as BS
+import qualified Data.ByteString.Lazy      as BL
+import           Data.CaseInsensitive      (original)
+import qualified Data.Csv                  as CSV
+import           Data.Functor.Identity
+import qualified Data.HashMap.Strict       as M
+import           Data.List                 (find, sortBy)
+import           Data.Maybe                (fromMaybe, isJust, isNothing,
+                                            mapMaybe)
+import           Data.Ord                  (comparing)
+import           Data.Ranged.Ranges        (emptyRange)
+import qualified Data.Set                  as S
+import           Data.String.Conversions   (cs)
+import           Data.Text                 (Text, replace, strip)
+import           Text.Regex.TDFA           ((=~))

-import Data.Text hiding (map)
-import Data.Maybe (fromMaybe, mapMaybe)
-import Text.Regex.TDFA ((=~))
-import Data.Ord (comparing)
-import Data.Ranged.Ranges (emptyRange)
-import qualified Data.HashMap.Strict as M
-import Data.String.Conversions (cs)
-import Data.CaseInsensitive (original)
-import Data.List (sortBy)
-import Data.Functor.Identity
-import qualified Data.Set as S
-import qualified Data.ByteString.Lazy as BL
-import qualified Blaze.ByteString.Builder as BB
-import qualified Data.Csv as CSV
+import           Text.Parsec.Error

-import Network.HTTP.Types.Status
-import Network.HTTP.Types.Header
-import Network.HTTP.Types.URI (parseSimpleQuery)
-import Network.HTTP.Base (urlEncodeVars)
-import Network.Wai
-import Network.Wai.Internal (Response(..))
+import           Network.HTTP.Base         (urlEncodeVars)
+import           Network.HTTP.Types.Header
+import           Network.HTTP.Types.Status
+import           Network.HTTP.Types.URI    (parseSimpleQuery)
+import           Network.Wai
+import           Network.Wai.Internal      (Response (..))
+import           Network.Wai.Parse         (parseHttpAccept)

-import Data.Aeson
-import Data.Monoid
-import qualified Data.Vector as V
-import qualified Hasql as H
-import qualified Hasql.Backend as B
-import qualified Hasql.Postgres as P
+import           Data.Aeson
+import           Data.Monoid
+import qualified Data.Vector               as V
+import qualified Hasql                     as H
+import qualified Hasql.Backend             as B
+import qualified Hasql.Postgres            as P

-import PostgREST.Config (AppConfig(..))
-import PostgREST.Auth
-import PostgREST.PgQuery
-import PostgREST.RangeQuery
-import PostgREST.PgStructure
+import           PostgREST.Auth
+import           PostgREST.Config          (AppConfig (..))
+import           PostgREST.Parsers
+import           PostgREST.PgQuery
+import           PostgREST.PgStructure
+import           PostgREST.QueryBuilder
+import           PostgREST.RangeQuery
+import           PostgREST.Types

-import Prelude
+import           Prelude

-app :: AppConfig -> BL.ByteString -> Request -> H.Tx P.Postgres s Response
-app conf reqBody req =
+app :: DbStructure -> AppConfig -> BL.ByteString -> DbRole -> Request -> H.Tx P.Postgres s Response
+app dbstructure conf reqBody dbrole req =
  case (path, verb) of
+
    ([], _) -> do
-      body <- encode <$> tables (cs schema)
+      let body = encode $ filter (filterTableAcl dbrole) $ filter ((cs schema==).tableSchema) allTabs
      return $ responseLBS status200 [jsonH] $ cs body

    ([table], "OPTIONS") -> do
-      let t = QualifiedTable schema (cs table)
-      cols <- columns t
-      pkey <- map cs <$> primaryKeyColumns t
-      return $ responseLBS status200 [jsonH, allOrigins]
-        $ encode (TableOptions cols pkey)
+      let cols = filter (filterCol schema table) allCols
+          pkeys = map pkName $ filter (filterPk schema table) allPrKeys
+          body = encode (TableOptions cols pkeys)
+      return $ responseLBS status200 [jsonH, allOrigins] $ cs body

    ([table], "GET") ->
      if range == Just emptyRange
      then return $ responseLBS status416 [] "HTTP Range error"
-      else do
-        let qt = QualifiedTable schema (cs table)
-        let select = B.Stmt "select " V.empty True <>
-                  parentheticT (
-                    whereT qq $ countRows qt
-                  ) <> commaq <> (
-                  asJsonWithCount
-                  . limitT range
-                  . orderT (orderParse qq)
-                  . whereT qq
-                  $ selectStar qt
+      else
+        case queries of
+          Left e -> return $ responseLBS status400 [("Content-Type", "application/json")] $ cs e
+          Right (qs, cqs) -> do
+            let qt = qualify table
+                count = if hasPrefer "count=none"
+                      then countNone
+                      else cqs
+                q = B.Stmt "select " V.empty True <>
+                    parentheticT count
+                    <> commaq <> (
+                    bodyForAccept contentType qt -- TODO! when in csv mode, the first row (columns) is not correct when requesting sub tables
+                    . limitT range
+                    $ qs
+                  )
+            row <- H.maybeEx q
+            let (tableTotal, queryTotal, body) = fromMaybe (Just (0::Int), 0::Int, Just "" :: Maybe BL.ByteString) row
+                to = from+queryTotal-1
+                contentRange = contentRangeH from to tableTotal
+                status = rangeStatus from to tableTotal
+                canonical = urlEncodeVars
+                  . sortBy (comparing fst)
+                  . map (join (***) cs)
+                  . parseSimpleQuery
+                  $ rawQueryString req
+            return $ responseLBS status
+              [contentTypeH, contentRange,
+                ("Content-Location",
+                  "/" <> cs table <>
+                    if Prelude.null canonical then "" else "?" <> cs canonical
                )
-        row <- H.maybeEx select
-        let (tableTotal, queryTotal, body) =
-              fromMaybe (0, 0, Just "" :: Maybe Text) row
+              ] (fromMaybe "[]" body)
+
+        where
            from = fromMaybe 0 $ rangeOffset <$> range
-            to = from+queryTotal-1
-            contentRange = contentRangeH from to tableTotal
-            status = rangeStatus from to tableTotal
-            canonical = urlEncodeVars
-                          . sortBy (comparing fst)
-                          . map (join (***) cs)
-                          . parseSimpleQuery
-                          $ rawQueryString req
-        return $ responseLBS status
-          [jsonH, contentRange,
-            ("Content-Location",
-             "/" <> cs table <>
-                if Prelude.null canonical then "" else "?" <> cs canonical
-            )
-          ] (cs $ fromMaybe "[]" body)
+            apiRequest = first formatParserError (parseGetRequest req)
+                     >>= first formatRelationError . addRelations schema allRels Nothing
+                     >>= addJoinConditions schema allCols
+                     where
+                       formatRelationError :: Text -> Text
+                       formatRelationError e = cs $ encode $ object [
+                         "mesage" .= ("could not find foreign keys between these entities"::String),
+                         "details" .= e]
+                       formatParserError :: ParseError -> Text
+                       formatParserError e = cs $ encode $ object [
+                         "message" .= message,
+                         "details" .= details]
+                         where
+                           message = show (errorPos e)
+                           details = strip $ replace "\n" " " $ cs
+                             $ showErrorMessages "or" "unknown parse error" "expecting" "unexpected" "end of input" (errorMessages e)
+
+            query = requestToQuery schema <$> apiRequest
+            countQuery = requestToCountQuery schema <$> apiRequest
+            queries = (,) <$> query <*> countQuery
+

    (["postgrest", "users"], "POST") -> do
      let user = decode reqBody :: Maybe AuthUser
@@ -99,7 +141,7 @@ app conf reqBody req =
          encode . object $ [("message", String "Failed to parse user.")]
        Just u -> do
          _ <- addUser (cs $ userId u)
-            (cs $ userPass u) (cs $ userRole u)
+            (cs $ userPass u) (cs <$> userRole u)
          return $ responseLBS status201
            [ jsonH
            , (hLocation, "/postgrest/users?id=eq." <> cs (userId u))
@@ -117,41 +159,40 @@ app conf reqBody req =
              encode . object $ [("message", String "Failed to parse user.")]
            Just u -> do
              setRole authenticator
-              login <- signInRole (cs $ userId u)
-                              (cs $ userPass u)
+              login <- signInRole (cs $ userId u) (cs $ userPass u)
              case login of
-                LoginSuccess role ->
+                LoginSuccess role uid ->
                  return $ responseLBS status201 [ jsonH ] $
-                    encode . object $ [("token", String $ tokenJWT jwtSecret (cs $ userId u) role)]
+                    encode . object $ [("token", String $ tokenJWT jwtSecret uid role)]
                _  -> return $ responseLBS status401 [jsonH] $
                  encode . object $ [("message", String "Failed authentication.")]

    ([table], "POST") -> do
-      let qt = QualifiedTable schema (cs table)
-          echoRequested = lookup "Prefer" hdrs == Just "return=representation"
+      let qt = qualify table
+          echoRequested = hasPrefer "return=representation"
          parsed :: Either String (V.Vector Text, V.Vector (V.Vector Value))
-          parsed = if lookup "Content-Type" hdrs == Just "text/csv"
-                    then do
-                      rows <- CSV.decode CSV.NoHeader reqBody
-                      if V.null rows then Left "CSV requires header"
-                        else Right (V.head rows, (V.map $ V.map $ parseCsvCell . cs) (V.tail rows))
-                    else eitherDecode reqBody >>= \val ->
-                      case val of
-                        Object obj -> Right .  second V.singleton .  V.unzip .  V.fromList $
-                          M.toList obj
-                        _ -> Left "Expecting single JSON object or CSV rows"
+          parsed = if lookupHeader "Content-Type" == Just csvMT
+            then do
+              rows <- CSV.decode CSV.NoHeader reqBody
+              if V.null rows then Left "CSV requires header"
+                else Right (V.head rows, (V.map $ V.map $ parseCsvCell . cs) (V.tail rows))
+            else eitherDecode reqBody >>= \val ->
+              case val of
+                Object obj -> Right .  second V.singleton .  V.unzip .  V.fromList $
+                  M.toList obj
+                _ -> Left "Expecting single JSON object or CSV rows"
      case parsed of
        Left err -> return $ responseLBS status400 [] $
          encode . object $ [("message", String $ "Failed to parse JSON payload. " <> cs err)]
        Right toBeInserted -> do
          rows :: [Identity Text] <- H.listEx $ uncurry (insertInto qt) toBeInserted
          let inserted :: [Object] = mapMaybe (decode . cs . runIdentity) rows
-          primaryKeys <- primaryKeyColumns qt
-          let responses = flip map inserted $ \obj -> do
+              pKeys = map pkName $ filter (filterPk schema table) allPrKeys
+              responses = flip map inserted $ \obj -> do
                let primaries =
-                      if Prelude.null primaryKeys
+                      if Prelude.null pKeys
                        then obj
-                        else M.filterWithKey (const . (`elem` primaryKeys)) obj
+                        else M.filterWithKey (const . (`elem` pKeys)) obj
                let params = urlEncodeVars
                      $ map (\t -> (cs $ fst t, cs (paramFilter $ snd t)))
                      $ sortBy (comparing fst) $ M.toList primaries
@@ -161,36 +202,52 @@ app conf reqBody req =
                  ] $ if echoRequested then encode obj else ""
          return $ multipart status201 responses

+    (["rpc", proc], "POST") -> do
+      let qi = QualifiedIdentifier schema (cs proc)
+      exists <- doesProcExist schema proc
+      if exists
+        then do
+          let call = B.Stmt "select " V.empty True <>
+                asJson (callProc qi $ fromMaybe M.empty (decode reqBody))
+          body :: Maybe (Identity Text) <- H.maybeEx call
+          return $ responseLBS status200 [jsonH]
+            (cs $ fromMaybe "[]" $ runIdentity <$> body)
+        else return $ responseLBS status404 [] ""
+
+      -- check that proc exists
+      -- check that arg names are all specified
+      -- select * from "1".proc(a := "foo"::undefined) where whereT limit limitT
+
    ([table], "PUT") ->
      handleJsonObj reqBody $ \obj -> do
-        let qt = QualifiedTable schema (cs table)
-        primaryKeys <- primaryKeyColumns qt
-        let specifiedKeys = map (cs . fst) qq
-        if S.fromList primaryKeys /= S.fromList specifiedKeys
+        let qt = qualify table
+            pKeys = map pkName $ filter (filterPk schema table) allPrKeys
+            specifiedKeys = map (cs . fst) qq
+        if S.fromList pKeys /= S.fromList specifiedKeys
          then return $ responseLBS status405 []
-               "You must speficy all and only primary keys as params"
+            "You must speficy all and only primary keys as params"
          else do
-            tableCols <- map (cs . colName) <$> columns qt
-            let cols = map cs $ M.keys obj
+            let tableCols = map (cs . colName) $ filter (filterCol schema table) allCols
+                cols = map cs $ M.keys obj
            if S.fromList tableCols == S.fromList cols
              then do
                let vals = M.elems obj
                H.unitEx $ iffNotT
-                        (whereT qq $ update qt cols vals)
-                        (insertSelect qt cols vals)
+                  (whereT qt qq $ update qt cols vals)
+                  (insertSelect qt cols vals)
                return $ responseLBS status204 [ jsonH ] ""

              else return $ if Prelude.null tableCols
                then responseLBS status404 [] ""
                else responseLBS status400 []
-                   "You must specify all columns in PUT request"
+                  "You must specify all columns in PUT request"

    ([table], "PATCH") ->
      handleJsonObj reqBody $ \obj -> do
-        let qt = QualifiedTable schema (cs table)
+        let qt = qualify table
            up = returningStarT
-               . whereT qq
-               $ update qt (map cs $ M.keys obj) (M.elems obj)
+              . whereT qt qq
+              $ update qt (map cs $ M.keys obj) (M.elems obj)
            patch = withT up "t" $ B.Stmt
              "select count(t), array_to_json(array_agg(row_to_json(t)))::character varying"
              V.empty True
@@ -198,38 +255,54 @@ app conf reqBody req =
        row <- H.maybeEx patch
        let (queryTotal, body) =
              fromMaybe (0 :: Int, Just "" :: Maybe Text) row
-            r = contentRangeH 0 (queryTotal-1) queryTotal
-            echoRequested = lookup "Prefer" hdrs == Just "return=representation"
+            r = contentRangeH 0 (queryTotal-1) (Just queryTotal)
+            echoRequested = hasPrefer "return=representation"
            s = case () of _ | queryTotal == 0 -> status404
                             | echoRequested -> status200
                             | otherwise -> status204
        return $ responseLBS s [ jsonH, r ] $ if echoRequested then cs $ fromMaybe "[]" body else ""

    ([table], "DELETE") -> do
-      let qt = QualifiedTable schema (cs table)
-      let del = countT
+      let qt = qualify table
+          del = countT
            . returningStarT
-            . whereT qq
+            . whereT qt qq
            $ deleteFrom qt
      row <- H.maybeEx del
      let (Identity deletedCount) = fromMaybe (Identity 0 :: Identity Int) row
      return $ if deletedCount == 0
-         then responseLBS status404 [] ""
-         else responseLBS status204 [("Content-Range", "*/"<> cs (show deletedCount))] ""
+        then responseLBS status404 [] ""
+        else responseLBS status204 [("Content-Range", "*/"<> cs (show deletedCount))] ""

    (_, _) ->
      return $ responseLBS status404 [] ""

  where
-    path   = pathInfo req
-    verb   = requestMethod req
-    qq     = queryString req
-    hdrs   = requestHeaders req
-    schema = requestedSchema (cs $ configV1Schema conf) hdrs
+    allTabs = tables dbstructure
+    allRels = relations dbstructure
+    allCols = columns dbstructure
+    allPrKeys = primaryKeys dbstructure
+    filterCol sc table (Column{colSchema=s, colTable=t}) =  s==sc && table==t
+    filterCol _ _ _ =  False
+    filterPk sc table pk = sc == pkSchema pk && table == pkTable pk
+
+    filterTableAcl :: Text -> Table -> Bool
+    filterTableAcl r (Table{tableAcl=a}) = r `elem` a
+    path          = pathInfo req
+    verb          = requestMethod req
+    qq            = queryString req
+    qualify       = QualifiedIdentifier schema
+    hdrs          = requestHeaders req
+    lookupHeader  = flip lookup hdrs
+    hasPrefer val = any (\(h,v) -> h == "Prefer" && v == val) hdrs
+    accept        = lookupHeader hAccept
+    schema        = requestedSchema (cs $ configV1Schema conf) accept
    authenticator = cs $ configDbUser conf
-    jwtSecret = cs $ configJwtSecret conf
-    range  = rangeRequested hdrs
-    allOrigins = ("Access-Control-Allow-Origin", "*") :: Header
+    jwtSecret     = cs $ configJwtSecret conf
+    range         = rangeRequested hdrs
+    allOrigins    = ("Access-Control-Allow-Origin", "*") :: Header
+    contentType   = fromMaybe "application/json" $ contentTypeForAccept accept
+    contentTypeH  = (hContentType, contentType)

 sqlError :: t
 sqlError = undefined
@@ -237,34 +310,62 @@ sqlError = undefined
 isSqlError :: t
 isSqlError = undefined

-rangeStatus :: Int -> Int -> Int -> Status
-rangeStatus from to total
+rangeStatus :: Int -> Int -> Maybe Int -> Status
+rangeStatus _ _ Nothing = status200
+rangeStatus from to (Just total)
  | from > total            = status416
  | (1 + to - from) < total = status206
  | otherwise               = status200

-contentRangeH :: Int -> Int -> Int -> Header
+contentRangeH :: Int -> Int -> Maybe Int -> Header
 contentRangeH from to total =
-  ("Content-Range",
-    if total == 0 || from > total
-    then "*/" <> cs (show total)
-    else cs (show from)  <> "-"
-       <> cs (show to)    <> "/"
-       <> cs (show total)
-  )
+    ("Content-Range", cs headerValue)
+    where
+      headerValue   = rangeString <> "/" <> totalString
+      rangeString
+        | totalNotZero && fromInRange = show from <> "-" <> cs (show to)
+        | otherwise = "*"
+      totalString   = fromMaybe "*" (show <$> total)
+      totalNotZero  = fromMaybe True ((/=) 0 <$> total)
+      fromInRange   = from <= to

-requestedSchema :: Text -> RequestHeaders -> Text
-requestedSchema v1schema hdrs =
+requestedSchema :: Text -> Maybe BS.ByteString -> Text
+requestedSchema v1schema accept =
  case verStr of
-       Just [[_, ver]] -> if ver == "1" then v1schema else ver
-       _ -> v1schema
+    Just [[_, ver]] -> if ver == "1" then v1schema else cs ver
+    _ -> v1schema

-  where verRegex = "version[ ]*=[ ]*([0-9]+)" :: String
-        accept = cs <$> lookup hAccept hdrs :: Maybe Text
-        verStr = (=~ verRegex) <$> accept :: Maybe [[Text]]
+  where
+    verRegex = "version[ ]*=[ ]*([0-9]+)" :: BS.ByteString
+    verStr = (=~ verRegex) <$> accept :: Maybe [[BS.ByteString]]
+
+
+jsonMT :: BS.ByteString
+jsonMT = "application/json"
+
+csvMT :: BS.ByteString
+csvMT = "text/csv"
+
+allMT :: BS.ByteString
+allMT = "*/*"

 jsonH :: Header
-jsonH = (hContentType, "application/json")
+jsonH = (hContentType, jsonMT)
+
+contentTypeForAccept :: Maybe BS.ByteString -> Maybe BS.ByteString
+contentTypeForAccept accept
+  | isNothing accept || has allMT || has jsonMT = Just jsonMT
+  | has csvMT = Just csvMT
+  | otherwise = Nothing
+  where
+    Just acceptH = accept
+    findInAccept = flip find $ parseHttpAccept acceptH
+    has          = isJust . findInAccept . BS.isPrefixOf
+
+bodyForAccept :: BS.ByteString -> QualifiedIdentifier  -> StatementT
+bodyForAccept contentType table
+  | contentType == csvMT = asCsvWithCount table
+  | otherwise = asJsonWithCount -- defaults to JSON

 handleJsonObj :: BL.ByteString -> (Object -> H.Tx P.Postgres s Response)
              -> H.Tx P.Postgres s Response
@@ -306,7 +407,7 @@ multipart s rs =

 data TableOptions = TableOptions {
  tblOptcolumns :: [Column]
-, tblOptpkey :: [Text]
+, tblOptpkey    :: [Text]
 }

 instance ToJSON TableOptions where
@@ -1,36 +1,35 @@
-{-# LANGUAGE QuasiQuotes, ScopedTypeVariables, OverloadedStrings #-}
 module PostgREST.Auth where

-import Data.Aeson
-import Control.Monad (mzero)
-import Control.Applicative
-import Crypto.BCrypt
-import Data.Text
-import Data.Monoid
-import Data.Map
-import qualified Data.Vector as V
-import qualified Hasql as H
-import qualified Hasql.Backend as B
-import qualified Hasql.Postgres as P
-import qualified Web.JWT as JWT
-import Data.String.Conversions (cs)
-import PostgREST.PgQuery (pgFmtLit)
+import           Control.Applicative
+import           Control.Monad           (mzero)
+import           Crypto.BCrypt
+import           Data.Aeson
+import           Data.Map
+import           Data.Monoid
+import           Data.String.Conversions (cs)
+import           Data.Text
+import           Data.Maybe (isNothing)
+import qualified Data.Vector             as V
+import qualified Hasql                   as H
+import qualified Hasql.Backend           as B
+import qualified Hasql.Postgres          as P
+import           PostgREST.PgQuery       (pgFmtLit)
+import           Prelude
+import qualified Web.JWT                 as JWT

-import Prelude
-
-import System.IO.Unsafe
+import           System.IO.Unsafe

 data AuthUser = AuthUser {
-    userId :: String
+    userId   :: String
  , userPass :: String
-  , userRole :: String
+  , userRole :: Maybe String
  } deriving (Show)

 instance FromJSON AuthUser where
  parseJSON (Object v) = AuthUser <$>
                         v .: "id" <*>
                         v .: "pass" <*>
-                         v .:? "role" .!= ""
+                         v .:? "role"
  parseJSON _ = mzero

 instance ToJSON AuthUser where
@@ -40,52 +39,66 @@ instance ToJSON AuthUser where
    , "role" .= userRole u ]

 type DbRole = Text
+type UserId = Text

 data LoginAttempt =
    NoCredentials
  | MalformedAuth
  | LoginFailed
-  | LoginSuccess DbRole
+  | LoginSuccess DbRole UserId
  deriving (Eq, Show)

 checkPass :: Text -> Text -> Bool
 checkPass = (. cs) . validatePassword . cs

 setRole :: Text -> H.Tx P.Postgres s ()
-setRole role = H.unitEx $ B.Stmt ("set role " <> cs (pgFmtLit role)) V.empty True
+setRole role = H.unitEx $ B.Stmt ("set local role " <> cs (pgFmtLit role)) V.empty True

-resetRole :: H.Tx P.Postgres s ()
-resetRole = H.unitEx [H.stmt|reset role|]
+setUserId :: Text -> H.Tx P.Postgres s ()
+setUserId uid =
+  if uid /= ""
+    then H.unitEx $ B.Stmt ("set local user_vars.user_id = " <> cs (pgFmtLit uid)) V.empty True
+    else resetUserId

-addUser :: Text -> Text -> Text -> H.Tx P.Postgres s ()
-addUser identity pass role = do
-  let Just hashed = unsafePerformIO $ hashPasswordUsingPolicy fastBcryptHashingPolicy (cs pass)
+resetUserId :: H.Tx P.Postgres s ()
+resetUserId = H.unitEx [H.stmt|reset user_vars.user_id|]
+
+addUser :: Text -> Text -> Maybe Text -> H.Tx P.Postgres s ()
+addUser identity pass role =
  H.unitEx $
-    [H.stmt|insert into postgrest.auth (id, pass, rolname) values (?, ?, ?)|]
-      identity (cs hashed :: Text) role
+    if isNothing role
+      then [H.stmt|insert into postgrest.auth (id, pass) values (?, ?)|]
+        identity hashedText
+      else [H.stmt|insert into postgrest.auth (id, pass, rolname) values (?, ?, ?)|]
+        identity hashedText role
+  where Just hashed = unsafePerformIO $ hashPasswordUsingPolicy fastBcryptHashingPolicy (cs pass)
+        hashedText = cs hashed :: Text

 signInRole :: Text -> Text -> H.Tx P.Postgres s LoginAttempt
 signInRole user pass = do
-  u <- H.maybeEx $ [H.stmt|select pass, rolname from postgrest.auth where id = ?|] user
+  u <- H.maybeEx $ [H.stmt|select id, pass, rolname from postgrest.auth where id = ?|] user
  return $ maybe LoginFailed (\r ->
-      let (hashed, role) = r in
+      let (uid, hashed, role) = r in
      if checkPass hashed pass
-         then LoginSuccess role
+         then LoginSuccess role uid
         else LoginFailed
    ) u

 signInWithJWT :: Text -> Text -> LoginAttempt
 signInWithJWT secret input = case maybeRole of
-    Just (Just (String role)) -> LoginSuccess $ cs role
+    Just (Just (String role)) -> case maybeUserId of
+      Just (Just (String uid)) -> LoginSuccess (cs role) (cs uid)
+      _   -> LoginFailed
    _   -> LoginFailed
-  where 
+  where
    maybeRole = (Data.Map.lookup "role" <$> claims) ::Maybe (Maybe Value)
+    maybeUserId = (Data.Map.lookup "id" <$> claims) ::Maybe (Maybe Value)
    claims = JWT.unregisteredClaims <$> JWT.claims <$> decoded
    decoded = JWT.decodeAndVerifySignature (JWT.secret secret) input
-    
+
 tokenJWT :: Text -> Text -> Text -> Text
 tokenJWT secret uid role = JWT.encodeSigned JWT.HS256 (JWT.secret secret) claimsSet
  where
    claimsSet = JWT.def {
      JWT.unregisteredClaims = Data.Map.fromList [("id", String uid), ("role", String role)]
-    }
+    }
@@ -1,28 +1,50 @@
-module PostgREST.Config where
+{-|
+Module      : PostgREST.Config
+Description : Manages PostgREST configuration options.

-import Network.Wai
-import Control.Applicative
-import Data.Text (strip)
-import qualified Data.CaseInsensitive as CI
-import qualified Data.ByteString.Char8 as BS
-import Data.String.Conversions (cs)
-import Options.Applicative hiding (columns)
-import Network.Wai.Middleware.Cors (CorsResourcePolicy(..))
-import Prelude
+This module provides a helper function to read the command line arguments using the optparse-applicative
+and the AppConfig type to store them.
+It also can be used to define other middleware configuration that may be delegated to some sort of
+external configuration.

+It currently includes a hardcoded CORS policy but this could easly be turned in configurable behaviour if needed.
+
+Other hardcoded options such as the minimum version number also belong here.
+-}
+module PostgREST.Config ( prettyVersion
+                        , readOptions
+                        , corsPolicy
+                        , minimumPgVersion
+                        , AppConfig (..)
+                        )
+       where
+
+import           Control.Applicative
+import qualified Data.ByteString.Char8       as BS
+import qualified Data.CaseInsensitive        as CI
+import           Data.List                   (intercalate)
+import           Data.String.Conversions     (cs)
+import           Data.Text                   (strip)
+import           Data.Version                (versionBranch)
+import           Network.Wai
+import           Network.Wai.Middleware.Cors (CorsResourcePolicy (..))
+import           Options.Applicative         hiding (columns)
+import           Paths_postgrest             (version)
+import           Prelude
+
+-- | Data type to store all command line options
 data AppConfig = AppConfig {
-    configDbName :: String
-  , configDbPort :: Int
-  , configDbUser :: String
-  , configDbPass :: String
-  , configDbHost :: String
+    configDbName    :: String
+  , configDbPort    :: Int
+  , configDbUser    :: String
+  , configDbPass    :: String
+  , configDbHost    :: String

-  , configPort  :: Int
-  , configAnonRole :: String
-  , configSecure :: Bool
-  , configPool :: Int
-  , configV1Schema :: String
-  
+  , configPort      :: Int
+  , configAnonRole  :: String
+  , configSecure    :: Bool
+  , configPool      :: Int
+  , configV1Schema  :: String
  , configJwtSecret :: String
  }

@@ -46,15 +68,16 @@ defaultCorsPolicy =  CorsResourcePolicy Nothing
  ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"] ["Authorization"] Nothing
  (Just $ 60*60*24) False False True

+-- | CORS policy to be used in by Wai Cors middleware
 corsPolicy :: Request -> Maybe CorsResourcePolicy
 corsPolicy req = case lookup "origin" headers of
  Just origin -> Just defaultCorsPolicy {
      corsOrigins = Just ([origin], True)
    , corsRequestHeaders = "Authentication":accHeaders
    , corsExposedHeaders = Just [
-          "Content-Encoding", "Content-Location", "Content-Range", "Content-Type"
-        , "Date", "Location", "Server", "Transfer-Encoding", "Range-Unit"
-        ]
+        "Content-Encoding", "Content-Location", "Content-Range", "Content-Type"
+      , "Date", "Location", "Server", "Transfer-Encoding", "Range-Unit"
+      ]
    }
  Nothing -> Nothing
  where
@@ -62,3 +85,24 @@ corsPolicy req = case lookup "origin" headers of
    accHeaders = case lookup "access-control-request-headers" headers of
      Just hdrs -> map (CI.mk . cs . strip . cs) $ BS.split ',' hdrs
      Nothing -> []
+
+-- | User friendly version number
+prettyVersion :: String
+prettyVersion = intercalate "." $ map show $ versionBranch version
+
+-- | Function to read and parse options from the command line
+readOptions :: IO AppConfig
+readOptions = customExecParser parserPrefs opts
+  where
+    opts = info (helper <*> argParser) $
+                    fullDesc
+                    <> progDesc (
+                    "PostgREST "
+                    <> prettyVersion
+                    <> " / create a REST API to an existing Postgres database"
+                    )
+    parserPrefs = prefs showHelpOnError
+
+-- | Tells the minimum PostgreSQL version required by this version of PostgREST
+minimumPgVersion :: Integer
+minimumPgVersion = 90300
@@ -1,18 +1,20 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
-{-# LANGUAGE FlexibleInstances, TypeSynonymInstances #-}
+{-# LANGUAGE FlexibleInstances    #-}
+{-# LANGUAGE TypeSynonymInstances #-}

 module PostgREST.Error (PgError, errResponse) where

-import qualified Hasql as H
-import qualified Hasql.Postgres as P
+
+import           Data.Aeson                ((.=))
+import qualified Data.Aeson                as JSON
+import           Data.String.Conversions   (cs)
+import           Data.String.Utils         (replace)
+import qualified Data.Text                 as T
+import qualified Hasql                     as H
+import qualified Hasql.Postgres            as P
+import           Network.HTTP.Types.Header
 import qualified Network.HTTP.Types.Status as HT
-import qualified Data.Aeson as JSON
-import qualified Data.Text as T
-import Data.Aeson ((.=))
-import Data.String.Conversions (cs)
-import Data.String.Utils(replace)
-import Network.Wai(Response, responseLBS)
-import Network.HTTP.Types.Header
+import           Network.Wai               (Response, responseLBS)

 type PgError = H.SessionError P.Postgres

@@ -1,39 +1,46 @@
 module Main where

-import Paths_postgrest (version)

-import PostgREST.App
-import PostgREST.Middleware
-import PostgREST.Error(errResponse)
+import           PostgREST.PgStructure
+import           PostgREST.Types
+import           Network.Wai

-import Control.Monad (unless)
-import Control.Monad.IO.Class (liftIO)
-import Data.String.Conversions (cs)
-import Network.Wai (strictRequestBody)
-import Network.Wai.Middleware.Cors (cors)
-import Network.Wai.Handler.Warp hiding (Connection)
-import Network.Wai.Middleware.Gzip (gzip, def)
-import Network.Wai.Middleware.Static (staticPolicy, only)
-import Network.Wai.Middleware.RequestLogger (logStdout)
-import Data.List (intercalate)
-import Data.Version (versionBranch)
-import qualified Hasql as H
-import qualified Hasql.Postgres as P
-import Options.Applicative hiding (columns)
+import           PostgREST.App
+import           PostgREST.Error                      (errResponse)
+import           PostgREST.Middleware

-import PostgREST.Config (AppConfig(..), argParser, corsPolicy)
+import           Control.Monad                        (unless)
+import           Control.Monad.IO.Class               (liftIO)
+import           Data.Functor.Identity
+import           Data.Monoid                          ((<>))
+import           Data.String.Conversions              (cs)
+import           Data.Text                            (Text)
+import qualified Hasql                                as H
+import qualified Hasql.Postgres                       as P
+import           Network.Wai.Handler.Warp             hiding (Connection)
+import           Network.Wai.Middleware.RequestLogger (logStdout)
+
+import           System.IO                            (BufferMode (..),
+                                                       hSetBuffering, stderr,
+                                                       stdin, stdout)
+
+import           PostgREST.Config                     (AppConfig (..),
+                                                       prettyVersion,
+                                                       readOptions,
+                                                       minimumPgVersion)
+
+isServerVersionSupported :: H.Session P.Postgres IO Bool
+isServerVersionSupported = do
+  Identity (row :: Text) <- H.tx Nothing $ H.singleEx $ [H.stmt|SHOW server_version_num|]
+  return $ read (cs row) >= minimumPgVersion

 main :: IO ()
 main = do
-  let opts = info (helper <*> argParser) $
-                fullDesc
-                <> progDesc (
-                    "PostgREST "
-                    <> prettyVersion
-                    <> " / create a REST API to an existing Postgres database"
-                )
-      parserPrefs = prefs showHelpOnError
-  conf <- customExecParser parserPrefs opts
+  hSetBuffering stdout LineBuffering
+  hSetBuffering stdin  LineBuffering
+  hSetBuffering stderr NoBuffering
+
+  conf <- readOptions
  let port = configPort conf

  unless (configSecure conf) $
@@ -51,21 +58,40 @@ main = do
      appSettings = setPort port
                  . setServerName (cs $ "postgrest/" <> prettyVersion)
                  $ defaultSettings
-      middle = logStdout
-        . (if configSecure conf then redirectInsecure else id)
-        . gzip def . cors corsPolicy
-        . staticPolicy (only [("favicon.ico", "static/favicon.ico")])
+      middle = logStdout . defaultMiddle (configSecure conf)

  poolSettings <- maybe (fail "Improper session settings") return $
-                H.poolSettings (fromIntegral $ configPool conf) 30
-  pool :: H.Pool P.Postgres
-          <- H.acquirePool pgSettings poolSettings
+    H.poolSettings (fromIntegral $ configPool conf) 30
+  pool :: H.Pool P.Postgres <- H.acquirePool pgSettings poolSettings

-  runSettings appSettings $ middle $ \req respond -> do
+  supportedOrError <- H.session pool isServerVersionSupported
+  either (fail . show)
+    (\supported ->
+      unless supported $
+        fail "Cannot run in this PostgreSQL version, PostgREST needs at least 9.2.0"
+    ) supportedOrError
+
+  let txSettings = Just (H.ReadCommitted, Just True)
+  metadata <- H.session pool $ H.tx txSettings $ do
+    tabs <- allTables
+    rels <- allRelations
+    cols <- allColumns rels
+    keys <- allPrimaryKeys
+    return (tabs, rels, cols, keys)
+
+  dbstructure <- case metadata of
+    Left e -> fail $ show e
+    Right (tabs, rels, cols, keys) ->
+      return DbStructure {
+          tables=tabs
+        , columns=cols
+        , relations=rels
+        , primaryKeys=keys
+        }
+
+
+  runSettings appSettings $ middle $ \ req respond -> do
    body <- strictRequestBody req
-    resOrError <- liftIO $ H.session pool $ H.tx Nothing $
-      authenticated conf (app conf body) req
+    resOrError <- liftIO $ H.session pool $ H.tx txSettings $
+      authenticated conf (app dbstructure conf body) req
    either (respond . errResponse) respond resOrError
-
-  where
-    prettyVersion = intercalate "." $ map show $ versionBranch version
@@ -3,30 +3,38 @@

 module PostgREST.Middleware where

-import Data.Maybe (fromMaybe)
-import Data.Monoid
-import Data.Text
-- import Data.Pool(withResource, Pool)
+import           Data.Maybe                    (fromMaybe, isNothing)
+import           Data.Monoid
+import           Data.Text
+import           Data.String.Conversions       (cs)
+import qualified Hasql                         as H
+import qualified Hasql.Postgres                as P

-import qualified Hasql as H
-import qualified Hasql.Postgres as P
-import Data.String.Conversions(cs)
+import           Network.HTTP.Types            (RequestHeaders)
+import           Network.HTTP.Types.Header     (hAccept, hAuthorization,
+                                                hLocation)
+import           Network.HTTP.Types.Status     (status301, status400, status401,
+                                                status415)
+import           Network.URI                   (URI (..), parseURI)
+import           Network.Wai                   (Application, Request (..),
+                                                Response, isSecure, rawPathInfo,
+                                                rawQueryString, requestHeaders,
+                                                responseLBS)
+import           Network.Wai.Middleware.Cors   (cors)
+import           Network.Wai.Middleware.Gzip   (def, gzip)
+import           Network.Wai.Middleware.Static (only, staticPolicy)

-import Network.HTTP.Types.Header (hLocation, hAuthorization)
-import Network.HTTP.Types (RequestHeaders)
-import Network.HTTP.Types.Status (status400, status401, status301)
-import Network.Wai (Application, requestHeaders, responseLBS, rawPathInfo,
-                   rawQueryString, isSecure, Request(..), Response)
-import Network.URI (URI(..), parseURI)
+import           Codec.Binary.Base64.String    (decode)
+import           PostgREST.App                 (contentTypeForAccept)
+import           PostgREST.Auth                (DbRole, LoginAttempt (..),
+                                                setRole, setUserId, signInRole,
+                                                signInWithJWT)
+import           PostgREST.Config              (AppConfig (..), corsPolicy)

-import PostgREST.Config (AppConfig(..))
-import PostgREST.Auth (LoginAttempt(..), signInRole, signInWithJWT, setRole, resetRole)
-import Codec.Binary.Base64.String (decode)
-
-import Prelude
+import           Prelude

 authenticated :: forall s. AppConfig ->
-                 (Request -> H.Tx P.Postgres s Response) ->
+                 (DbRole -> Request -> H.Tx P.Postgres s Response) ->
                 Request -> H.Tx P.Postgres s Response
 authenticated conf app req = do
  attempt <- httpRequesterRole (requestHeaders req)
@@ -35,8 +43,8 @@ authenticated conf app req = do
      return $ responseLBS status400 [] "Malformed basic auth header"
    LoginFailed ->
      return $ responseLBS status401 [] "Invalid username or password"
-    LoginSuccess role -> if role /= currentRole then runInRole role else app req
-    NoCredentials ->     if anon /= currentRole then runInRole anon else app req
+    LoginSuccess role uid -> if role /= currentRole then runInRole role uid else app currentRole req
+    NoCredentials         -> if anon /= currentRole then runInRole anon "" else app currentRole req

 where
   jwtSecret = cs $ configJwtSecret conf
@@ -54,12 +62,11 @@ authenticated conf app req = do
        return $ signInWithJWT jwtSecret jwt
      _ -> return NoCredentials

-   runInRole :: Text -> H.Tx P.Postgres s Response
-   runInRole r = do
+   runInRole :: Text -> Text -> H.Tx P.Postgres s Response
+   runInRole r uid = do
+     setUserId uid
     setRole r
-     res <- app req
-     resetRole
-     return res
+     app r req


 redirectInsecure :: Application -> Application
@@ -75,10 +82,24 @@ redirectInsecure app req respond = do

  if not (isSecure req || isHerokuSecure)
    then case uriM of
-              Just uri ->
-                respond $ responseLBS status301 [
-                    (hLocation, cs . show $ uri { uriScheme = "https:" })
-                  ] ""
-              Nothing ->
-                respond $ responseLBS status400 [] "SSL is required"
+      Just uri ->
+        respond $ responseLBS status301 [
+            (hLocation, cs . show $ uri { uriScheme = "https:" })
+          ] ""
+      Nothing ->
+        respond $ responseLBS status400 [] "SSL is required"
    else app req respond
+
+unsupportedAccept :: Application -> Application
+unsupportedAccept app req respond = do
+  let
+    accept = lookup hAccept $ requestHeaders req
+  if isNothing $ contentTypeForAccept accept
+  then respond $ responseLBS status415 [] "Unsupported Accept header, try: application/json"
+  else app req respond
+
+defaultMiddle :: Bool -> Application -> Application
+defaultMiddle secure = (if secure then redirectInsecure else id)
+  . gzip def . cors corsPolicy
+  . staticPolicy (only [("favicon.ico", "static/favicon.ico")])
+  . unsupportedAccept
@@ -0,0 +1,159 @@
+module PostgREST.Parsers
+( parseGetRequest
+)
+where
+
+import           Control.Applicative hiding ((<$>))
+--lines needed for ghc 7.8
+import           Data.Functor ((<$>))
+import           Data.Traversable (traverse)
+
+import           Control.Monad                 (join)
+import           Data.List                     (delete, find)
+import           Data.Maybe
+import           Data.Monoid
+import           Data.String.Conversions       (cs)
+import           Data.Text                     (Text)
+import           Data.Tree
+import           Network.Wai                   (Request, pathInfo, queryString)
+import           PostgREST.Types
+import           Text.ParserCombinators.Parsec hiding (many, (<|>))
+parseGetRequest :: Request -> Either ParseError ApiRequest
+parseGetRequest httpRequest =
+  foldr addFilter <$> (addOrder <$> apiRequest <*> ord) <*> flts
+  where
+    apiRequest = parse (pRequestSelect rootTableName) ("failed to parse select parameter <<"++selectStr++">>") $ cs selectStr
+    addOrder (Node r f) o = Node r{order=o} f
+    flts = mapM pRequestFilter whereFilters
+    rootTableName = cs $ head $ pathInfo httpRequest -- TODO unsafe head
+    qString = [(cs k, cs <$> v)|(k,v) <- queryString httpRequest]
+    orderStr = join $ lookup "order" qString
+    ord = traverse (parse pOrder ("failed to parse order parameter <<"++fromMaybe "" orderStr++">>")) orderStr
+    selectStr = fromMaybe "*" $ fromMaybe (Just "*") $ lookup "select" qString --in case the parametre is missing or empty we default to *
+    whereFilters = [ (k, fromJust v) | (k,v) <- qString, k `notElem` ["select", "order"], isJust v ]
+
+pRequestSelect :: Text -> Parser ApiRequest
+pRequestSelect rootNodeName = do
+  fieldTree <- pFieldForest
+  return $ foldr treeEntry (Node (Select rootNodeName [] [] [] Nothing Nothing) []) fieldTree
+  where
+    treeEntry :: Tree SelectItem -> ApiRequest -> ApiRequest
+    treeEntry (Node fld@((fn, _),_) fldForest) (Node rNode rForest) =
+      case fldForest of
+        [] -> Node (rNode {fields=fld:fields rNode}) rForest
+        _  -> Node rNode (foldr treeEntry (Node (Select fn [] [] [] Nothing Nothing) []) fldForest:rForest)
+
+pRequestFilter :: (String, String) -> Either ParseError (Path, Filter)
+pRequestFilter (k, v) = (,) <$> path <*> (Filter <$> fld <*> op <*> val)
+  where
+    treePath = parse pTreePath ("failed to parser tree path (" ++ k ++ ")") k
+    opVal = parse pOpValueExp ("failed to parse filter (" ++ v ++ ")") v
+    path = fst <$> treePath
+    fld = snd <$> treePath
+    op = fst <$> opVal
+    val = snd <$> opVal
+
+addFilter :: (Path, Filter) -> ApiRequest -> ApiRequest
+addFilter ([], flt) (Node rn@(Select {filters=flts}) forest) = Node (rn {filters=flt:flts}) forest
+addFilter (path, flt) (Node rn forest) =
+  case targetNode of
+    Nothing -> Node rn forest -- the filter is silenty dropped in the Request does not contain the required path
+    Just tn -> Node rn (addFilter (remainingPath, flt) tn:restForest)
+  where
+    targetNodeName:remainingPath = path
+    (targetNode,restForest) = splitForest targetNodeName forest
+    splitForest name forst =
+      case maybeNode of
+        Nothing -> (Nothing,forest)
+        Just node -> (Just node, delete node forest)
+      where maybeNode = find ((name==).mainTable.rootLabel) forst
+
+ws :: Parser Text
+ws = cs <$> many (oneOf " \t")
+
+lexeme :: Parser a -> Parser a
+lexeme p = ws *> p <* ws
+
+pTreePath :: Parser (Path,Field)
+pTreePath = do
+  p <- pFieldName `sepBy1` pDelimiter
+  jp <- optionMaybe ( string "->" >>  pJsonPath)
+  let pp = map cs p
+      jpp = map cs <$> jp
+  return (init pp, (last pp, jpp))
+  where
+
+
+pFieldForest :: Parser [Tree SelectItem]
+pFieldForest = pFieldTree `sepBy1` lexeme (char ',')
+
+pFieldTree :: Parser (Tree SelectItem)
+pFieldTree = try (Node <$> pSelect <*> ( char '(' *> pFieldForest <* char ')'))
+      <|>    Node <$> pSelect <*> pure []
+
+pStar :: Parser Text
+pStar = cs <$> (string "*" *> pure ("*"::String))
+
+pFieldName :: Parser Text
+pFieldName =  cs <$> (many1 (letter <|> digit <|> oneOf "_")
+      <?> "field name (* or [a..z0..9_])")
+
+pJsonPathDelimiter :: Parser Text
+pJsonPathDelimiter = cs <$> (try (string "->>") <|> string "->")
+
+pJsonPath :: Parser [Text]
+pJsonPath = pFieldName `sepBy1` pJsonPathDelimiter
+
+pField :: Parser Field
+pField = lexeme $ (,) <$> pFieldName <*> optionMaybe ( pJsonPathDelimiter *>  pJsonPath)
+
+pSelect :: Parser SelectItem
+pSelect = lexeme $
+  try ((,) <$> pField <*>((cs <$>) <$> optionMaybe (string "::" *> many letter)) )
+  <|> do
+    s <- pStar
+    return ((s, Nothing), Nothing)
+
+pOperator :: Parser Operator
+pOperator = cs <$> ( try (string "lte") -- has to be before lt
+     <|> try (string "lt")
+     <|> try (string "eq")
+     <|> try (string "gte") -- has to be before gh
+     <|> try (string "gt")
+     <|> try (string "lt")
+     <|> try (string "neq")
+     <|> try (string "like")
+     <|> try (string "ilike")
+     <|> try (string "in")
+     <|> try (string "notin")
+     <|> try (string "is" )
+     <|> try (string "isnot")
+     <|> try (string "@@")
+     <?> "operator (eq, gt, ...)"
+     )
+
+pValue :: Parser FValue
+pValue = VText <$> (cs <$> many anyChar)
+
+pDelimiter :: Parser Char
+pDelimiter = char '.' <?> "delimiter (.)"
+
+pOperatiorWithNegation :: Parser Operator
+pOperatiorWithNegation = try ( (<>) <$> ( cs <$> string "not." ) <*>  pOperator) <|> pOperator
+
+pOpValueExp :: Parser (Operator, FValue)
+pOpValueExp = (,) <$> pOperatiorWithNegation <*> (pDelimiter *> pValue)
+
+pOrder :: Parser [OrderTerm]
+pOrder = lexeme pOrderTerm `sepBy` char ','
+
+pOrderTerm :: Parser OrderTerm
+pOrderTerm =
+  try ( do
+    c <- pFieldName
+    _ <- pDelimiter
+    d <- string "asc" <|> string "desc"
+    nls <- optionMaybe (pDelimiter *> ( try(string "nullslast" *> pure ("nulls last"::String)) <|> try(string "nullsfirst" *> pure ("nulls first"::String))))
+    return $ OrderTerm (cs c) (cs d) (cs <$> nls)
+  )
+  <|> OrderTerm <$> (cs <$> pFieldName) <*> pure "asc" <*> pure Nothing
@@ -1,31 +1,35 @@
-{-# LANGUAGE TypeSynonymInstances, FlexibleInstances, MultiWayIf #-}
+{-# LANGUAGE FlexibleInstances    #-}
+{-# LANGUAGE MultiWayIf           #-}
+{-# LANGUAGE TypeSynonymInstances #-}
 {-# OPTIONS_GHC -fno-warn-orphans #-}

 module PostgREST.PgQuery where

-import PostgREST.RangeQuery

-import qualified Hasql as H
-import qualified Hasql.Postgres as P
-import qualified Hasql.Backend as B
+import qualified Hasql                   as H
+import qualified Hasql.Backend           as B
+import qualified Hasql.Postgres          as P
+import           PostgREST.RangeQuery
+import           PostgREST.Types         (OrderTerm (..), QualifiedIdentifier(..))

-import qualified Data.Text as T
-import Text.Regex.TDFA ( (=~) )
-import Text.Regex.TDFA.Text ()
-import qualified Network.HTTP.Types.URI as Net
-import qualified Data.ByteString.Char8 as BS
-import Data.Monoid
-import Data.Vector (empty)
-import Data.Maybe (fromMaybe, mapMaybe)
-import Data.Functor
-import Control.Monad (join)
-import Data.String.Conversions (cs)
-import qualified Data.Aeson as JSON
-import qualified Data.List as L
-import qualified Data.Vector as V
-import Data.Scientific (isInteger, formatScientific, FPFormat(..))
+import           Control.Monad           (join)
+import qualified Data.Aeson              as JSON
+import qualified Data.ByteString.Char8   as BS
+import           Data.Functor
+import qualified Data.HashMap.Strict     as H
+import qualified Data.List               as L
+import           Data.Maybe              (fromMaybe)
+import           Data.Monoid
+import           Data.Scientific         (FPFormat (..), formatScientific,
+                                          isInteger)
+import           Data.String.Conversions (cs)
+import qualified Data.Text               as T
+import           Data.Vector             (empty)
+import qualified Data.Vector             as V
+import qualified Network.HTTP.Types.URI  as Net
+import           Text.Regex.TDFA         ((=~))

-import Prelude
+import           Prelude

 type PStmt = H.Stmt P.Postgres
 instance Monoid PStmt where
@@ -34,16 +38,6 @@ instance Monoid PStmt where
  mempty = B.Stmt "" empty True
 type StatementT = PStmt -> PStmt

-data QualifiedTable = QualifiedTable {
-  qtSchema :: T.Text
-, qtName   :: T.Text
-} deriving (Show)
-
-data OrderTerm = OrderTerm {
-  otTerm :: T.Text
-, otDirection :: BS.ByteString
-, otNullOrder :: Maybe BS.ByteString
-}

 limitT :: Maybe NonnegRange -> StatementT
 limitT r q =
@@ -52,14 +46,15 @@ limitT r q =
    limit  = maybe "ALL" (cs . show) $ join $ rangeLimit <$> r
    offset = cs . show $ fromMaybe 0 $ rangeOffset <$> r

-whereT :: Net.Query -> StatementT
-whereT params q =
- if L.null cols
-   then q
-   else q <> B.Stmt " where " empty True <> conjunction
- where
-   cols = [ col | col <- params, fst col `notElem` ["order"] ]
-   conjunction = mconcat $ L.intersperse andq (map wherePred cols)
+whereT :: QualifiedIdentifier -> Net.Query -> StatementT
+whereT table params q =
+  if L.null cols
+    then q
+    else q <> B.Stmt " where " empty True <> conjunction
+  where
+    cols = [ col | col <- params, fst col `notElem` ["order","select"] ]
+    wherePredTable = wherePred table
+    conjunction = mconcat $ L.intersperse andq (map wherePredTable cols)

 withT :: PStmt -> T.Text -> StatementT
 withT (B.Stmt eq ep epre) v (B.Stmt wq wp wpre) =
@@ -73,13 +68,13 @@ orderT ts q =
    then q
    else q <> B.Stmt " order by " empty True <> clause
  where
-   clause = mconcat $ L.intersperse commaq (map queryTerm ts)
-   queryTerm :: OrderTerm -> PStmt
-   queryTerm t = B.Stmt
-                   (" " <> cs (pgFmtIdent $ otTerm t) <> " "
-                        <> cs (otDirection t)         <> " "
-                        <> maybe "" cs (otNullOrder t) <> " ")
-                   empty True
+    clause = mconcat $ L.intersperse commaq (map queryTerm ts)
+    queryTerm :: OrderTerm -> PStmt
+    queryTerm t = B.Stmt
+      (" " <> cs (pgFmtIdent $ otTerm t) <> " "
+           <> cs (otDirection t)         <> " "
+           <> maybe "" cs (otNullOrder t) <> " ")
+      empty True

 parentheticT :: StatementT
 parentheticT s =
@@ -95,36 +90,55 @@ iffNotT (B.Stmt aq ap apre) (B.Stmt bq bp bpre) =

 countT :: StatementT
 countT s =
-  s { B.stmtTemplate = "WITH qqq AS (" <> B.stmtTemplate s <> ") SELECT count(1) FROM qqq" }
+  s { B.stmtTemplate = "WITH qqq AS (" <> B.stmtTemplate s <> ") SELECT pg_catalog.count(1) FROM qqq" }

-countRows :: QualifiedTable -> PStmt
-countRows t = B.Stmt ("select count(1) from " <> fromQt t) empty True
+countRows :: QualifiedIdentifier  -> PStmt
+countRows t = B.Stmt ("select pg_catalog.count(1) from " <> fromQi t) empty True
+
+countNone :: PStmt
+countNone = B.Stmt "select null" empty True
+
+asCsvWithCount :: QualifiedIdentifier -> StatementT
+asCsvWithCount table = withCount . asCsv table
+
+asCsv :: QualifiedIdentifier -> StatementT
+asCsv table s = s {
+  B.stmtTemplate =
+    "(select string_agg(quote_ident(column_name::text), ',') from "
+    <> "(select column_name from information_schema.columns where quote_ident(table_schema) || '.' || table_name = '"
+    <> fromQi table <> "' order by ordinal_position) h) || '\r' || "
+    <> "coalesce(string_agg(substring(t::text, 2, length(t::text) - 2), '\r'), '') from ("
+    <> B.stmtTemplate s <> ") t" }

 asJsonWithCount :: StatementT
-asJsonWithCount s = s { B.stmtTemplate =
-     "count(t), array_to_json(array_agg(row_to_json(t)))::character varying from ("
-  <> B.stmtTemplate s <> ") t" }
+asJsonWithCount = withCount . asJson
+
+asJson :: StatementT
+asJson s = s {
+  B.stmtTemplate =
+    "array_to_json(array_agg(row_to_json(t)))::character varying from ("
+    <> B.stmtTemplate s <> ") t" }
+
+withCount :: StatementT
+withCount s = s { B.stmtTemplate = "pg_catalog.count(t), " <> B.stmtTemplate s }

 asJsonRow :: StatementT
 asJsonRow s = s { B.stmtTemplate = "row_to_json(t) from (" <> B.stmtTemplate s <> ") t" }

-selectStar :: QualifiedTable -> PStmt
-selectStar t = B.Stmt ("select * from " <> fromQt t) empty True
-
 returningStarT :: StatementT
 returningStarT s = s { B.stmtTemplate = B.stmtTemplate s <> " RETURNING *" }

-deleteFrom :: QualifiedTable -> PStmt
-deleteFrom t = B.Stmt ("delete from " <> fromQt t) empty True
+deleteFrom :: QualifiedIdentifier -> PStmt
+deleteFrom t = B.Stmt ("delete from " <> fromQi t) empty True

-insertInto :: QualifiedTable
+insertInto :: QualifiedIdentifier
              -> V.Vector T.Text
              -> V.Vector (V.Vector JSON.Value)
              -> PStmt
 insertInto t cols vals
-  | V.null cols = B.Stmt ("insert into " <> fromQt t <> " default values returning *") empty True
+  | V.null cols = B.Stmt ("insert into " <> fromQi t <> " default values returning *") empty True
  | otherwise   = B.Stmt
-    ("insert into " <> fromQt t <> " (" <>
+    ("insert into " <> fromQi t <> " (" <>
      T.intercalate ", " (V.toList $ V.map pgFmtIdent cols) <>
      ") values "
      <> T.intercalate ", "
@@ -133,85 +147,87 @@ insertInto t cols vals
            <> ")"
          ) vals
        )
-      <> " returning row_to_json(" <> fromQt t <> ".*)")
+      <> " returning row_to_json(" <> fromQi t <> ".*)")
    empty True

-insertSelect :: QualifiedTable -> [T.Text] -> [JSON.Value] -> PStmt
+insertSelect :: QualifiedIdentifier -> [T.Text] -> [JSON.Value] -> PStmt
 insertSelect t [] _ = B.Stmt
-  ("insert into " <> fromQt t <> " default values returning *") empty True
+  ("insert into " <> fromQi t <> " default values returning *") empty True
 insertSelect t cols vals = B.Stmt
-  ("insert into " <> fromQt t <> " ("
+  ("insert into " <> fromQi t <> " ("
    <> T.intercalate ", " (map pgFmtIdent cols)
    <> ") select "
    <> T.intercalate ", " (map insertableValue vals))
  empty True

-update :: QualifiedTable -> [T.Text] -> [JSON.Value] -> PStmt
+update :: QualifiedIdentifier -> [T.Text] -> [JSON.Value] -> PStmt
 update t cols vals = B.Stmt
-  ("update " <> fromQt t <> " set ("
+  ("update " <> fromQi t <> " set ("
    <> T.intercalate ", " (map pgFmtIdent cols)
    <> ") = ("
    <> T.intercalate ", " (map insertableValue vals)
    <> ")")
  empty True

-wherePred :: Net.QueryItem -> PStmt
-wherePred (col, predicate) =
-  B.Stmt (" " <> pgFmtJsonbPath (cs col) <> " " <> op <> " " <>
+callProc :: QualifiedIdentifier -> JSON.Object -> PStmt
+callProc qi params = do
+  let args = T.intercalate "," $ map assignment (H.toList params)
+  B.Stmt ("select * from " <> fromQi qi <> "(" <> args <> ")") empty True
+  where
+    assignment (n,v) = pgFmtIdent n <> ":=" <> insertableValue v
+
+wherePred :: QualifiedIdentifier -> Net.QueryItem -> PStmt
+wherePred table (col, predicate) =
+  B.Stmt (notOp <> " " <> pgFmtJsonbPath table (cs col) <> " " <> op <> " " <>
      if opCode `elem` ["is","isnot"] then whiteList value
                                 else cs sqlValue)
      empty True

  where
-    opCode:rest = T.split (=='.') $ cs $ fromMaybe "." predicate
-    value = T.intercalate "." rest
-    whiteList val = fromMaybe (cs (pgFmtLit val) <> "::unknown ")
-                              (L.find ((==) . T.toLower $ val)
-                                      ["null","true","false"])
+    headPredicate:rest = T.split (=='.') $ cs $ fromMaybe "." predicate
+    hasNot caseTrue caseFalse = if headPredicate == "not" then caseTrue else caseFalse
+    opCode        = hasNot (head rest) headPredicate
+    notOp         = hasNot headPredicate ""
+    value         = hasNot (T.intercalate "." $ tail rest) (T.intercalate "." rest)
+    sqlValue = pgFmtValue opCode value
+    op = pgFmtOperator opCode
+
+
+whiteList :: T.Text -> T.Text
+whiteList val = fromMaybe
+  (cs (pgFmtLit val) <> "::unknown ")
+  (L.find ((==) . T.toLower $ val) ["null","true","false"])
+
+pgFmtValue :: T.Text -> T.Text -> T.Text
+pgFmtValue opCode value =
+  case opCode of
+    "like" -> unknownLiteral $ T.map star value
+    "ilike" -> unknownLiteral $ T.map star value
+    "in" -> "(" <> T.intercalate ", " (map unknownLiteral $ T.split (==',') value) <> ") "
+    "notin" -> "(" <> T.intercalate ", " (map unknownLiteral $ T.split (==',') value) <> ") "
+    "@@" -> "to_tsquery(" <> unknownLiteral value <> ") "
+    _    -> unknownLiteral value
+  where
    star c = if c == '*' then '%' else c
    unknownLiteral = (<> "::unknown ") . pgFmtLit

-    sqlValue = case opCode of
-            "like" -> unknownLiteral $ T.map star value
-            "ilike" -> unknownLiteral $ T.map star value
-            "in" -> "(" <> T.intercalate ", " (map unknownLiteral $ T.split (==',') value) <> ") "
-            _    -> unknownLiteral value
-
-    op = case opCode of
-         "eq"  -> "="
-         "gt"  -> ">"
-         "lt"  -> "<"
-         "gte" -> ">="
-         "lte" -> "<="
-         "neq" -> "<>"
-         "like"-> "like"
-         "ilike"-> "ilike"
-         "in"  -> "in"
-         "is"    -> "is"
-         "isnot" -> "is not"
-         _     -> "="
-
-orderParse :: Net.Query -> [OrderTerm]
-orderParse q =
-  mapMaybe orderParseTerm . T.split (==',') $ cs order
-  where
-    order = fromMaybe "" $ join (lookup "order" q)
-
-orderParseTerm :: T.Text -> Maybe OrderTerm
-orderParseTerm s =
-  case T.split (=='.') s of
-       (c:d:nls) ->
-         if d `elem` ["asc", "desc"]
-            then Just $ OrderTerm c
-              ( if d == "asc" then "asc" else "desc" )
-              ( case nls of
-                  [n] -> if | n == "nullsfirst" -> Just "nulls first"
-                            | n == "nullslast"  -> Just "nulls last"
-                            | otherwise -> Nothing
-                  _   -> Nothing
-              )
-            else Nothing
-       _ -> Nothing
+pgFmtOperator :: T.Text -> T.Text
+pgFmtOperator opCode =
+  case opCode of
+    "eq"  -> "="
+    "gt"  -> ">"
+    "lt"  -> "<"
+    "gte" -> ">="
+    "lte" -> "<="
+    "neq" -> "<>"
+    "like"-> "like"
+    "ilike"-> "ilike"
+    "in"  -> "in"
+    "notin" -> "not in"
+    "is"    -> "is"
+    "isnot" -> "is not"
+    "@@" -> "@@"
+    _     -> "="

 commaq :: PStmt
 commaq  = B.Stmt ", " empty True
@@ -236,11 +252,11 @@ parseJsonbPath p =
        (KeyIdentifier b)
    _ -> Nothing

-pgFmtJsonbPath :: T.Text -> T.Text
-pgFmtJsonbPath p =
+pgFmtJsonbPath :: QualifiedIdentifier -> T.Text -> T.Text
+pgFmtJsonbPath table p =
  pgFmtJsonbPath' $ fromMaybe (ColIdentifier p) (parseJsonbPath p)
  where
-    pgFmtJsonbPath' (ColIdentifier i) = pgFmtIdent i
+    pgFmtJsonbPath' (ColIdentifier i) = fromQi table <> "." <> pgFmtIdent i
    pgFmtJsonbPath' (KeyIdentifier i) = pgFmtLit i
    pgFmtJsonbPath' (SingleArrow a b) =
      pgFmtJsonbPath' a <> "->" <> pgFmtJsonbPath' b
@@ -250,26 +266,26 @@ pgFmtJsonbPath p =
 pgFmtIdent :: T.Text -> T.Text
 pgFmtIdent x =
  let escaped = T.replace "\"" "\"\"" (trimNullChars $ cs x) in
-  if escaped =~ danger
+  if (cs escaped :: BS.ByteString) =~ danger
    then "\"" <> escaped <> "\""
    else escaped

-  where danger = "^$|^[^a-z_]|[^a-z_0-9]" :: T.Text
+  where danger = "^$|^[^a-z_]|[^a-z_0-9]" :: BS.ByteString

 pgFmtLit :: T.Text -> T.Text
 pgFmtLit x =
  let trimmed = trimNullChars x
      escaped = "'" <> T.replace "'" "''" trimmed <> "'"
      slashed = T.replace "\\" "\\\\" escaped in
-  cs $ if escaped =~ ("\\\\" :: T.Text)
+  if T.isInfixOf "\\\\" escaped
    then "E" <> slashed
    else slashed

 trimNullChars :: T.Text -> T.Text
 trimNullChars = T.takeWhile (/= '\x0')

-fromQt :: QualifiedTable -> T.Text
-fromQt t = pgFmtIdent (qtSchema t) <> "." <> pgFmtIdent (qtName t)
+fromQi :: QualifiedIdentifier -> T.Text
+fromQi t = pgFmtIdent (qiSchema t) <> "." <> pgFmtIdent (qiName t)

 unquoted :: JSON.Value -> T.Text
 unquoted (JSON.String t) = t
@@ -1,175 +1,264 @@
-{-# LANGUAGE QuasiQuotes, OverloadedStrings, TypeSynonymInstances,
-             MultiParamTypeClasses, ScopedTypeVariables,
-             FlexibleContexts #-}
+{-# LANGUAGE FlexibleContexts      #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE QuasiQuotes           #-}
+{-# LANGUAGE ScopedTypeVariables   #-}
+{-# LANGUAGE TypeSynonymInstances  #-}
 module PostgREST.PgStructure where

-import PostgREST.PgQuery (QualifiedTable(..))
-import Data.Text hiding (foldl, map, zipWith, concat)
-import Data.Aeson
-import Data.Functor.Identity
-import Data.String.Conversions (cs)
-import Data.Maybe (fromMaybe)
-import Control.Applicative
+import           Control.Applicative
+import           Control.Monad         (join)
+import           Data.Functor.Identity
+import           Data.List             (elemIndex, find)
+import           Data.Maybe            (fromMaybe, isJust, mapMaybe)
+import           Data.Monoid
+import           Data.Text             (Text, split)
+import qualified Hasql                 as H
+import qualified Hasql.Postgres        as P
+import           PostgREST.PgQuery     ()
+import           PostgREST.Types

-import qualified Data.Map as Map
+import           GHC.Exts              (groupWith)
+import           Prelude

-import qualified Hasql as H
-import qualified Hasql.Postgres as P

-import Prelude
+doesProcExist :: Text -> Text -> H.Tx P.Postgres s Bool
+doesProcExist schema proc = do
+  row :: Maybe (Identity Int) <- H.maybeEx $ [H.stmt|
+      SELECT 1
+      FROM   pg_catalog.pg_namespace n
+      JOIN   pg_catalog.pg_proc p
+      ON     pronamespace = n.oid
+      WHERE  nspname = ?
+      AND    proname = ?
+    |] schema proc
+  return $ isJust row

-foreignKeys :: QualifiedTable -> H.Tx P.Postgres s (Map.Map Text ForeignKey)
-foreignKeys table = do
-  r <- H.listEx $ [H.stmt|
-      select kcu.column_name, ccu.table_name AS foreign_table_name,
-        ccu.column_name AS foreign_column_name
-      from information_schema.table_constraints AS tc
-        join information_schema.key_column_usage AS kcu
-          on tc.constraint_name = kcu.constraint_name
-        join information_schema.constraint_column_usage AS ccu
-          on ccu.constraint_name = tc.constraint_name
-      where constraint_type = 'FOREIGN KEY'
-        and tc.table_name=? and tc.table_schema = ?
-        order by kcu.column_name
-    |] (qtName table) (qtSchema table)

-  return $ foldl addKey Map.empty r
+tableFromRow :: (Text, Text, Bool, Maybe Text) -> Table
+tableFromRow (s, n, i, a) = Table s n i (parseAcl a)
  where
-    addKey :: Map.Map Text ForeignKey -> (Text, Text, Text) -> Map.Map Text ForeignKey
-    addKey m (col, ftab, fcol) = Map.insert col (ForeignKey ftab fcol) m
-
-
-tables :: Text -> H.Tx P.Postgres s [Table]
-tables schema = do
-  rows <- H.listEx $
-    [H.stmt|
-      select table_schema, table_name,
-             is_insertable_into
-        from information_schema.tables
-       where table_schema = ?
-       order by table_name
-    |] schema
-  return $ map tableFromRow rows
-
-
-columns :: QualifiedTable -> H.Tx P.Postgres s [Column]
-columns table = do
-  cols <- H.listEx $ [H.stmt|
-      select info.table_schema as schema, info.table_name as table_name,
-             info.column_name as name, info.ordinal_position as position,
-             info.is_nullable as nullable, info.data_type as col_type,
-             info.is_updatable as updatable,
-             info.character_maximum_length as max_len,
-             info.numeric_precision as precision,
-             info.column_default as default_value,
-             array_to_string(enum_info.vals, ',') as enum
-         from (
-           select table_schema, table_name, column_name, ordinal_position,
-                  is_nullable, data_type, is_updatable,
-                  character_maximum_length, numeric_precision,
-                  column_default, udt_name
-             from information_schema.columns
-            where table_schema = ? and table_name = ?
-         ) as info
-         left outer join (
-           select n.nspname as s,
-                  t.typname as n,
-                  array_agg(e.enumlabel ORDER BY e.enumsortorder) as vals
-           from pg_type t
-              join pg_enum e on t.oid = e.enumtypid
-              join pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-           group by s, n
-         ) as enum_info
-         on (info.udt_name = enum_info.n)
-      order by position |]
-    (qtSchema table) (qtName table)
-
-  fks <- foreignKeys table
-  return $ map (addFK fks . columnFromRow) cols
-
-  where
-    addFK fks col = col { colFK = Map.lookup (cs . colName $ col) fks }
-
-
-primaryKeyColumns :: QualifiedTable -> H.Tx P.Postgres s [Text]
-primaryKeyColumns table = do
-  r <- H.listEx $ [H.stmt|
-    select kc.column_name
-      from
-        information_schema.table_constraints tc,
-        information_schema.key_column_usage kc
-    where
-      tc.constraint_type = 'PRIMARY KEY'
-      and kc.table_name = tc.table_name and kc.table_schema = tc.table_schema
-      and kc.constraint_name = tc.constraint_name
-      and kc.table_schema = ?
-      and kc.table_name  = ? |] (qtSchema table) (qtName table)
-  return $ map runIdentity r
-
-
-toBool :: Text -> Bool
-toBool = (== "YES")
-
-data Table = Table {
-  tableSchema :: Text
-, tableName :: Text
-, tableInsertable :: Bool
-} deriving (Show)
-
-data ForeignKey = ForeignKey {
-  fkTable::Text, fkCol::Text
-} deriving (Eq, Show)
-
-data Column = Column {
-  colSchema :: Text
-, colTable :: Text
-, colName :: Text
-, colPosition :: Int
-, colNullable :: Bool
-, colType :: Text
-, colUpdatable :: Bool
-, colMaxLen :: Maybe Int
-, colPrecision :: Maybe Int
-, colDefault :: Maybe Text
-, colEnum :: [Text]
-, colFK :: Maybe ForeignKey
-} deriving (Show)
-
-tableFromRow :: (Text, Text, Text) -> Table
-tableFromRow (s, n, i) = Table s n (toBool i)
+    parseAcl :: Maybe Text -> [Text]
+    parseAcl str = fromMaybe [] $ split (==',') <$> str

 columnFromRow :: (Text,       Text,      Text,
-                  Int,        Text,      Text,
-                  Text,       Maybe Int, Maybe Int,
+                  Int,        Bool,      Text,
+                  Bool,       Maybe Int, Maybe Int,
                  Maybe Text, Maybe Text)
              -> Column
 columnFromRow (s, t, n, pos, nul, typ, u, l, p, d, e) =
-  Column s t n pos (toBool nul) typ (toBool u) l p d (parseEnum e) Nothing
+  Column s t n pos nul typ u l p d (parseEnum e) Nothing

  where
    parseEnum :: Maybe Text -> [Text]
    parseEnum str = fromMaybe [] $ split (==',') <$> str


-instance ToJSON Column where
-  toJSON c = object [
-      "schema"    .= colSchema c
-    , "name"      .= colName c
-    , "position"  .= colPosition c
-    , "nullable"  .= colNullable c
-    , "type"      .= colType c
-    , "updatable" .= colUpdatable c
-    , "maxLen"    .= colMaxLen c
-    , "precision" .= colPrecision c
-    , "references".= colFK c
-    , "default"   .= colDefault c
-    , "enum"      .= colEnum c ]
+relationFromRow :: (Text, Text, [Text], Text, [Text]) -> Relation
+relationFromRow (s, t, cs, ft, fcs) = Relation s t cs ft fcs Child Nothing Nothing Nothing

-instance ToJSON ForeignKey where
-  toJSON fk = object ["table".=fkTable fk, "column".=fkCol fk]
+pkFromRow :: (Text, Text, Text) -> PrimaryKey
+pkFromRow (s, t, n) = PrimaryKey s t n

-instance ToJSON Table where
-  toJSON v = object [
-      "schema"     .= tableSchema v
-    , "name"       .= tableName v
-    , "insertable" .= tableInsertable v ]
+
+addParentRelation :: Relation -> [Relation] -> [Relation]
+addParentRelation rel@(Relation s t c ft fc _ _ _ _) rels = Relation s ft fc t c Parent Nothing Nothing Nothing:rel:rels
+
+allTables :: H.Tx P.Postgres s [Table]
+allTables = do
+    rows <- H.listEx $ [H.stmt|
+      SELECT
+        n.nspname AS table_schema,
+        c.relname AS table_name,
+        c.relkind = 'r' OR (c.relkind IN ('v','f'))
+        AND (pg_relation_is_updatable(c.oid::regclass, FALSE) & 8) = 8
+        OR (EXISTS
+          ( SELECT 1
+            FROM pg_trigger
+            WHERE pg_trigger.tgrelid = c.oid
+            AND (pg_trigger.tgtype::integer & 69) = 69) ) AS insertable,
+        array_to_string(array_agg(r.rolname), ',') AS acl
+      FROM pg_class c
+      CROSS JOIN pg_roles r
+      JOIN pg_namespace n ON n.oid = c.relnamespace
+      WHERE c.relkind IN ('v','r','m')
+        AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+        AND (
+          pg_has_role(r.rolname, c.relowner, 'USAGE'::text) OR
+          has_table_privilege(r.rolname, c.oid, 'SELECT, INSERT, UPDATE, DELETE, TRUNCATE, REFERENCES, TRIGGER'::text) OR
+          has_any_column_privilege(r.rolname, c.oid, 'SELECT, INSERT, UPDATE, REFERENCES'::text) )
+
+      GROUP BY table_schema, table_name, insertable
+      ORDER BY table_schema, table_name
+    |]
+    return $ map tableFromRow rows
+
+allRelations :: H.Tx P.Postgres s [Relation]
+allRelations = do
+  rels <- H.listEx $ [H.stmt|
+    WITH table_fk AS (
+        SELECT ns.nspname AS table_schema,
+               tab.relname AS table_name,
+               column_info.cols AS columns,
+               other.relname AS foreign_table_name,
+               column_info.refs AS foreign_columns
+        FROM pg_constraint,
+           LATERAL (SELECT array_agg(cols.attname) AS cols,
+                           array_agg(cols.attnum)  AS nums,
+                           array_agg(refs.attname) AS refs
+                      FROM ( SELECT unnest(conkey) AS col, unnest(confkey) AS ref) k,
+                           LATERAL (SELECT * FROM pg_attribute
+                                     WHERE attrelid = conrelid AND attnum = col)
+                                AS cols,
+                           LATERAL (SELECT * FROM pg_attribute
+                                     WHERE attrelid = confrelid AND attnum = ref)
+                                AS refs)
+                AS column_info,
+           LATERAL (SELECT * FROM pg_namespace
+                            WHERE pg_namespace.oid = connamespace) AS ns,
+           LATERAL (SELECT * FROM pg_class WHERE pg_class.oid = conrelid) AS tab,
+           LATERAL (SELECT * FROM pg_class WHERE pg_class.oid = confrelid) AS other
+        WHERE confrelid != 0
+        ORDER BY (conrelid, column_info.nums)
+    )
+
+    SELECT * FROM table_fk
+    UNION
+    (
+        SELECT
+            vcu.table_schema,
+            vcu.view_name AS table_name,
+            array_agg(vcu.column_name::text) AS columns,
+            table_fk.foreign_table_name,
+            table_fk.foreign_columns
+        FROM information_schema.view_column_usage as vcu
+        JOIN table_fk ON
+            table_fk.table_schema = vcu.view_schema AND
+            table_fk.table_name = vcu.table_name AND
+            vcu.column_name = ANY (table_fk.columns)
+        WHERE vcu.view_schema NOT IN ('pg_catalog', 'information_schema')
+        AND columns = table_fk.columns
+        GROUP BY vcu.table_schema, vcu.view_name, table_fk.foreign_table_name, table_fk.foreign_columns
+    )
+    UNION
+    (
+        SELECT
+            vcu.view_schema as table_schema,
+            table_fk.table_name,
+            table_fk.columns,
+            vcu.view_name as foreign_table_name,
+            array_agg(vcu.column_name::text) as foreign_columns
+        FROM information_schema.view_column_usage as vcu
+        JOIN table_fk ON
+            table_fk.table_schema = vcu.view_schema AND
+            table_fk.foreign_table_name = vcu.table_name AND
+            vcu.column_name = ANY (table_fk.foreign_columns)
+        WHERE vcu.view_schema NOT IN ('pg_catalog', 'information_schema')
+            AND foreign_columns = table_fk.foreign_columns
+        GROUP BY vcu.view_schema, table_fk.table_name, vcu.view_name, table_fk.columns
+    )
+  |]
+  let simpleRelations = foldr (addParentRelation.relationFromRow) [] rels
+  let links = filter ((==2).length) $ groupWith groupFn $ filter ( (==Child). relType) simpleRelations
+  return $ simpleRelations ++ mapMaybe link2Relation links
+  where
+    groupFn :: Relation -> Text
+    groupFn (Relation{relSchema=s, relTable=t}) = s<>"_"<>t
+    link2Relation [
+      Relation{relSchema=sc, relTable=lt, relColumns=lc1, relFTable=t, relFColumns=c},
+      Relation{                           relColumns=lc2, relFTable=ft, relFColumns=fc}
+      ] = Just $ Relation sc t c ft fc Many (Just lt) (Just lc1) (Just lc2)
+    link2Relation _ = Nothing
+
+allColumns :: [Relation] -> H.Tx P.Postgres s [Column]
+allColumns rels = do
+  cols <- H.listEx $ [H.stmt|
+      SELECT
+          info.table_schema AS schema,
+          info.table_name AS table_name,
+          info.column_name AS name,
+          info.ordinal_position AS position,
+          info.is_nullable::boolean AS nullable,
+          info.data_type AS col_type,
+          info.is_updatable::boolean AS updatable,
+          info.character_maximum_length AS max_len,
+          info.numeric_precision AS precision,
+          info.column_default AS default_value,
+          array_to_string(enum_info.vals, ',') AS enum
+      FROM (
+          SELECT
+              table_schema,
+              table_name,
+              column_name,
+              ordinal_position,
+              is_nullable,
+              data_type,
+              is_updatable,
+              character_maximum_length,
+              numeric_precision,
+              column_default,
+              udt_name
+          FROM information_schema.columns
+          WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
+      ) AS info
+      LEFT OUTER JOIN (
+          SELECT
+              n.nspname AS s,
+              t.typname AS n,
+              array_agg(e.enumlabel ORDER BY e.enumsortorder) AS vals
+          FROM pg_type t
+          JOIN pg_enum e ON t.oid = e.enumtypid
+          JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+          GROUP BY s,n
+      ) AS enum_info ON (info.udt_name = enum_info.n)
+      ORDER BY schema, position
+  |]
+  return $ map (addFK . columnFromRow) cols
+
+  where
+    addFK col = col { colFK = fk col }
+    fk col = join $ relToFk (colName col) <$> find (lookupFn col) rels
+    lookupFn :: Column -> Relation -> Bool
+    lookupFn (Column{colSchema=cs, colTable=ct, colName=cn})  (Relation{relSchema=rs, relTable=rt, relColumns=rc, relType=rty}) =
+      cs==rs && ct==rt && cn `elem` rc && rty==Child
+    lookupFn _ _ = False
+    relToFk cName (Relation{relFTable=t, relColumns=cs, relFColumns=fcs}) = ForeignKey t <$> c
+      where
+        pos = elemIndex cName cs
+        c = (fcs !!) <$> pos
+
+allPrimaryKeys :: H.Tx P.Postgres s [PrimaryKey]
+allPrimaryKeys = do
+  pks <- H.listEx $ [H.stmt|
+    WITH table_pk AS (
+        SELECT
+            kc.table_schema,
+            kc.table_name,
+            kc.column_name
+        FROM
+            information_schema.table_constraints tc,
+            information_schema.key_column_usage kc
+        WHERE
+            tc.constraint_type = 'PRIMARY KEY' AND
+            kc.table_name = tc.table_name AND
+            kc.table_schema = tc.table_schema AND
+            kc.constraint_name = tc.constraint_name AND
+            kc.table_schema NOT IN ('pg_catalog', 'information_schema')
+    )
+    SELECT table_schema,
+           table_name,
+           column_name
+    FROM table_pk
+    UNION (
+        SELECT
+            vcu.view_schema,
+            vcu.view_name,
+            vcu.column_name
+         FROM information_schema.view_column_usage AS vcu
+         JOIN
+            table_pk ON table_pk.table_schema = vcu.view_schema AND
+            table_pk.table_name = vcu.table_name AND
+            table_pk.column_name = vcu.column_name
+         WHERE vcu.view_schema NOT IN ('pg_catalog','information_schema')
+    )
+    |]
+  return $ map pkFromRow pks
@@ -0,0 +1,165 @@
+module PostgREST.QueryBuilder
+where
+
+
+import           Control.Error
+import           Data.List         (find)
+import           Data.Monoid
+import           Data.Text         hiding (filter, find, foldr, head, last, map,
+                                    null, zipWith)
+import           Control.Applicative
+import           Data.Tree
+import           PostgREST.PgQuery (PStmt, fromQi,
+                                    orderT, pgFmtIdent, pgFmtLit, pgFmtOperator,
+                                    pgFmtValue, whiteList)
+import           PostgREST.Types
+import qualified Data.Vector       as V (empty)
+import qualified Hasql.Backend     as B
+
+findRelation :: [Relation] -> Text -> Text -> Text -> Maybe Relation
+findRelation allRelations s t1 t2 =
+  find (\r -> s == relSchema r && t1 == relTable r && t2 == relFTable r) allRelations
+
+addRelations :: Text -> [Relation] -> Maybe ApiRequest -> ApiRequest -> Either Text ApiRequest
+addRelations schema allRelations parentNode node@(Node query@(Select {mainTable=table}) forest) =
+  case parentNode of
+    Nothing -> Node query{relation=Nothing} <$> updatedForest
+    (Just (Node (Select{mainTable=parentTable}) _)) -> Node <$> (addRel query <$> rel) <*> updatedForest
+      where
+        rel = note ("no relation between " <> table <> " and " <> parentTable)
+            $  findRelation allRelations schema table parentTable
+           <|> findRelation allRelations schema parentTable table
+        addRel :: Query -> Relation -> Query
+        addRel q r = q{relation = Just r}
+  where
+    updatedForest = mapM (addRelations schema allRelations (Just node)) forest
+
+getJoinConditions :: Relation -> [Filter]
+getJoinConditions (Relation s t cs ft fcs typ lt lc1 lc2) =
+  case typ of
+    Child  -> zipWith (toFilter t ft) cs fcs
+    Parent -> zipWith (toFilter t ft) cs fcs
+    Many   -> zipWith (toFilter t (fromMaybe "" lt)) cs (fromMaybe [] lc1) ++ zipWith (toFilter ft (fromMaybe "" lt)) fcs (fromMaybe [] lc2)
+  where
+    toFilter :: Text -> Text -> FieldName -> FieldName -> Filter
+    toFilter tb ftb c fc = Filter (c, Nothing) "=" (VForeignKey (QualifiedIdentifier s tb) (ForeignKey ftb fc))
+
+addJoinConditions :: Text -> [Column] -> ApiRequest -> Either Text ApiRequest
+addJoinConditions schema allColumns (Node query@(Select{relation=r}) forest) =
+  case r of
+    Nothing -> Node updatedQuery  <$> updatedForest -- this is the root node
+    Just rel@(Relation{relType=Child}) -> Node (addCond updatedQuery (getJoinConditions rel)) <$> updatedForest
+    Just (Relation{relType=Parent}) -> Node updatedQuery <$> updatedForest
+    Just rel@(Relation{relType=Many, relLTable=(Just linkTable)}) ->
+      Node <$> pure qq <*> updatedForest
+      where
+         q = addCond updatedQuery (getJoinConditions rel)
+         qq = q{joinTables=linkTable:joinTables q}
+    _ -> Left "unknow relation"
+  where
+    -- add parentTable and parentJoinConditions to the query
+    updatedQuery = foldr (flip addCond) (query{joinTables = parentTables ++ joinTables query}) parentJoinConditions
+      where
+        parentJoinConditions = map (getJoinConditions.snd) parents
+        parentTables = map fst parents
+        parents = mapMaybe (getParents.rootLabel) forest
+        getParents qq@(Select{relation=(Just rel@(Relation{relType=Parent}))}) = Just (mainTable qq, rel)
+        getParents _ = Nothing
+    updatedForest = mapM (addJoinConditions schema allColumns) forest
+    addCond q con = q{filters=con ++ filters q}
+
+requestToCountQuery :: Text -> ApiRequest -> PStmt
+requestToCountQuery schema (Node (Select mainTbl _ _ conditions _ _) _) =
+  B.Stmt query V.empty True
+  where
+    query = Data.Text.unwords [
+      "SELECT pg_catalog.count(1)",
+      "FROM ", fromQi $ QualifiedIdentifier schema mainTbl,
+      ("WHERE " <> intercalate " AND " ( map (pgFmtCondition (QualifiedIdentifier schema mainTbl)) localConditions )) `emptyOnNull` localConditions
+      ]
+    emptyOnNull val x = if null x then "" else val
+    localConditions = filter fn conditions
+      where
+        fn  (Filter{value=VText _}) = True
+        fn  (Filter{value=VForeignKey _ _}) = False
+
+requestToQuery :: Text -> ApiRequest -> PStmt
+requestToQuery schema (Node (Select mainTbl colSelects tbls conditions ord _) forest) =
+  orderT (fromMaybe [] ord)  query
+  where
+    query = B.Stmt qStr V.empty True
+    qStr = Data.Text.unwords [
+      ("WITH " <> intercalate ", " withs) `emptyOnNull` withs,
+      "SELECT ", intercalate ", " (map (pgFmtSelectItem (QualifiedIdentifier schema mainTbl)) colSelects ++ selects),
+      "FROM ", intercalate ", " (map (fromQi . QualifiedIdentifier schema) (mainTbl:tbls)),
+      ("WHERE " <> intercalate " AND " ( map (pgFmtCondition (QualifiedIdentifier schema mainTbl) ) conditions )) `emptyOnNull` conditions
+      ]
+    emptyOnNull val x = if null x then "" else val
+    (withs, selects) = foldr getQueryParts ([],[]) forest
+    getQueryParts :: Tree Query -> ([Text], [Text]) -> ([Text], [Text])
+    getQueryParts (Node q@(Select{mainTable=table, relation=(Just (Relation {relType=Child}))}) forst) (w,s) = (w,sel:s)
+      where
+        sel = "("
+           <> "SELECT array_to_json(array_agg(row_to_json("<>table<>"))) "
+           <> "FROM (" <> subquery <> ") " <> table
+           <> ") AS " <> table
+           where (B.Stmt subquery _ _) = requestToQuery schema (Node q forst)
+
+    getQueryParts (Node q@(Select{mainTable=table, relation=(Just (Relation{relType=Parent}))}) forst) (w,s) = (wit:w,sel:s)
+      where
+        sel = "row_to_json(" <> table <> ".*) AS "<>table --TODO must be singular
+        wit = table <> " AS ( " <> subquery <> " )"
+          where (B.Stmt subquery _ _) = requestToQuery schema (Node q forst)
+
+    getQueryParts (Node q@(Select{mainTable=table, relation=(Just (Relation {relType=Many}))}) forst) (w,s) = (w,sel:s)
+      where
+        sel = "("
+           <> "SELECT array_to_json(array_agg(row_to_json("<>table<>"))) "
+           <> "FROM (" <> subquery <> ") " <> table
+           <> ") AS " <> table
+           where (B.Stmt subquery _ _) = requestToQuery schema (Node q forst)
+
+    -- the following is just to remove the warning
+    --getQueryParts is not total but requestToQuery is called only after addJoinConditions which ensures the only
+    --posible relations are Child Parent Many
+    getQueryParts (Node (Select{relation=Nothing}) _) _ = undefined
+
+pgFmtCondition :: QualifiedIdentifier -> Filter -> Text
+pgFmtCondition table (Filter (col,jp) ops val) =
+  notOp <> " " <> sqlCol  <> " " <> pgFmtOperator opCode <> " " <>
+    if opCode `elem` ["is","isnot"] then whiteList (getInner val) else sqlValue
+  where
+    headPredicate:rest = split (=='.') ops
+    hasNot caseTrue caseFalse = if headPredicate == "not" then caseTrue else caseFalse
+    opCode      = hasNot (head rest) headPredicate
+    notOp       = hasNot headPredicate ""
+    sqlCol = case val of
+      VText _ -> pgFmtColumn table col <> pgFmtJsonPath jp
+      VForeignKey qi _ -> pgFmtColumn qi col
+    sqlValue = valToStr val
+    getInner v = case v of
+      VText s -> s
+      _      -> ""
+    valToStr v = case v of
+      VText s -> pgFmtValue opCode s
+      VForeignKey (QualifiedIdentifier s _) (ForeignKey ft fc) -> pgFmtColumn (QualifiedIdentifier s ft) fc
+
+pgFmtColumn :: QualifiedIdentifier -> Text -> Text
+pgFmtColumn table "*" = fromQi table <> ".*"
+pgFmtColumn table c = fromQi table <> "." <> pgFmtIdent c
+
+pgFmtJsonPath :: Maybe JsonPath -> Text
+pgFmtJsonPath (Just [x]) = "->>" <> pgFmtLit x
+pgFmtJsonPath (Just (x:xs)) = "->" <> pgFmtLit x <> pgFmtJsonPath ( Just xs )
+pgFmtJsonPath _ = ""
+
+pgFmtTable :: Table -> Text
+pgFmtTable Table{tableSchema=s, tableName=n} = fromQi $ QualifiedIdentifier s n
+
+pgFmtSelectItem :: QualifiedIdentifier -> SelectItem -> Text
+pgFmtSelectItem table ((c, jp), Nothing) = pgFmtColumn table c <> pgFmtJsonPath jp <> asJsonPath jp
+pgFmtSelectItem table ((c, jp), Just cast ) = "CAST (" <> pgFmtColumn table c <> pgFmtJsonPath jp <> " AS " <> cast <> " )" <> asJsonPath jp
+
+asJsonPath :: Maybe JsonPath -> Text
+asJsonPath Nothing = ""
+asJsonPath (Just xx) = " AS " <> last xx
@@ -6,21 +6,22 @@ module PostgREST.RangeQuery (
 , NonnegRange
 ) where

-import Control.Applicative
-import Network.HTTP.Types.Header

-import qualified Data.ByteString.Char8 as BS
+import           Control.Applicative
+import           Network.HTTP.Types.Header
+import           PostgREST.Types           ()

-import Data.Ranged.Boundaries
-import Data.Ranged.Ranges
+import qualified Data.ByteString.Char8     as BS
+import           Data.Ranged.Boundaries
+import           Data.Ranged.Ranges

-import Data.String.Conversions (cs)
-import Text.Regex.TDFA ((=~))
-import Text.Read (readMaybe)
+import           Data.String.Conversions   (cs)
+import           Text.Read                 (readMaybe)
+import           Text.Regex.TDFA           ((=~))

-import Data.Maybe (fromMaybe, listToMaybe)
+import           Data.Maybe                (fromMaybe, listToMaybe)

-import Prelude
+import           Prelude

 type NonnegRange = Range Int

@@ -41,15 +42,15 @@ rangeRequested = (rangeParse =<<) . lookup hRange

 rangeLimit :: NonnegRange -> Maybe Int
 rangeLimit range =
-  case [rangeLower range, rangeUpper range]
-    of [BoundaryBelow from, BoundaryAbove to] -> Just (1 + to - from)
-       _ -> Nothing
+  case [rangeLower range, rangeUpper range] of
+    [BoundaryBelow from, BoundaryAbove to] -> Just (1 + to - from)
+    _ -> Nothing

 rangeOffset :: NonnegRange -> Int
 rangeOffset range =
-  case rangeLower range
-    of BoundaryBelow from -> from
-       _ -> error "range without lower bound" -- should never happen
+  case rangeLower range of
+    BoundaryBelow from -> from
+    _ -> error "range without lower bound" -- should never happen

 rangeGeq :: Int -> NonnegRange
 rangeGeq n =
@@ -0,0 +1,113 @@
+module PostgREST.Types where
+import Data.Text
+import Data.Tree
+import qualified Data.ByteString.Char8 as BS
+import Data.Aeson
+
+data DbStructure = DbStructure {
+  tables :: [Table]
+, columns :: [Column]
+, relations :: [Relation]
+, primaryKeys :: [PrimaryKey]
+}
+
+
+data Table = Table {
+  tableSchema :: Text
+, tableName :: Text
+, tableInsertable :: Bool
+, tableAcl :: [Text]
+} deriving (Show)
+
+data ForeignKey = ForeignKey {
+  fkTable::Text, fkCol::Text
+} deriving (Show, Eq)
+
+
+data Column = Column {
+  colSchema :: Text
+, colTable :: Text
+, colName :: Text
+, colPosition :: Int
+, colNullable :: Bool
+, colType :: Text
+, colUpdatable :: Bool
+, colMaxLen :: Maybe Int
+, colPrecision :: Maybe Int
+, colDefault :: Maybe Text
+, colEnum :: [Text]
+, colFK :: Maybe ForeignKey
+} | Star {colSchema :: Text, colTable :: Text } deriving (Show)
+
+data PrimaryKey = PrimaryKey {
+  pkSchema::Text, pkTable::Text, pkName::Text
+}
+
+data OrderTerm = OrderTerm {
+  otTerm :: Text
+, otDirection :: BS.ByteString
+, otNullOrder :: Maybe BS.ByteString
+} deriving (Show, Eq)
+
+data QualifiedIdentifier = QualifiedIdentifier {
+  qiSchema :: Text
+, qiName   :: Text
+} deriving (Show, Eq)
+
+
+data RelationType = Child | Parent | Many deriving (Show, Eq)
+data Relation = Relation {
+  relSchema  :: Text
+, relTable   :: Text
+, relColumns  :: [Text]
+, relFTable  :: Text
+, relFColumns :: [Text]
+, relType    :: RelationType
+, relLTable  :: Maybe Text
+, relLCols1   :: Maybe [Text]
+, relLCols2   :: Maybe [Text]
+} deriving (Show, Eq)
+
+
+type Operator = Text
+data FValue = VText Text | VForeignKey QualifiedIdentifier ForeignKey deriving (Show, Eq)
+type FieldName = Text
+type JsonPath = [Text]
+type Field = (FieldName, Maybe JsonPath)
+type Cast = Text
+type SelectItem = (Field, Maybe Cast)
+type Path = [Text]
+data Query = Select {
+  mainTable::Text
+, fields::[SelectItem]
+, joinTables::[Text]
+, filters::[Filter]
+, order::Maybe [OrderTerm]
+, relation::Maybe Relation
+} deriving (Show, Eq)
+data Filter = Filter {field::Field, operator::Operator, value::FValue} deriving (Show, Eq)
+type ApiRequest = Tree Query
+
+
+instance ToJSON Column where
+  toJSON c = object [
+      "schema"    .= colSchema c
+    , "name"      .= colName c
+    , "position"  .= colPosition c
+    , "nullable"  .= colNullable c
+    , "type"      .= colType c
+    , "updatable" .= colUpdatable c
+    , "maxLen"    .= colMaxLen c
+    , "precision" .= colPrecision c
+    , "references".= colFK c
+    , "default"   .= colDefault c
+    , "enum"      .= colEnum c ]
+
+instance ToJSON ForeignKey where
+  toJSON fk = object ["table".=fkTable fk, "column".=fkCol fk]
+
+instance ToJSON Table where
+  toJSON v = object [
+      "schema"     .= tableSchema v
+    , "name"       .= tableName v
+    , "insertable" .= tableInsertable v ]
@@ -0,0 +1,7 @@
+flags: {}
+packages:
+- '.'
+extra-deps: 
+  - Ranged-sets-0.3.0
+  - packdeps-0.4.1
+resolver: lts-3.10
@@ -24,23 +24,41 @@ spec = beforeAll
      `shouldRespondWith` 401

  it "allows users with permissions to see their tables (BasicAuth)" $ do
-    _ <- post "/postgrest/users" [json| { "id":"jdoe", "pass": "1234", "role": "postgrest_test_author" } |]
+    _ <- post "/postgrest/users" [json| { "id": "jdoe", "pass": "1234", "role": "postgrest_test_author" } |]
    let auth = authHeaderBasic "jdoe" "1234"
    request methodGet "/authors_only" [auth] ""
      `shouldRespondWith` 200
-      
+
+  it "respects database constraints for role" $
+    post "/postgrest/users" [json| { "id": "ssmith", "pass": "1234", "role": "SUPER_ADMIN_TRUNCATE_POWERS" } |]
+      `shouldRespondWith` 400
+
+  it "does not send a value when no role is provided" $ do
+    post "/postgrest/users" [json| { "id": "bdeey", "pass": "1234" } |]
+      `shouldRespondWith` 201
+    let auth = authHeaderBasic "jdoe" "1234"
+    request methodGet "/authors_only" [auth] ""
+      `shouldRespondWith` 200
+
+  it "recovers after 400 error with logged in user" $ do
+    _ <- post "/postgrest/users" [json| { "id": "jdoe", "pass": "1234", "role": "postgrest_test_author" } |]
+    let auth = authHeaderBasic "jdoe" "1234"
+    _ <- request methodPost "/rpc/problem" [auth] ""
+    request methodGet "/authors_only" [auth] ""
+      `shouldRespondWith` 200
+
  it "allows users to login (JWT)" $ do
-    _ <- post "/postgrest/users" [json| { "id":"jdoe", "pass": "1234", "role": "postgrest_test_author" } |]
-    post "/postgrest/tokens" [json| { "id":"jdoe", "pass": "1234" } |] 
+    _ <- post "/postgrest/users" [json| { "id": "jdoe", "pass": "1234", "role": "postgrest_test_author" } |]
+    post "/postgrest/tokens" [json| { "id": "jdoe", "pass": "1234" } |]
      `shouldRespondWith` ResponseMatcher {
          matchBody = Just [json| {"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyb2xlIjoicG9zdGdyZXN0X3Rlc3RfYXV0aG9yIiwiaWQiOiJqZG9lIn0.y4vZuu1dDdwAl0-S00MCRWRYMlJ5YAMSir6Es6WtWx0"} |]
        , matchStatus = 201
        , matchHeaders = ["Content-Type" <:> "application/json"]
        }
-      
+
  it "indicates login failure (JWT)" $ do
-    _ <- post "/postgrest/users" [json| { "id":"jdoe", "pass": "1234", "role": "postgrest_test_author" } |]
-    post "/postgrest/tokens" [json| { "id":"jdoe", "pass": "NOPE" } |] 
+    _ <- post "/postgrest/users" [json| { "id": "jdoe", "pass": "1234", "role": "postgrest_test_author" } |]
+    post "/postgrest/tokens" [json| { "id": "jdoe", "pass": "NOPE" } |]
      `shouldRespondWith` ResponseMatcher {
          matchBody = Just [json| {"message":"Failed authentication."} |]
        , matchStatus = 401
@@ -48,7 +66,7 @@ spec = beforeAll
        }

  it "allows users with permissions to see their tables (JWT)" $ do
-    _ <- post "/postgrest/users" [json| { "id":"jdoe", "pass": "1234", "role": "postgrest_test_author" } |]
+    _ <- post "/postgrest/users" [json| { "id": "jdoe", "pass": "1234", "role": "postgrest_test_author" } |]
    let auth = authHeaderJWT "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyb2xlIjoicG9zdGdyZXN0X3Rlc3RfYXV0aG9yIiwiaWQiOiJqZG9lIn0.y4vZuu1dDdwAl0-S00MCRWRYMlJ5YAMSir6Es6WtWx0"
    request methodGet "/authors_only" [auth] ""
-      `shouldRespondWith` 200
+      `shouldRespondWith` 200
@@ -22,7 +22,7 @@ spec = around withApp $ describe "CORS" $ do
          ("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/plain, */*; q=0.01"),
+          ("Accept", "text/csv, */*; q=0.01"),
          ("Accept-Language", "en-US,en;q=0.5"),
          ("Accept-Encoding", "gzip, deflate"),
          ("Referer", "http://localhost:8000/"),
@@ -87,12 +87,7 @@ spec = afterAll_ resetDb $ around withApp $ do

    context "with invalid json payload" $
      it "fails with 400 and error" $
-        post "/simple_pk" "}{ x = 2"
-          `shouldRespondWith` ResponseMatcher {
-            matchBody    = Just [json| {"message":"Failed to parse JSON payload. Failed reading: satisfy"} |]
-          , matchStatus  = 400
-          , matchHeaders = []
-          }
+        post "/simple_pk" "}{ x = 2" `shouldRespondWith` 400

    context "jsonb" . after_ (clearTable "json") $ do
      it "serializes nested object" $ do
@@ -266,6 +261,18 @@ spec = afterAll_ resetDb $ around withApp $ do
        liftIO $ simpleHeaders g
          `shouldSatisfy` matchHeader "Content-Range" "0-9/10"

+      it "can set a column to NULL" $ do
+        _ <- post "/no_pk" [json| { a: "keepme", b: "nullme" } |]
+        _ <- request methodPatch "/no_pk?b=eq.nullme" [] [json| { b: null } |]
+        get "/no_pk?a=eq.keepme" `shouldRespondWith`
+          [json| [{ a: "keepme", b: null }] |]
+
+      it "can update based on a computed column" $
+        request methodPatch
+          "/items?always_true=eq.false"
+          [("Prefer", "return=representation")]
+          [json| { id: 100 } |]
+          `shouldRespondWith` 404
      it "can provide a representation" $ do
        _ <- post "/items"
          [json| { id: 1 } |]
@@ -274,3 +281,23 @@ spec = afterAll_ resetDb $ around withApp $ do
          [("Prefer", "return=representation")]
          [json| { id: 99 } |]
          `shouldRespondWith` [json| [{id:99}] |]
+
+  describe "Row level permission" $
+    it "set user_id when inserting rows" $ do
+      _ <- post "/postgrest/users" [json| { "id":"jdoe", "pass": "1234", "role": "postgrest_test_author" } |]
+      _ <- post "/postgrest/users" [json| { "id":"jroe", "pass": "1234", "role": "postgrest_test_author" } |]
+
+      p1 <- request methodPost "/authors_only"
+        [ authHeaderBasic "jdoe" "1234", ("Prefer", "return=representation") ]
+        [json| { "secret": "nyancat" } |]
+      liftIO $ do
+          simpleBody p1 `shouldBe` [json| { "owner":"jdoe", "secret":"nyancat" } |]
+          simpleStatus p1 `shouldBe` created201
+
+      p2 <- request methodPost "/authors_only"
+        -- jwt token for jroe
+        [ authHeaderJWT "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyb2xlIjoicG9zdGdyZXN0X3Rlc3RfYXV0aG9yIiwiaWQiOiJqcm9lIn0.YuF_VfmyIxWyuceT7crnNKEprIYXsJAyXid3rjPjIow", ("Prefer", "return=representation") ]
+        [json| { "secret": "lolcat", "owner": "hacker" } |]
+      liftIO $ do
+          simpleBody p2 `shouldBe` [json| { "owner":"jroe", "secret":"lolcat" } |]
+          simpleStatus p2 `shouldBe` created201
@@ -1,8 +1,9 @@
 module Feature.QuerySpec where

-import Test.Hspec
+import Test.Hspec hiding (pendingWith)
 import Test.Hspec.Wai
 import Test.Hspec.Wai.JSON
+import Network.HTTP.Types
 import Network.Wai.Test (SResponse(simpleHeaders))

 import SpecHelper
@@ -10,13 +11,20 @@ import SpecHelper
 spec :: Spec
 spec =
  beforeAll (clearTable "items" >> createItems 15)
+   . beforeAll (clearTable "complex_items" >> createComplexItems)
+   . beforeAll (clearTable "nullable_integer" >> createNullInteger)
   . beforeAll (
       clearTable "no_pk" >>
       createNulls 2 >>
       createLikableStrings >>
       createJsonData)
-   . afterAll_ (clearTable "items" >> clearTable "no_pk" >> clearTable "simple_pk")
+   . afterAll_ (clearTable "items" >> clearTable "complex_items" >> clearTable "no_pk" >> clearTable "simple_pk")
   . around withApp $ do
+
+  describe "Querying a table with a column called count" $
+    it "should not confuse count column with pg_catalog.count aggregate" $
+      get "/has_count_column" `shouldRespondWith` 200
+
  describe "Querying a nonexistent table" $
    it "causes a 404" $
      get "/faketable" `shouldRespondWith` 404
@@ -30,6 +38,31 @@ spec =
        , matchHeaders = ["Content-Range" <:> "0-0/1"]
        }

+    it "matches with equality using not operator" $
+      get "/items?id=not.eq.5"
+        `shouldRespondWith` ResponseMatcher {
+          matchBody    = Just [json| [{"id":1},{"id":2},{"id":3},{"id":4},{"id":6},{"id":7},{"id":8},{"id":9},{"id":10},{"id":11},{"id":12},{"id":13},{"id":14},{"id":15}] |]
+        , matchStatus  = 200
+        , matchHeaders = ["Content-Range" <:> "0-13/14"]
+        }
+
+    it "matches with more than one condition using not operator" $
+      get "/simple_pk?k=like.*yx&extra=not.eq.u" `shouldRespondWith` "[]"
+
+    it "matches with inequality using not operator" $ do
+      get "/items?id=not.lt.14&order=id.asc"
+        `shouldRespondWith` ResponseMatcher {
+          matchBody    = Just [json| [{"id":14},{"id":15}] |]
+        , matchStatus  = 200
+        , matchHeaders = ["Content-Range" <:> "0-1/2"]
+        }
+      get "/items?id=not.gt.2&order=id.asc"
+        `shouldRespondWith` ResponseMatcher {
+          matchBody    = Just [json| [{"id":1},{"id":2}] |]
+        , matchStatus  = 200
+        , matchHeaders = ["Content-Range" <:> "0-1/2"]
+        }
+
    it "matches items IN" $
      get "/items?id=in.1,3,5"
        `shouldRespondWith` ResponseMatcher {
@@ -38,10 +71,32 @@ spec =
        , matchHeaders = ["Content-Range" <:> "0-2/3"]
        }

-    it "matches nulls" $
+    it "matches items NOT IN" $
+      get "/items?id=notin.2,4,6,7,8,9,10,11,12,13,14,15"
+        `shouldRespondWith` ResponseMatcher {
+          matchBody    = Just [json| [{"id":1},{"id":3},{"id":5}] |]
+        , matchStatus  = 200
+        , matchHeaders = ["Content-Range" <:> "0-2/3"]
+        }
+
+    it "matches items NOT IN using not operator" $
+      get "/items?id=not.in.2,4,6,7,8,9,10,11,12,13,14,15"
+        `shouldRespondWith` ResponseMatcher {
+          matchBody    = Just [json| [{"id":1},{"id":3},{"id":5}] |]
+        , matchStatus  = 200
+        , matchHeaders = ["Content-Range" <:> "0-2/3"]
+        }
+
+    it "matches nulls using not operator" $
+      get "/no_pk?a=not.is.null" `shouldRespondWith`
+        [json| [{"a":"1","b":"0"},{"a":"2","b":"0"}] |]
+
+    it "matches nulls in varchar and numeric fields alike" $ do
      get "/no_pk?a=is.null" `shouldRespondWith`
        [json| [{"a": null, "b": null}] |]

+      get "/nullable_integer?a=is.null" `shouldRespondWith` "[{\"a\":null}]"
+
    it "matches with like" $ do
      get "/simple_pk?k=like.*yx" `shouldRespondWith`
        "[{\"k\":\"xyyx\",\"extra\":\"u\"}]"
@@ -50,12 +105,104 @@ spec =
      get "/simple_pk?k=like.*YY*" `shouldRespondWith`
        "[{\"k\":\"xYYx\",\"extra\":\"v\"}]"

+    it "matches with like using not operator" $
+      get "/simple_pk?k=not.like.*yx" `shouldRespondWith`
+        "[{\"k\":\"xYYx\",\"extra\":\"v\"}]"
+
    it "matches with ilike" $ do
      get "/simple_pk?k=ilike.xy*&order=extra.asc" `shouldRespondWith`
        "[{\"k\":\"xyyx\",\"extra\":\"u\"},{\"k\":\"xYYx\",\"extra\":\"v\"}]"
      get "/simple_pk?k=ilike.*YY*&order=extra.asc" `shouldRespondWith`
        "[{\"k\":\"xyyx\",\"extra\":\"u\"},{\"k\":\"xYYx\",\"extra\":\"v\"}]"

+    it "matches with ilike using not operator" $
+      get "/simple_pk?k=not.ilike.xy*&order=extra.asc" `shouldRespondWith` "[]"
+
+    it "matches with tsearch @@" $
+      get "/tsearch?text_search_vector=@@.foo" `shouldRespondWith`
+        [json| [{"text_search_vector":"'bar':2 'foo':1"}] |]
+
+    it "matches with tsearch @@ using not operator" $
+      get "/tsearch?text_search_vector=not.@@.foo" `shouldRespondWith`
+        [json| [{"text_search_vector":"'baz':1 'qux':2"}] |]
+
+    it "matches with computed column" $
+      get "/items?always_true=eq.true" `shouldRespondWith`
+        [json| [{"id":1},{"id":2},{"id":3},{"id":4},{"id":5},{"id":6},{"id":7},{"id":8},{"id":9},{"id":10},{"id":11},{"id":12},{"id":13},{"id":14},{"id":15}] |]
+
+    it "matches filtering nested items" $
+      get "/clients?select=id,projects(id,tasks(id,name))&projects.tasks.name=like.Design*" `shouldRespondWith`
+        "[{\"id\":1,\"projects\":[{\"id\":1,\"tasks\":[{\"id\":1,\"name\":\"Design w7\"}]},{\"id\":2,\"tasks\":[{\"id\":3,\"name\":\"Design w10\"}]}]},{\"id\":2,\"projects\":[{\"id\":3,\"tasks\":[{\"id\":5,\"name\":\"Design IOS\"}]},{\"id\":4,\"tasks\":[{\"id\":7,\"name\":\"Design OSX\"}]}]}]"
+
+  describe "Shaping response with select parameter" $ do
+
+    it "selectStar works in absense of parameter" $
+      get "/complex_items?id=eq.3" `shouldRespondWith`
+        "[{\"id\":3,\"name\":\"Three\",\"settings\":{\"foo\":{\"int\":1,\"bar\":\"baz\"}}}]"
+
+    it "one simple column" $
+      get "/complex_items?select=id" `shouldRespondWith`
+        [json| [{"id":1},{"id":2},{"id":3}] |]
+
+    it "one simple column with casting (text)" $
+      get "/complex_items?select=id::text" `shouldRespondWith`
+        [json| [{"id":"1"},{"id":"2"},{"id":"3"}] |]
+
+    it "json column" $
+      get "/complex_items?id=eq.1&select=settings" `shouldRespondWith`
+        [json| [{"settings":{"foo":{"int":1,"bar":"baz"}}}] |]
+
+    it "json subfield one level with casting (json)" $
+      get "/complex_items?id=eq.1&select=settings->>foo::json" `shouldRespondWith`
+        [json| [{"foo":{"int":1,"bar":"baz"}}] |] -- the value of foo here is of type "text"
+
+    it "fails on bad casting (data of the wrong format)" $
+      get "/complex_items?select=settings->foo->>bar::integer"
+        `shouldRespondWith` ResponseMatcher {
+          matchBody    = Just [json| {"hint":null,"details":null,"code":"22P02","message":"invalid input syntax for integer: \"baz\""} |]
+        , matchStatus  = 400
+        , matchHeaders = []
+        }
+
+    it "fails on bad casting (wrong cast type)" $
+      get "/complex_items?select=id::fakecolumntype"
+        `shouldRespondWith` ResponseMatcher {
+          matchBody    = Just [json| {"hint":null,"details":null,"code":"42704","message":"type \"fakecolumntype\" does not exist"} |]
+        , matchStatus  = 400
+        , matchHeaders = []
+        }
+
+
+    it "json subfield two levels (string)" $
+      get "/complex_items?id=eq.1&select=settings->foo->>bar" `shouldRespondWith`
+        [json| [{"bar":"baz"}] |]
+
+
+    it "json subfield two levels with casting (int)" $
+      get "/complex_items?id=eq.1&select=settings->foo->>int::integer" `shouldRespondWith`
+        [json| [{"int":1}] |] -- the value in the db is an int, but here we expect a string for now
+
+    it "requesting parents and children" $
+      get "/projects?id=eq.1&select=id, name, clients(*), tasks(id, name)" `shouldRespondWith`
+        "[{\"id\":1,\"name\":\"Windows 7\",\"clients\":{\"id\":1,\"name\":\"Microsoft\"},\"tasks\":[{\"id\":1,\"name\":\"Design w7\"},{\"id\":2,\"name\":\"Code w7\"}]}]"
+
+    it "requesting children 2 levels" $
+      get "/clients?id=eq.1&select=id,projects(id,tasks(id))" `shouldRespondWith`
+        "[{\"id\":1,\"projects\":[{\"id\":1,\"tasks\":[{\"id\":1},{\"id\":2}]},{\"id\":2,\"tasks\":[{\"id\":3},{\"id\":4}]}]}]"
+
+    it "requesting many<->many relation" $
+      get "/tasks?select=id,users(id)" `shouldRespondWith`
+        "[{\"id\":1,\"users\":[{\"id\":1},{\"id\":3}]},{\"id\":2,\"users\":[{\"id\":1}]},{\"id\":3,\"users\":[{\"id\":1}]},{\"id\":4,\"users\":[{\"id\":1}]},{\"id\":5,\"users\":[{\"id\":2},{\"id\":3}]},{\"id\":6,\"users\":[{\"id\":2}]},{\"id\":7,\"users\":[{\"id\":2}]},{\"id\":8,\"users\":null}]"
+
+    it "requesting parents and children on views" $
+      get "/projects_view?id=eq.1&select=id, name, clients(*), tasks(id, name)" `shouldRespondWith`
+        "[{\"id\":1,\"name\":\"Windows 7\",\"clients\":{\"id\":1,\"name\":\"Microsoft\"},\"tasks\":[{\"id\":1,\"name\":\"Design w7\"},{\"id\":2,\"name\":\"Code w7\"}]}]"
+
+    it "requesting children with composite key" $
+      get "/users_tasks?user_id=eq.2&task_id=eq.6&select=*, comments(content)" `shouldRespondWith`
+        "[{\"user_id\":2,\"task_id\":6,\"comments\":[{\"content\":\"Needs to be delivered ASAP\"}]}]"
+
+
  describe "ordering response" $ do
    it "by a column asc" $
      get "/items?id=lte.2&order=id.asc"
@@ -103,7 +250,32 @@ spec =
        }

    it "without other constraints" $
-      get "/items?order=asc.id" `shouldRespondWith` 200
+      get "/items?order=id.asc" `shouldRespondWith` 200
+
+  describe "Accept headers" $ do
+    it "should respond an unknown accept type with 415" $
+      request methodGet "/simple_pk"
+              (acceptHdrs "text/unknowntype") ""
+        `shouldRespondWith` 415
+
+    it "should respond correctly to */* in accept header" $
+      request methodGet "/simple_pk"
+              (acceptHdrs "*/*") ""
+        `shouldRespondWith` 200
+
+    it "should respond correctly to multiple types in accept header" $
+      request methodGet "/simple_pk"
+              (acceptHdrs "text/unknowntype, text/csv") ""
+        `shouldRespondWith` 200
+
+    it "should respond with CSV to 'text/csv' request" $
+      request methodGet "/simple_pk"
+              (acceptHdrs "text/csv; version=1") ""
+        `shouldRespondWith` ResponseMatcher {
+          matchBody    = Just "k,extra\rxyyx,u\rxYYx,v"
+        , matchStatus  = 200
+        , matchHeaders = ["Content-Type" <:> "text/csv"]
+        }

  describe "Canonical location" $ do
    it "Sets Content-Location with alphabetized params" $
@@ -121,9 +293,24 @@ spec =
        respHeaders `shouldSatisfy` matchHeader
          "Content-Location" "/simple_pk"

-  describe "jsonb" $
+  describe "jsonb" $ do
    it "can filter by properties inside json column" $ do
      get "/json?data->foo->>bar=eq.baz" `shouldRespondWith`
        [json| [{"data": {"foo": {"bar": "baz"}}}] |]
      get "/json?data->foo->>bar=eq.fake" `shouldRespondWith`
        [json| [] |]
+    it "can filter by properties inside json column using not" $
+      get "/json?data->foo->>bar=not.eq.baz" `shouldRespondWith`
+        [json| [] |]
+
+  describe "remote procedure call" $ do
+    context "a proc that returns a set" . before_ (clearTable "items" >> createItems 10) .
+      after_ (clearTable "items") $
+      it "returns proper json" $
+        post "/rpc/getitemrange" [json| { "min": 2, "max": 4 } |] `shouldRespondWith`
+          [json| [ {"id": 3}, {"id":4} ] |]
+
+    context "a proc that returns plain text" $
+      it "returns proper json" $
+        post "/rpc/sayhello" [json| { "name": "world" } |] `shouldRespondWith`
+          [json| [{"sayhello":"Hello, world"}] |]
@@ -2,6 +2,7 @@ module Feature.RangeSpec where

 import Test.Hspec
 import Test.Hspec.Wai
+import Test.Hspec.Wai.JSON
 import Network.HTTP.Types
 import Network.Wai.Test (SResponse(simpleHeaders,simpleStatus))

@@ -12,11 +13,39 @@ spec = beforeAll (clearTable "items" >> createItems 15) . afterAll_ (clearTable
  . around withApp $
  describe "GET /items" $ do

-    context "without range headers" $
+    context "without range headers" $ do
      context "with response under server size limit" $
        it "returns whole range with status 200" $
          get "/items" `shouldRespondWith` 200

+      context "when I don't want the count" $ do
+        it "returns range Content-Range with /*" $
+          request methodGet "/menagerie"
+                  [("Prefer", "count=none")] ""
+            `shouldRespondWith` ResponseMatcher {
+              matchBody    = Just "[]"
+            , matchStatus  = 200
+            , matchHeaders = ["Content-Range" <:> "*/*"]
+            }
+
+        it "returns range Content-Range with range/*" $
+          request methodGet "/items?order=id"
+                  [("Prefer", "count=none")] ""
+            `shouldRespondWith` ResponseMatcher {
+              matchBody    = Just [json| [{"id":1},{"id":2},{"id":3},{"id":4},{"id":5},{"id":6},{"id":7},{"id":8},{"id":9},{"id":10},{"id":11},{"id":12},{"id":13},{"id":14},{"id":15}] |]
+            , matchStatus  = 200
+            , matchHeaders = ["Content-Range" <:> "0-14/*"]
+            }
+
+        it "returns range Content-Range with range/* even using other filters" $
+          request methodGet "/items?id=eq.1&order=id"
+                  [("Prefer", "count=none")] ""
+            `shouldRespondWith` ResponseMatcher {
+              matchBody    = Just [json| [{"id":1}] |]
+            , matchStatus  = 200
+            , matchHeaders = ["Content-Range" <:> "0-0/*"]
+            }
+
    context "with range headers" $ do

      context "of acceptable range" $ do
@@ -15,13 +15,27 @@ spec = around withApp $ do
      request methodGet "/" [] ""
        `shouldRespondWith` [json| [
          {"schema":"1","name":"auto_incrementing_pk","insertable":true}
+        , {"schema":"1","name":"clients","insertable":true}
+        , {"schema":"1","name":"comments","insertable":true}
+        , {"schema":"1","name":"complex_items","insertable":true}
        , {"schema":"1","name":"compound_pk","insertable":true}
+        , {"schema":"1","name":"has_count_column","insertable":false}
        , {"schema":"1","name":"has_fk","insertable":true}
+        , {"schema":"1","name":"insertable_view_with_join","insertable":true}
        , {"schema":"1","name":"items","insertable":true}
        , {"schema":"1","name":"json","insertable":true}
+        , {"schema":"1","name":"materialized_view","insertable":false}
        , {"schema":"1","name":"menagerie","insertable":true}
        , {"schema":"1","name":"no_pk","insertable":true}
+        , {"schema":"1","name":"nullable_integer","insertable":true}
+        , {"schema":"1","name":"projects","insertable":true}
+        , {"schema":"1","name":"projects_view","insertable":true}
        , {"schema":"1","name":"simple_pk","insertable":true}
+        , {"schema":"1","name":"tasks","insertable":true}
+        , {"schema":"1","name":"tsearch","insertable":true}
+        , {"schema":"1","name":"users","insertable":true}
+        , {"schema":"1","name":"users_projects","insertable":true}
+        , {"schema":"1","name":"users_tasks","insertable":true}
        ] |]
        {matchStatus = 200}

@@ -139,6 +153,102 @@ spec = around withApp $ do
      }
      |]

+    it "it includes primary and foreign keys for views" $
+      request methodOptions "/insertable_view_with_join" [] "" `shouldRespondWith`
+      [json|
+      {
+         "pkey":[
+            "id"
+         ],
+         "columns":[
+            {
+               "references":null,
+               "default":null,
+               "precision":64,
+               "updatable":false,
+               "schema":"1",
+               "name":"id",
+               "type":"bigint",
+               "maxLen":null,
+               "enum":[],
+               "nullable":true,
+               "position":1
+            },
+            {
+               "references":{
+                  "column":"id",
+                  "table":"auto_incrementing_pk"
+               },
+               "default":null,
+               "precision":32,
+               "updatable":false,
+               "schema":"1",
+               "name":"auto_inc_fk",
+               "type":"integer",
+               "maxLen":null,
+               "enum":[],
+               "nullable":true,
+               "position":2
+            },
+            {
+               "references":{
+                  "column":"k",
+                  "table":"simple_pk"
+               },
+               "default":null,
+               "precision":null,
+               "updatable":false,
+               "schema":"1",
+               "name":"simple_fk",
+               "type":"character varying",
+               "maxLen":255,
+               "enum":[],
+               "nullable":true,
+               "position":3
+            },
+            {
+               "references":null,
+               "default":null,
+               "precision":null,
+               "updatable":false,
+               "schema":"1",
+               "name":"nullable_string",
+               "type":"character varying",
+               "maxLen":null,
+               "enum":[],
+               "nullable":true,
+               "position":4
+            },
+            {
+               "references":null,
+               "default":null,
+               "precision":null,
+               "updatable":false,
+               "schema":"1",
+               "name":"non_nullable_string",
+               "type":"character varying",
+               "maxLen":null,
+               "enum":[],
+               "nullable":true,
+               "position":5
+            },
+            {
+               "references":null,
+               "default":null,
+               "precision":null,
+               "updatable":false,
+               "schema":"1",
+               "name":"inserted_at",
+               "type":"timestamp with time zone",
+               "maxLen":null,
+               "enum":[],
+               "nullable":true,
+               "position":6
+            }
+         ]
+      }
+      |]
+
    it "includes foreign key data" $ do
      pendingWith "have to resolve issue #107"

@@ -13,23 +13,25 @@ import Data.Monoid
 import Data.Text hiding (map)
 import qualified Data.Vector as V
 import Control.Monad (void)
+import Control.Applicative

 import Network.HTTP.Types.Header (Header, ByteRange, renderByteRange,
-                                  hRange, hAuthorization)
+                                  hRange, hAuthorization, hAccept)
 import Codec.Binary.Base64.String (encode)
 import Data.CaseInsensitive (CI(..))
 import Data.Maybe (fromMaybe)
 import Text.Regex.TDFA ((=~))
 import qualified Data.ByteString.Char8 as BS
-import Network.Wai.Middleware.Cors (cors)
 import System.Process (readProcess)

 import qualified Data.Aeson.Types as J

 import PostgREST.App (app)
-import PostgREST.Config (AppConfig(..), corsPolicy)
+import PostgREST.Config (AppConfig(..))
 import PostgREST.Middleware
 import PostgREST.Error(errResponse)
+import PostgREST.PgStructure
+import PostgREST.Types

 isLeft :: Either a b -> Bool
 isLeft (Left _ ) = True
@@ -53,13 +55,31 @@ withApp perform = do
  pool :: H.Pool P.Postgres
    <- H.acquirePool pgSettings testPoolOpts

+  let txSettings = Just (H.ReadCommitted, Just True)
+  metadata <- H.session pool $ H.tx txSettings $ do
+    tabs <- allTables
+    rels <- allRelations
+    cols <- allColumns rels
+    keys <- allPrimaryKeys
+    return (tabs, rels, cols, keys)
+
+  dbstructure <- case metadata of
+    Left e -> fail $ show e
+    Right (tabs, rels, cols, keys) ->
+      return $ DbStructure {
+          tables=tabs
+        , columns=cols
+        , relations=rels
+        , primaryKeys=keys
+        }
+
  perform $ middle $ \req resp -> do
    body <- strictRequestBody req
-    result <- liftIO $ H.session pool $ H.tx Nothing
-      $ authenticated cfg (app cfg body) req
+    result <- liftIO $ H.session pool $ H.tx txSettings
+      $ authenticated cfg (app dbstructure cfg body) req
    either (resp . errResponse) resp result

-  where middle = cors corsPolicy
+  where middle = defaultMiddle False


 resetDb :: IO ()
@@ -84,6 +104,9 @@ loadFixture name =
 rangeHdrs :: ByteRange -> [Header]
 rangeHdrs r = [rangeUnit, (hRange, renderByteRange r)]

+acceptHdrs :: BS.ByteString -> [Header]
+acceptHdrs mime = [(hAccept, mime)]
+
 rangeUnit :: Header
 rangeUnit = ("Range-Unit" :: CI BS.ByteString, "items")

@@ -94,7 +117,7 @@ matchHeader name valRegex headers =
 authHeaderBasic :: String -> String -> Header
 authHeaderBasic u p =
  (hAuthorization, cs $ "Basic " ++ encode (u ++ ":" ++ p))
-  
+
 authHeaderJWT :: String -> Header
 authHeaderJWT token =
  (hAuthorization, cs $ "Bearer " ++ token)
@@ -116,6 +139,18 @@ createItems n = do
    txn = mapM_ H.unitEx stmts
    stmts = map [H.stmt|insert into "1".items (id) values (?)|] [1..n]

+createComplexItems :: IO ()
+createComplexItems = do
+  pool <- testPool
+  void . liftIO $ H.session pool $ H.tx Nothing txn
+  where
+    txn = mapM_ H.unitEx stmts
+    stmts = getZipList $ [H.stmt|insert into "1".complex_items (id, name, settings) values (?,?,?)|]
+        <$> ZipList ([1..3]::[Int])
+        <*> ZipList (["One", "Two", "Three"]::[Text])
+        <*> ZipList ([jobj,jobj,jobj])
+    jobj = (J.object [("foo", J.object [("int", J.Number 1),("bar", J.String "baz")])])
+
 createNulls :: Int -> IO ()
 createNulls n = do
  pool <- testPool
@@ -125,6 +160,12 @@ createNulls n = do
    stmt' = [H.stmt|insert into "1".no_pk (a,b) values (null,null)|]
    stmts = map [H.stmt|insert into "1".no_pk (a,b) values (?,0)|] [1..n]

+createNullInteger :: IO ()
+createNullInteger = do
+  pool <- testPool
+  void . liftIO $ H.session pool $ H.tx Nothing $
+    H.unitEx $ [H.stmt| insert into "1".nullable_integer (a) values (null) |]
+
 createLikableStrings :: IO ()
 createLikableStrings = do
  pool <- testPool
@@ -79,7 +79,7 @@ spec = around dbWithSchema $ do
    addUser user pass role conn
    return conn) $ do
    it "accepts correct credentials and return the role" $ \conn ->
-      signInRole user pass conn `shouldReturn` LoginSuccess role
+      signInRole user pass conn `shouldReturn` LoginSuccess role user

    it "returns nothing with bad creds" $ \conn -> do
      signInRole "not-a-user" pass conn `shouldReturn` LoginFailed
@@ -14,7 +14,7 @@ spec = around dbWithSchema $ beforeWith setRole $ do
    it "shows all the tables" $ \conn -> do
      ts <- tables "1" conn
      map tableName ts `shouldBe` ["authors_only","auto_incrementing_pk",
-        "compound_pk","has_fk","items","menagerie","no_pk", "simple_pk"]
+        "compound_pk","has_fk","insertable_view_with_join","items","menagerie","no_pk", "simple_pk"]

  describe "columns" $ do
    it "responds with each column for the table" $ \conn -> do
@@ -47,7 +47,7 @@ SET search_path = postgrest, pg_catalog;
 CREATE FUNCTION check_role_exists() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
-begin 
+begin
 if not exists (select 1 from pg_roles as r where r.rolname = new.rolname) then
   raise foreign_key_violation using message = 'Cannot create user with unknown role: ' || new.rolname;
   return null;
@@ -64,7 +64,7 @@ CREATE FUNCTION update_owner() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
 BEGIN
-   NEW.owner = current_user; 
+   NEW.owner = current_user;
   RETURN NEW;
 END;
 $$;
@@ -72,6 +72,28 @@ $$;

 ALTER FUNCTION postgrest.update_owner() OWNER TO postgrest_test;

+CREATE FUNCTION set_authors_only_owner() RETURNS trigger
+    LANGUAGE plpgsql
+    AS $$
+begin
+  NEW.owner = current_setting('user_vars.user_id');
+  RETURN NEW;
+end
+$$;
+
+ALTER FUNCTION postgrest.set_authors_only_owner() OWNER TO postgrest_test;
+
+CREATE FUNCTION "1".insert_insertable_view_with_join() RETURNS trigger
+    LANGUAGE plpgsql
+    AS $$
+begin
+  INSERT INTO "1".auto_incrementing_pk (nullable_string, non_nullable_string) VALUES (NEW.nullable_string, NEW.non_nullable_string);
+  RETURN NEW;
+end;
+$$;
+
+ALTER FUNCTION "1".insert_insertable_view_with_join() OWNER TO postgrest_test;
+
 SET search_path = "1", pg_catalog;

 SET default_tablespace = '';
@@ -80,6 +102,7 @@ SET default_with_oids = false;


 CREATE TABLE authors_only (
+    owner character varying NOT NULL,
    secret character varying NOT NULL
 );

@@ -146,6 +169,29 @@ ALTER TABLE "1".has_fk_id_seq OWNER TO postgrest_test;

 ALTER SEQUENCE has_fk_id_seq OWNED BY has_fk.id;

+CREATE MATERIALIZED VIEW "1".materialized_view AS
+ SELECT
+    version();
+
+ALTER TABLE "1".materialized_view OWNER TO postgrest_test;
+
+CREATE VIEW "1".insertable_view_with_join AS
+ SELECT has_fk.id,
+    has_fk.auto_inc_fk,
+    has_fk.simple_fk,
+    auto_incrementing_pk.nullable_string,
+    auto_incrementing_pk.non_nullable_string,
+    auto_incrementing_pk.inserted_at
+   FROM (has_fk
+     JOIN auto_incrementing_pk USING (id));
+
+
+ALTER TABLE "1".insertable_view_with_join OWNER TO postgrest_test;
+
+CREATE VIEW "1".has_count_column AS
+ SELECT 1 AS count;
+
+ALTER TABLE "1".insertable_view_with_join OWNER TO postgrest_test;


 CREATE TABLE items (
@@ -155,6 +201,82 @@ CREATE TABLE items (

 ALTER TABLE "1".items OWNER TO postgrest_test;

+CREATE TABLE complex_items (
+    id bigint NOT NULL,
+    name text,
+    settings json
+);
+
+
+ALTER TABLE "1".complex_items OWNER TO postgrest_test;
+
+--- Structure for testing table relations
+CREATE TABLE clients(
+    id INT PRIMARY KEY     NOT NULL,
+    name           TEXT    NOT NULL
+);
+ALTER TABLE "1".clients OWNER TO postgrest_test;
+
+CREATE TABLE projects(
+    id INT PRIMARY KEY     NOT NULL,
+    name           TEXT    NOT NULL,
+    client_id      INT     REFERENCES clients(id)
+);
+ALTER TABLE "1".projects OWNER TO postgrest_test;
+
+CREATE TABLE tasks(
+    id INT PRIMARY KEY     NOT NULL,
+    name           TEXT    NOT NULL,
+    project_id      INT     REFERENCES projects(id)
+);
+ALTER TABLE "1".tasks OWNER TO postgrest_test;
+
+CREATE TABLE users(
+    id INT PRIMARY KEY     NOT NULL,
+    name           TEXT    NOT NULL
+);
+ALTER TABLE "1".users OWNER TO postgrest_test;
+
+CREATE TABLE users_tasks(
+    user_id      INT     REFERENCES users(id),
+    task_id      INT     REFERENCES tasks(id),
+    CONSTRAINT task_user PRIMARY KEY (task_id,user_id)
+);
+ALTER TABLE "1".users_tasks OWNER TO postgrest_test;
+
+CREATE TABLE comments(
+id INT PRIMARY KEY   NOT NULL,
+commenter_id INT     NOT NULL REFERENCES users(id),
+user_id      INT     NOT NULL,
+task_id      INT     NOT NULL,
+content      TEXT    NOT NULL,
+FOREIGN KEY (task_id,user_id) REFERENCES users_tasks (task_id,user_id)
+);
+ALTER TABLE "1".comments OWNER TO postgrest_test;
+
+CREATE TABLE users_projects(
+    user_id         INT     REFERENCES users(id),
+    project_id      INT     REFERENCES projects(id),
+    CONSTRAINT project_user PRIMARY KEY (project_id, user_id)
+);
+ALTER TABLE "1".users_projects OWNER TO postgrest_test;
+
+CREATE VIEW "1".projects_view AS
+  SELECT
+      projects.id,
+      projects.name,
+      projects.client_id
+  FROM projects;
+ALTER TABLE "1".projects_view OWNER TO postgrest_test;
+------- SAMPLE DATA -----
+INSERT INTO clients VALUES (1, 'Microsoft'),(2, 'Apple');
+INSERT INTO projects VALUES (1,'Windows 7', 1),(2,'Windows 10', 1),(3,'IOS', 2),(4,'OSX', 2);
+INSERT INTO tasks VALUES (1,'Design w7',1),(2,'Code w7',1),(3,'Design w10',2),(4,'Code w10',2),(5,'Design IOS',3),(6,'Code IOS',3),(7,'Design OSX',4),(8,'Code OSX',4);
+INSERT INTO users VALUES (1, 'Angela Martin'),(2, 'Michael Scott'),(3, 'Dwight Schrute');
+INSERT INTO users_projects VALUES(1,1),(1,2),(2,3),(2,4),(3,1),(3,3);
+INSERT INTO users_tasks VALUES(1,1),(1,2),(1,3),(1,4),(2,5),(2,6),(2,7),(3,1),(3,5);
+INSERT INTO comments VALUES (1, 1, 2, 6, 'Needs to be delivered ASAP');
+----------------

 CREATE SEQUENCE items_id_seq
    START WITH 1
@@ -171,6 +293,25 @@ ALTER SEQUENCE items_id_seq OWNED BY items.id;



+CREATE FUNCTION "1".getitemrange(min bigint, max bigint) RETURNS SETOF "1".items AS $$
+    SELECT * FROM "1".items WHERE id > $1 AND id <= $2;
+$$ LANGUAGE SQL;
+
+
+
+CREATE FUNCTION "1".sayhello(name text) RETURNS text AS $$
+    SELECT 'Hello, ' || $1;
+$$ LANGUAGE SQL;
+
+
+CREATE FUNCTION "1".problem() RETURNS void LANGUAGE plpgsql AS
+$$
+BEGIN
+      RAISE 'bad thing';
+END;
+$$;
+
+
 CREATE TABLE menagerie (
    "integer" integer NOT NULL,
    double double precision NOT NULL,
@@ -194,6 +335,14 @@ CREATE TABLE no_pk (
 ALTER TABLE "1".no_pk OWNER TO postgrest_test;


+CREATE TABLE nullable_integer (
+    a integer
+);
+
+
+ALTER TABLE "1".nullable_integer OWNER TO postgrest_test;
+
+
 CREATE TABLE simple_pk (
    k character varying NOT NULL,
    extra character varying NOT NULL
@@ -212,12 +361,18 @@ CREATE TABLE json
 ALTER TABLE "1".json OWNER TO postgrest_test;


+CREATE TABLE tsearch (
+    text_search_vector tsvector
+);
+
+ALTER TABLE "1".tsearch OWNER TO postgrest_test;
+
 SET search_path = postgrest, pg_catalog;


 CREATE TABLE auth (
    id character varying NOT NULL,
-    rolname name NOT NULL,
+    rolname name NOT NULL DEFAULT 'postgrest_test_author',
    pass character(60) NOT NULL
 );

@@ -299,14 +454,8 @@ INSERT INTO items (id) VALUES (1);
 SELECT pg_catalog.setval('items_id_seq', 1, true);


-
-
-
-
-
-
-
-
+INSERT INTO tsearch (text_search_vector) VALUES ('''bar'':2 ''foo'':1');
+INSERT INTO tsearch (text_search_vector) VALUES ('''baz'':1 ''qux'':2');

 SET search_path = postgrest, pg_catalog;

@@ -324,10 +473,21 @@ SELECT pg_catalog.setval('articles_id_seq', 1, false);

 SET search_path = "1", pg_catalog;

+CREATE FUNCTION public.always_true("1".items) RETURNS boolean
+    LANGUAGE sql STABLE
+    AS $$ SELECT true $$;
+
+ALTER FUNCTION public.always_true("1".items) OWNER TO postgrest_test;
+
+

 ALTER TABLE ONLY authors_only
    ADD CONSTRAINT authors_only_pkey PRIMARY KEY (secret);

+CREATE TRIGGER insert_insertable_view_with_join INSTEAD OF INSERT ON "1".insertable_view_with_join FOR EACH ROW EXECUTE PROCEDURE "1".insert_insertable_view_with_join();
+
+
+CREATE TRIGGER secrets_owner_track BEFORE INSERT OR UPDATE ON authors_only FOR EACH ROW EXECUTE PROCEDURE postgrest.set_authors_only_owner();


 ALTER TABLE ONLY auto_incrementing_pk
@@ -353,6 +513,8 @@ ALTER TABLE ONLY has_fk
 ALTER TABLE ONLY items
    ADD CONSTRAINT items_pkey PRIMARY KEY (id);

+ALTER TABLE ONLY complex_items
+    ADD CONSTRAINT complex_items_pkey PRIMARY KEY (id);


 ALTER TABLE ONLY menagerie
@@ -455,6 +617,62 @@ REVOKE ALL ON TABLE items FROM postgrest_test;
 GRANT ALL ON TABLE items TO postgrest_test;
 GRANT ALL ON TABLE items TO postgrest_anonymous;

+REVOKE ALL ON TABLE complex_items FROM PUBLIC;
+REVOKE ALL ON TABLE complex_items FROM postgrest_test;
+GRANT ALL ON TABLE complex_items TO postgrest_test;
+GRANT ALL ON TABLE complex_items TO postgrest_anonymous;
+
+---------
+REVOKE ALL ON TABLE clients FROM PUBLIC;
+REVOKE ALL ON TABLE clients FROM postgrest_test;
+GRANT ALL ON TABLE clients TO postgrest_test;
+GRANT ALL ON TABLE clients TO postgrest_anonymous;
+REVOKE ALL ON TABLE projects FROM PUBLIC;
+REVOKE ALL ON TABLE projects FROM postgrest_test;
+GRANT ALL ON TABLE projects TO postgrest_test;
+GRANT ALL ON TABLE projects TO postgrest_anonymous;
+REVOKE ALL ON TABLE tasks FROM PUBLIC;
+REVOKE ALL ON TABLE tasks FROM postgrest_test;
+GRANT ALL ON TABLE tasks TO postgrest_test;
+GRANT ALL ON TABLE tasks TO postgrest_anonymous;
+REVOKE ALL ON TABLE users FROM PUBLIC;
+REVOKE ALL ON TABLE users FROM postgrest_test;
+GRANT ALL ON TABLE users TO postgrest_test;
+GRANT ALL ON TABLE users TO postgrest_anonymous;
+REVOKE ALL ON TABLE users_tasks FROM PUBLIC;
+REVOKE ALL ON TABLE users_tasks FROM postgrest_test;
+GRANT ALL ON TABLE users_tasks TO postgrest_test;
+GRANT ALL ON TABLE users_tasks TO postgrest_anonymous;
+REVOKE ALL ON TABLE comments FROM PUBLIC;
+REVOKE ALL ON TABLE comments FROM postgrest_test;
+GRANT ALL ON TABLE  comments TO postgrest_test;
+GRANT ALL ON TABLE  comments TO postgrest_anonymous;
+REVOKE ALL ON TABLE users_projects FROM PUBLIC;
+REVOKE ALL ON TABLE users_projects FROM postgrest_test;
+GRANT ALL ON TABLE users_projects TO postgrest_test;
+GRANT ALL ON TABLE users_projects TO postgrest_anonymous;
+REVOKE ALL ON TABLE projects_view FROM PUBLIC;
+REVOKE ALL ON TABLE projects_view FROM postgrest_test;
+GRANT ALL ON TABLE projects_view TO postgrest_test;
+GRANT ALL ON TABLE projects_view TO postgrest_anonymous;
+---------
+
+
+REVOKE ALL ON FUNCTION getitemrange(bigint, bigint) FROM PUBLIC;
+REVOKE ALL ON FUNCTION getitemrange(bigint, bigint) FROM postgrest_test;
+GRANT EXECUTE ON FUNCTION getitemrange(bigint, bigint) TO postgrest_test;
+GRANT EXECUTE ON FUNCTION getitemrange(bigint, bigint) TO postgrest_anonymous;
+
+
+REVOKE ALL ON FUNCTION sayhello(text) FROM PUBLIC;
+REVOKE ALL ON FUNCTION sayhello(text) FROM postgrest_test;
+GRANT EXECUTE ON FUNCTION sayhello(text) TO postgrest_test;
+GRANT EXECUTE ON FUNCTION sayhello(text) TO postgrest_anonymous;
+
+
+REVOKE ALL ON FUNCTION problem() FROM PUBLIC;
+REVOKE ALL ON FUNCTION problem() FROM postgrest_test_author;
+GRANT EXECUTE ON FUNCTION problem() TO postgrest_test_author;


 REVOKE ALL ON SEQUENCE items_id_seq FROM PUBLIC;
@@ -478,6 +696,13 @@ GRANT ALL ON TABLE no_pk TO postgrest_anonymous;



+REVOKE ALL ON TABLE nullable_integer FROM PUBLIC;
+REVOKE ALL ON TABLE nullable_integer FROM postgrest_test;
+GRANT ALL ON TABLE nullable_integer TO postgrest_test;
+GRANT ALL ON TABLE nullable_integer TO postgrest_anonymous;
+
+
+
 REVOKE ALL ON TABLE simple_pk FROM PUBLIC;
 REVOKE ALL ON TABLE simple_pk FROM postgrest_test;
 GRANT ALL ON TABLE simple_pk TO postgrest_test;
@@ -491,6 +716,33 @@ GRANT ALL ON TABLE json TO postgrest_test;
 GRANT ALL ON TABLE json TO postgrest_anonymous;


+
+REVOKE ALL ON TABLE tsearch FROM PUBLIC;
+REVOKE ALL ON TABLE tsearch FROM postgrest_test;
+GRANT ALL ON TABLE tsearch TO postgrest_test;
+GRANT ALL ON TABLE tsearch TO postgrest_anonymous;
+
+REVOKE ALL ON TABLE materialized_view FROM PUBLIC;
+REVOKE ALL ON TABLE materialized_view FROM postgrest_test;
+GRANT ALL ON TABLE materialized_view TO postgrest_test;
+GRANT ALL ON TABLE materialized_view TO postgrest_anonymous;
+
+REVOKE ALL ON TABLE insertable_view_with_join FROM PUBLIC;
+REVOKE ALL ON TABLE insertable_view_with_join FROM postgrest_test;
+GRANT ALL ON TABLE insertable_view_with_join TO postgrest_test;
+GRANT ALL ON TABLE insertable_view_with_join TO postgrest_anonymous;
+
+REVOKE ALL ON TABLE has_count_column FROM PUBLIC;
+REVOKE ALL ON TABLE has_count_column FROM postgrest_test;
+GRANT ALL ON TABLE has_count_column TO postgrest_test;
+GRANT ALL ON TABLE has_count_column TO postgrest_anonymous;
+
+REVOKE ALL ON FUNCTION public.always_true("1".items) FROM PUBLIC;
+REVOKE ALL ON FUNCTION public.always_true("1".items) FROM postgrest_test;
+GRANT ALL ON FUNCTION public.always_true("1".items) TO postgrest_test;
+GRANT ALL ON FUNCTION public.always_true("1".items) TO postgrest_anonymous;
+
+
 SET search_path = postgrest, pg_catalog;
Author	SHA1	Message	Date
Joe Nelson	bd1826670e	Version 0.2.12.0	2015-10-25 11:46:16 -07:00
Joe Nelson	aab1500879	Merge pull request #330 from ruslantalpa/master Fix for #321	2015-10-24 12:57:31 -07:00
Ruslan Talpa	0ed8ec9868	Fix for #321	2015-10-24 22:50:03 +03:00
Joe Nelson	df00d728ff	Docs about methods for updating records	2015-10-21 21:12:27 -07:00
Joe Nelson	9fad028074	Document API read requests	2015-10-20 19:25:31 -07:00
Joe Nelson	e0fe610d7b	Merge pull request #324 from begriffs/mkdocs Documentation outline	2015-10-19 16:51:53 -07:00
Joe Nelson	20198367da	Documentation outline	2015-10-19 16:45:52 -07:00
Joe Nelson	d3eca26393	Merge pull request #319 from ruslantalpa/master avoid ByteString -> Text -> ByteString converstion of the response body	2015-10-15 10:22:30 -07:00
Ruslan Talpa	864c865e52	avoid ByteString -> Text -> ByteString converstion of the response body	2015-10-15 16:20:57 +03:00
Joe Nelson	3e9f9f300c	Merge pull request #309 from ruslantalpa/master Fix for #302 (supporting compound foreign keys in relations)	2015-10-08 12:21:00 -07:00
Ruslan Talpa	6ba4dc4617	Fix for #302	2015-10-08 11:33:42 +03:00
Joe Nelson	2d0c4fecd8	Merge pull request #307 from calebmer/tolerate-missing-role Tolerate missing role in user creation	2015-10-07 18:09:04 -07:00
calebmer	8e107e5b24	Tolerate missing role in user creation	2015-10-07 20:01:46 -04:00
Joe Nelson	2f551fea97	Merge pull request #305 from diogob/moves_minimum_pg_version_to_config Moves minimum pg version to config	2015-10-06 17:58:18 -07:00
Diogo Biazus	adfd980a60	Moves minimum pg version to config, eliminates magic constant from main and improves docs.	2015-10-06 20:27:54 -04:00
Joe Nelson	f186d6bb33	Merge pull request #299 from fike/master Added files in debian subdirectory.	2015-10-06 09:25:14 -07:00
Joe Nelson	180d647c70	Merge pull request #303 from diogob/refactor_config Moves all config related code to PostgREST.Config module and sets default db-pass	2015-10-05 19:13:23 -07:00
Diogo Biazus	3020812f71	Adds basic haddock comments on Config module	2015-10-05 21:14:18 -04:00
Diogo Biazus	ed9eea3e8b	Imports (<>) from Data.Monoid	2015-10-05 18:53:44 -04:00
Diogo Biazus	346170220e	Uses empty password by default	2015-10-05 14:58:53 -04:00
Diogo Biazus	3a1f7938e8	Moves all config related code to PostgREST.Config module and tweak the code to better encapsulate functionality.	2015-10-05 14:50:35 -04:00
Joe Nelson	9b222fb93d	Thank you @ruslantalpa	2015-10-04 10:10:17 -07:00
Joe Nelson	0f1b313d96	Merge pull request #295 from ruslantalpa/master Extend the capabilities of PostgREST #280	2015-10-04 09:42:32 -07:00
Ruslan Talpa	b675276f31	merge new test from @diogob	2015-10-04 07:26:05 +03:00
Ruslan Talpa	c014d09072	Merge pull request #1 from diogob/fix_composite_fk_children Adds a failing spec for child relation (comments) using a composite FK	2015-10-04 07:17:04 +03:00
Diogo Biazus	4dd508a628	Adds a failing spec for child relation (comments) using a composite foreign key (references to users_tasks)	2015-10-03 15:02:02 -04:00
Ruslan Talpa	e23a49395b	error formatting for parsers and relation	2015-10-02 11:36:56 +03:00
Fernando Ike	80f9685bb9	Fixed year dat in d/copyright	2015-10-01 18:15:08 -03:00
Ruslan Talpa	7754f96af8	Merge remote-tracking branch 'begriffs/master'	2015-10-01 22:22:14 +03:00
Joe Nelson	7d8523a786	Merge pull request #298 from diogob/fix_count_none Fix count=none when we have filters	2015-10-01 10:26:25 -07:00
Ruslan Talpa	e6baafdb8f	remove space	2015-10-01 15:28:02 +03:00
Ruslan Talpa	c7666c0a67	tests for table relations & bugfix for not detecting child relations of view	2015-10-01 14:20:40 +03:00
Ruslan Talpa	8ff4b4be66	lint fix	2015-10-01 10:36:33 +03:00
Ruslan Talpa	ffeb8b1d5f	Merge remote-tracking branch 'begriffs/master'	2015-10-01 10:32:30 +03:00
Ruslan Talpa	812135d1e5	cleanup suggested by @begriffs	2015-10-01 10:30:41 +03:00
Joe Nelson	3eb58c511b	Merge pull request #300 from diogob/update_stack_37 Updates stackage resolver to 3.7	2015-09-30 22:30:40 -07:00
Diogo Biazus	0df6ea57ae	Updates stackage resolver to 3.7	2015-09-30 23:35:44 -04:00
Diogo Biazus	f0ec46fd11	Fix count=none when we have filters	2015-09-30 16:50:52 -04:00
Fernando Ike	add25ae68e	Added files in debian subdirectory. These files are base to build postgrest Debian package. Additional, it has TODO-deps.md file with whole task to build postgrest as Debian official package.	2015-09-30 17:49:11 -03:00
Ruslan Talpa	7f2c39ef94	small cleanup suggested by @begriffs	2015-09-29 19:16:25 +03:00
Ruslan Talpa	94b1d2815c	small changes suggested by @diogob	2015-09-29 11:40:33 +03:00
Ruslan Talpa	1da26cac98	trying to make it work with ghc 7.8 (3)	2015-09-28 16:54:34 +03:00
Ruslan Talpa	a4a2c8b886	trying to make it work with ghc 7.8 (2)	2015-09-28 16:46:33 +03:00
Ruslan Talpa	68c7f45be1	trying to make it work with ghc 7.8	2015-09-28 16:40:22 +03:00
Ruslan Talpa	dbf3d5809b	add bifunctors to cabal config	2015-09-28 16:23:57 +03:00
Ruslan Talpa	bcf3bf5586	handle many to many relations	2015-09-28 15:53:03 +03:00
Ruslan Talpa	edff915f9e	delete unused functions	2015-09-28 13:41:45 +03:00
Ruslan Talpa	9342cc8c8a	removide duplication from data types (all tests passing)	2015-09-28 12:06:49 +03:00
Ruslan Talpa	db13724131	moved string packing to parsers	2015-09-28 10:11:59 +03:00
Ruslan Talpa	380cab6ca3	Merge branch 'master' into skin	2015-09-25 22:45:49 +03:00
Ruslan Talpa	bd4bf489dc	Merge remote-tracking branch 'begriffs/master'	2015-09-25 22:14:58 +03:00
Joe Nelson	29ae1bdefd	Merge pull request #293 from diogob/prefer_count_none Prefer count none	2015-09-25 10:35:53 -07:00
Diogo Biazus	efd6580b26	Adds Prefer count=none to changelog	2015-09-25 13:22:19 -04:00
Diogo Biazus	f08512eaa9	Updates optparse-applicative package version constraints	2015-09-25 12:19:24 -04:00
Diogo Biazus	e28b2dd00e	Implements Prefer count=none header Uses Maybe for total parameter in contentRangeH	2015-09-25 10:52:44 -04:00
Ruslan Talpa	3d1736e0d3	fix for generating count query	2015-09-25 16:33:25 +03:00
Ruslan Talpa	2fb5c5187a	deleted some commented code	2015-09-25 15:28:48 +03:00
Ruslan Talpa	ff2c0b63e2	changed identation to 2 spaces to match the rest of the project	2015-09-25 12:04:44 +03:00
Ruslan Talpa	c42832f1c5	code cleanup	2015-09-25 11:51:37 +03:00
Ruslan Talpa	770e04c04a	remove unused functions in pgstructure	2015-09-25 10:36:19 +03:00
Ruslan Talpa	54d1e4112a	detect primary keys for views & use cached info in PUT/PATCH requests	2015-09-25 10:30:19 +03:00
Ruslan Talpa	89fffd1518	Merge branch 'master' into skin	2015-09-25 10:00:18 +03:00
Diogo Biazus	1fbf276474	Adds spec for Prefer header set to count=none	2015-09-24 18:31:36 -04:00
Ruslan Talpa	8783615ebc	detect primary keys for views (fix #217 )	2015-09-24 23:30:47 +03:00
Ruslan Talpa	f546dc3ac8	small note about a bug	2015-09-24 22:06:44 +03:00
Ruslan Talpa	f2d6c59bab	fixes for failing tests (only 2 failing, yay! :))	2015-09-24 16:29:20 +03:00
Ruslan Talpa	448a81dff8	first fully functioning build, some tests are failing (limit,order,csv not implemented yet)	2015-09-24 11:45:34 +03:00
Ruslan Talpa	fb92b76a1a	integrated skin code gor generating Sql Query (only left to execute it)	2015-09-23 14:31:24 +03:00
Ruslan Talpa	c0e17c44ba	all tests passing after moving table structure detection at load time	2015-09-23 09:38:40 +03:00
Ruslan Talpa	6f55e1d389	fix for one of the failing tests (acl for tables added)	2015-09-22 18:17:24 +03:00
Ruslan Talpa	a7b883c922	moved db structure detection at the beginning (2 tests failing)	2015-09-22 16:56:19 +03:00
Ruslan Talpa	6bd6108619	Merge remote-tracking branch 'begriffs/master'	2015-09-07 09:28:31 +03:00
Joe Nelson	aee0c2c731	Test that patch requests can set a field to null Exploring situation mentioned in #233	2015-09-06 17:07:00 -07:00
Joe Nelson	b5e76f42a5	Note @ruslantalpa's contribution in changelog	2015-09-06 16:14:53 -07:00
Joe Nelson	35f05f6fe1	Standardize indentation	2015-09-06 16:13:11 -07:00
Joe Nelson	cf2f576ec0	Merge pull request #276 from ruslantalpa/master Support for &select=col1,col2,col3 as suggested in issue #227	2015-09-06 15:24:47 -07:00
Ruslan Talpa	92a1d8c7e3	constrain cast parameters to letters only	2015-09-05 16:54:09 +03:00
Ruslan Talpa	cc418d3519	aditional tests for bad casting parameters	2015-09-05 15:31:36 +03:00
Ruslan Talpa	9c8ac2a489	tests for &select= feature and support for casting columns (usefull when extracting subfields from json columns)	2015-09-05 15:05:53 +03:00
Ruslan Talpa	6c16395dfb	change fn name from selectT to select	2015-09-04 19:04:39 +03:00
Ruslan Talpa	40d4fb0d75	Support for extracting fields from json columns	2015-09-02 12:41:02 +03:00
Ruslan Talpa	b9fec2ce41	Support for &select=col1,col2,col3 as suggested in issue #227	2015-09-02 11:03:34 +03:00
Joe Nelson	593f247abb	Expose more heroku config vars	2015-09-01 23:16:30 -07:00
Joe Nelson	add63ac25b	Keep the dilapidated release script alive	2015-09-01 23:13:47 -07:00
Joe Nelson	1ef8cc5048	Bump patch version	2015-09-01 22:29:13 -07:00
Joe Nelson	c5836e0c9e	Merge pull request #275 from diogob/fix_all_media_types_in_accept Fix / in accept headers	2015-09-01 13:10:02 -07:00
Diogo Biazus	922aa702a2	Adds fix to changelog	2015-09-01 15:58:07 -04:00
Diogo Biazus	89c581816e	Adds / as a valid media type that will return json [fix #274 ]	2015-09-01 15:57:59 -04:00
Joe Nelson	3d670b9c03	bump minor version	2015-08-28 19:19:37 -07:00
Joe Nelson	5bf644867f	Merge pull request #271 from begriffs/surprise-404 Allow continued auth access after db errors	2015-08-26 20:58:55 -07:00
Joe Nelson	fcdae73f49	Note fix in changelog	2015-08-26 20:49:23 -07:00
Joe Nelson	1656fb9f57	Let the transaction reset the role and user id for us	2015-08-26 20:49:23 -07:00
Joe Nelson	594327924c	Set role locally in a tx to ensure it is reset after error	2015-08-26 20:49:23 -07:00
Joe Nelson	480800edbd	Problem after exceptions when authed Reproduces #264	2015-08-26 20:49:23 -07:00
Joe Nelson	9b01d1b1ab	Helpful directions in contributing doc	2015-08-26 20:47:22 -07:00
Joe Nelson	ed810bc380	Operator negation	2015-08-21 19:35:48 -07:00
Joe Nelson	789db9a017	Merge pull request #266 from diogob/adds_not_unary_operator Adds not as a keyword that can optionally be prepended to any operator in a parameter value [fix #173]	2015-08-21 19:25:02 -07:00
Diogo Biazus	52626cc86d	Adds test cases for not operator in equality, inequality, like, ilike, tesarch (@@) and is null queries	2015-08-21 15:08:52 -04:00
Diogo Biazus	32b97ef076	Adds not as a keyword that can optionally be prepended to any operator in a parameter value	2015-08-21 10:33:41 -04:00
Joe Nelson	8e319321c9	RPC and Stack	2015-08-20 22:37:19 -07:00
Joe Nelson	cdac6d385c	Merge pull request #228 from begriffs/rpc Expose stored procedures	2015-08-20 22:27:30 -07:00
Joe Nelson	d65d011e5e	Tests for rpc	2015-08-20 22:14:09 -07:00
Joe Nelson	28f771324d	Nest response JSON more shallowly	2015-08-20 22:14:08 -07:00
Joe Nelson	cf04fbd6ea	Call procedures that return setof, not just text The output is too deeply nested however	2015-08-20 21:52:46 -07:00
Joe Nelson	bb511f0df2	WIP: call stored pprocedures that emit plain text The beginning of #114	2015-08-20 21:52:46 -07:00
Joe Nelson	f564fb0977	Rename QualifiedTable to encompass proc names as well	2015-08-20 21:35:12 -07:00
Diogo BiazusandJoe Nelson	3b017dfdf6	Adds 415 response for any non-empty Accept header different from application/json or text/csv. Uses apropriate Content-Type header when sending CSV format.	2015-08-20 20:47:36 -07:00
Diogo BiazusandJoe Nelson	cb7d00b839	Adds tags file to gitignore	2015-08-20 20:47:36 -07:00
Joe Nelson	010e18ea0b	Merge pull request #269 from diogob/build_with_stack Build with stack	2015-08-20 15:29:10 -07:00
Diogo Biazus	c34f96ce2e	Removes body matcher to compile and test against any aeson version >= 0.8	2015-08-20 16:43:57 -04:00
Diogo Biazus	f9d50018d9	Rollback to aeson 0.8.0.2 to allow building with stackage, and adds stack.yml	2015-08-20 15:50:28 -04:00
Diogo Biazus	6c1233fcec	Adss stack-work directory to gitignore	2015-08-20 15:15:53 -04:00
Joe Nelson	acd8e92d24	Note the NOT IN addition	2015-08-17 09:40:49 -07:00
Joe Nelson	559d370a89	Merge pull request #263 from rall/notin NOT IN queries	2015-08-17 09:38:45 -07:00
Richard Allaway	4cf51b7005	fixes spec for changed error message from updated aeson library	2015-08-17 11:10:15 -04:00
Richard Allaway	4e77492797	adds a spec for NOT IN query case	2015-08-17 10:24:51 -04:00
Richard Allaway	f16e2e3ee5	adds 'not in' query	2015-08-17 10:24:51 -04:00
Joe Nelson	ebc8c387e0	Thanks @diogob!	2015-08-15 12:14:20 -07:00
Joe Nelson	734484714c	CSV responses!	2015-08-15 11:59:12 -07:00
Joe Nelson	adac39bd7c	Use Content-Type text/csv for CSV responses	2015-08-15 11:57:57 -07:00
Diogo Biazus	9d5011e864	Implements CSV resnponse for the appropriate accept headers	2015-08-14 11:04:26 -04:00
Diogo Biazus	ca40ba1fda	Refactors app function to DRY header lookups	2015-08-14 11:04:26 -04:00
Joe Nelson	894455f2cd	Relax hasql deps for packdeps checker	2015-08-12 00:05:38 -07:00
Joe Nelson	6cb73062a9	Better shields	2015-08-11 23:18:47 -07:00
Joe Nelson	86c68d191c	Updated maintenance note in contributing doc	2015-08-09 14:04:57 -07:00
Joe Nelson	d20c252cb3	Adjust version of hasql-postgres for packdeps	2015-08-08 12:57:44 -07:00
Joe Nelson	cd6b688f7f	Merge pull request #244 from diogob/adds_materialized_views_to_root Adds materialized views to list of relations in GET / [#242]	2015-08-01 16:16:23 -07:00
Joe Nelson	49f41d8edb	Merge pull request #243 from diogob/fix_count_column_name_case Fixes error code 42803 when trying to query a view with a column named count	2015-08-01 16:15:02 -07:00
Diogo Biazus	b45953dff8	Mentions fix in CHANGELOG	2015-08-01 01:23:31 -04:00
Diogo Biazus	8075d7e51a	Mentions fix in CHANGELOG	2015-08-01 01:21:42 -04:00
Diogo Biazus	ab0170ffaf	Adds materialized views to list of relations in GET / [#242 ]	2015-08-01 01:09:12 -04:00
Diogo Biazus	449cacdacf	Fixes error code 42803 when trying to query a view with a column named count.	2015-08-01 00:15:17 -04:00
Joe Nelson	e724c2df00	Merge pull request #230 from edelans/master Add link to Jonathan Harrington's nice tutorial	2015-07-26 10:17:39 -07:00
Joe Nelson	12dc180065	Merge pull request #237 from datasaur/master Enable log capture if stdout is not a terminal (issue #229)	2015-07-24 09:51:37 -07:00
MattK	8eae978eae	Enable log capture if stdout is not a terminal	2015-07-24 12:14:18 -04:00
Edouard de Lansalut	019d53bca1	Add link to Jonathan Harrington's nice tutorial	2015-07-22 09:47:14 +02:00
Joe Nelson	e1d7dc3dea	Note computed columns in changelog	2015-07-21 22:34:45 -07:00
Joe Nelson	28a2826fa8	Merge pull request #221 from diogob/allow_virtual_fields_in_where Qualifies columns of WHERE clauses so we can use computed columns as filters	2015-07-21 22:31:10 -07:00
Diogo Biazus	c76864a653	Qualifies columns used in WHERE clauses so we can use computed columns as filters	2015-07-10 12:35:24 -04:00
Joe Nelson	c0d44232a5	Note Debian changes in changelog	2015-07-09 22:52:14 -07:00
Joe Nelson	e34e92eb44	Merge pull request #216 from mkhon/master Debian init script for postgrest.	2015-07-09 22:49:11 -07:00
Joe Nelson	956f73d997	Regression test for situation reported in issue #203	2015-07-03 22:51:04 -07:00
Joe Nelson	df04d26c15	Merge pull request #219 from diogob/check_postgresql_version Verifies PostgreSQL version is supported (+9.2) before spawning server	2015-07-02 13:21:29 -07:00
Diogo Biazus	9c69553373	Verifies PostgreSQL version is supported (+9.2) before spawning server [fixes #157 ]	2015-07-02 09:26:58 -04:00
Joe Nelson	6604293ac1	Remove regex-tdfa-text to allow building in GHC 7.10 Fixes #212	2015-07-01 21:55:35 -07:00
Max Khon	60a61adbce	Use POSTGREST_USER.	2015-06-24 18:30:56 +06:00
Max Khon	b56ab47f84	Debian init script for postgrest.	2015-06-24 18:07:30 +06:00
Joe Nelson	25492a089b	Merge pull request #214 from diogob/refactor_to_bool Removes toBool function as we now cast the 'YES/NO' values to boolean in PostgreSQL's queries	2015-06-22 22:29:07 -07:00
Diogo Biazus	e87be593c0	Removes toBool function as we now cast the 'YES/NO' values to boolean in PostgreSQL's queries	2015-06-22 18:09:45 -04:00
Joe Nelson	1937363fc8	Note @diogob's contribution	2015-06-21 22:18:51 -07:00
Joe Nelson	d68cbec25c	Merge pull request #209 from diogob/insertable_views_with_triggers Changes the insertable to true in views that are insertable through triggers [fixes #206]	2015-06-21 22:16:43 -07:00
Diogo Biazus	f4011e5d8c	Changes the insertable to true in views that are insertable through triggers [fixes #206 ]	2015-06-22 00:16:23 -04:00
Joe Nelson	e93c96a6f8	Link to Heroku troubleshooting Wiki in readme	2015-06-21 14:01:42 -07:00
Joe Nelson	070f67e9c6	Merge pull request #213 from begriffs/packdeps Loosen dependency version constraints for packdeps	2015-06-20 12:16:05 -07:00
Joe Nelson	61dac3b02b	Loosen dependency version constraints for packdeps	2015-06-20 12:12:36 -07:00
Joe Nelson	169157ec6d	Thanks @framp	2015-06-17 20:24:10 -07:00
Joe Nelson	bd304c9fc3	Bump version	2015-06-03 21:22:17 -07:00
Joe Nelson	3989aaa144	Note @framp's auth id change	2015-05-26 14:58:59 -07:00
Joe Nelson	1d51a5f543	Merge pull request #201 from framp/master User_id support (via user_vars)	2015-05-26 14:55:56 -07:00
Joe Nelson	e4dafad64d	Use github release feature to host binaries	2015-05-25 21:56:47 -07:00
Joe Nelson	3f31c60f1d	Mention JWT in readme	2015-05-25 21:46:05 -07:00
Federico Rampazzo	83f48dcd15	User_id support (via user_vars)	2015-05-24 03:26:42 +01:00
Joe Nelson	1cc53245c5	Full text search in changelog	2015-05-23 08:21:02 -07:00
Joe Nelson	f24ba048af	Merge pull request #199 from diogob/tsearch_operator Tsearch operator	2015-05-23 08:15:44 -07:00
Diogo Biazus	a980db6d2d	Adds spec for @@ operator and implements it in PgQuery	2015-05-22 12:28:26 -04:00
Diogo Biazus	4277284a69	Adds table tsearch to test for @@ operator against a tsvector field. Fixes StructureSpec accordingly.	2015-05-22 12:15:14 -04:00