Bump version

Note @framp's auth id change
Merge pull request #201 from framp/master
2015-06-03 21:22:17 -07:00 · 2015-05-26 14:58:59 -07:00 · 2015-05-26 14:55:56 -07:00 · 2015-05-25 21:56:47 -07:00 · 2015-05-25 21:46:05 -07:00 · 2015-05-24 03:26:42 +01:00
24 changed files with 787 additions and 606 deletions
@@ -3,6 +3,37 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).

+## [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
+- Return PATCHed resources if header "Prefer: return=representation"
+- Allow nested objects and arrays in JSON post for jsonb columns
+- JSON Web Tokens - [Federico Rampazzo](https://github.com/framp)
+- Expose PostgREST as a Haskell package
+
+### Fixed
+- Return 404 if no records updated by PATCH
+
+## [0.2.8.0] - 2015-04-17
+### Added
+- Option to specify nulls first or last, eg `/people?order=age.desc.nullsfirst`
+- Filter nulls, `?col=is.null` and `?col=isnot.null`
+- Filter within jsonb, `?col->a->>b=eq.c`
+- Accept CSV in post body for bulk inserts
+
+### Fixed
+- Allow NULL values in posts
+- Show full command line usage on param errors
+
 ## [0.2.7.0] - 2015-03-03
 ### Added
 - Server response logging
@@ -0,0 +1,50 @@
+# Contributing to PostgREST
+
+**First:** if you're unsure or afraid of _anything_, just ask or
+submit the issue or pull request anyways. You won't be yelled at
+for giving your best effort. The worst that can happen is that
+you'll be politely asked to change something. We appreciate any
+sort of contributions, and don't want a wall of rules to get in the
+way of that.
+
+However, for those individuals who want a bit more guidance on the
+best way to contribute to the project, read on. This document will
+cover what we're looking for. By addressing all the points we're
+looking for, it raises the chances we can quickly merge or address
+your contributions.
+
+## Issues
+
+### Reporting an Issue
+
+* Make sure you test against the latest released version. It is possible
+  we already fixed the bug you're experiencing.
+
+* Also check the `CHANGELOG.md` to see if any unreleased changes affect
+  the issue. The very newest changes can take a little while to be released
+  as a new official version.
+
+* Provide steps to reproduce the issue, including your OS version and
+  the specific database schema that you are using.
+
+## Code
+
+### Haskell Conventions
+
+* All contributions must pass the tests before being merged. When
+  you create a pull request your code will automatically be tested.
+
+* All code must also pass [hlint](http://community.haskell.org/~ndm/hlint/)
+  with no warnings. This helps enforce a uniform style for all
+  committers. Continuous integration will check this as well on every
+  pull request.
+
+## 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.
@@ -9,7 +9,7 @@ PostgREST serves a fully RESTful API from any existing PostgreSQL
 database. It provides a cleaner, more standards-compliant, faster
 API than you are likely to write from scratch.

-### Demo [postgrest.herokuapp.com](https://postgrest.herokuapp.com) | Watch [Video](http://begriffs.com/posts/2014-12-30-intro-to-postgrest.html)
+### Demo [postgrest.herokuapp.com](https://postgrest.herokuapp.com) | Watch [Video](http://begriffs.com/posts/2014-12-30-intro-to-postgrest.html) | [GUI Demo](http://marmelab.com/ng-admin-postgrest)

 Try making requests to the live demo server with an HTTP client
 such as [postman](http://www.getpostman.com/). The structure of the
@@ -20,7 +20,7 @@ your own projects.

 ### Usage

-Download the binary ([OS X](http://bin.begriffs.com/dbapi/osx/postgrest-0.2.7.0.tar.xz) / [Linux](http://bin.begriffs.com/dbapi/heroku/postgrest-0.2.7.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 +75,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/).
@@ -153,6 +155,7 @@ and the [guide to routing](https://github.com/begriffs/postgrest/wiki/Routing).
 * [Versioning](https://github.com/begriffs/postgrest/wiki/API-Versioning)
 * [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)

 ### Thanks

@@ -162,3 +165,4 @@ and the [guide to routing](https://github.com/begriffs/postgrest/wiki/Routing).
  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
@@ -10,7 +10,7 @@
    },
    "POSTGREST_VER": {
      "description": "Version of PostgREST to deploy",
-      "value": "0.2.7.0"
+      "value": "0.2.10.0"
    },
    "DB_NAME": {
      "description": "Database name",
@@ -4,7 +4,13 @@ machine:
    - createdb -O postgrest_test -U ubuntu postgrest_test
  ghc:
    version: 7.8.3
+dependencies:
+  override:
+    - cabal update
+    - cabal sandbox init
+    - cabal install --upgrade-dependencies --constraint="template-haskell installed" --dependencies-only --enable-tests
+    - cabal configure --enable-tests -f ci
 test:
  post:
-    - cabal exec hlint -- -X QuasiQuotes src/*.hs test/**/*.hs
+    - cabal exec hlint -- -X QuasiQuotes src/**/*.hs test/**/*.hs
    - cabal exec packdeps postgrest.cabal
@@ -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.7.0
+version:               0.2.10.0
 synopsis:              REST API for any Postgres database
 license:               MIT
 license-file:          LICENSE
@@ -12,15 +12,23 @@ maintainer:            cred+github@begriffs.com
 category:              Web
 build-type:            Simple
 cabal-version:         >=1.10
+source-repository head
+  type: git
+  location: git://github.com/begriffs/postgrest.git
+
+Flag CI
+  Description: No warnings allowed in continuous integration
+  Manual:      True
+  Default:     False

 executable postgrest
-  main-is:             Main.hs
-  ghc-options:         -Wall -W -O2
-  default-language:    Haskell2010
+  main-is:             PostgREST/Main.hs
  default-extensions:  OverloadedStrings, ScopedTypeVariables, QuasiQuotes
+  default-language:    Haskell2010
  build-depends:       base >=4.6 && <5
-                     , hasql == 0.7.*, hasql-backend
-                     , hasql-postgres == 0.10.*
+                     , postgrest
+                     , hasql == 0.7.3.1, hasql-backend == 0.4.1
+                     , hasql-postgres == 0.10.3.1
                     , warp >= 3.0.2, wai >= 3.0.1
                     , wai-extra, wai-cors
                     , wai-middleware-static >= 0.6.0
@@ -42,15 +50,52 @@ executable postgrest
                     , blaze-builder
                     , vector
                     , mtl
-  Other-Modules:       App
-                     , Auth
-                     , Config
-                     , Error
-                     , Middleware
-                     , PgQuery
-                     , PgStructure
-                     , RangeQuery
-                     , Types
+                     , cassava
+                     , jwt
+  hs-source-dirs:      src
+
+library
+  if flag(ci)
+    ghc-options:       -Wall -W -Werror
+  else
+    ghc-options:       -Wall -W -O2
+
+  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
+                     , wai-extra, wai-cors
+                     , wai-middleware-static >= 0.6.0
+                     , HTTP, convertible, http-types
+                     , case-insensitive
+                     , scientific, time
+                     , aeson, network >= 2.6
+                     , bytestring, text, split, string-conversions
+                     , stringsearch
+                     , containers, unordered-containers
+                     , optparse-applicative == 0.11.*
+                     , regex-base, regex-tdfa
+                     , regex-tdfa-text
+                     , Ranged-sets
+                     , transformers, MissingH
+                     , bcrypt >= 0.0.6, base64-string
+                     , network-uri >= 2.6
+                     , resource-pool
+                     , blaze-builder
+                     , vector
+                     , mtl
+                     , cassava
+                     , jwt
+  Exposed-Modules:     PostgREST.App
+                     , PostgREST.Auth
+                     , PostgREST.Config
+                     , PostgREST.Error
+                     , PostgREST.Middleware
+                     , PostgREST.PgQuery
+                     , PostgREST.PgStructure
+                     , PostgREST.RangeQuery
  hs-source-dirs:      src

 Test-Suite spec
@@ -58,23 +103,25 @@ Test-Suite spec
  Default-Language:    Haskell2010
  default-extensions:  OverloadedStrings, ScopedTypeVariables, QuasiQuotes
  Hs-Source-Dirs:      test, src
-  ghc-options:         -Wall -W -Werror
+  if flag(ci)
+    ghc-options:       -Wall -W -Werror
+  else
+    ghc-options:       -Wall -W -O2
  Main-Is:             Main.hs
-  Other-Modules:       App
-                     , Auth
-                     , Config
-                     , Error
-                     , Middleware
-                     , PgQuery
-                     , PgStructure
-                     , RangeQuery
-                     , Types
+  Other-Modules:       PostgREST.App
+                     , PostgREST.Auth
+                     , PostgREST.Config
+                     , PostgREST.Error
+                     , PostgREST.Middleware
+                     , PostgREST.PgQuery
+                     , PostgREST.PgStructure
+                     , PostgREST.RangeQuery
                     , Spec
                     , SpecHelper
  Build-Depends:       base, hspec >= 2.1.2, QuickCheck
                     , hspec-wai >= 0.5.0, hspec-wai-json
-                     , hasql, hasql-backend
-                     , hasql-postgres
+                     , hasql == 0.7.3.1, hasql-backend == 0.4.1
+                     , hasql-postgres == 0.10.3.1
                     , warp, wai
                     , packdeps, hlint
                     , HTTP, convertible
@@ -98,4 +145,7 @@ Test-Suite spec
                     , blaze-builder
                     , vector
                     , mtl
+                     , cassava
                     , process
+                     , heredoc
+                     , jwt
@@ -1,27 +1,31 @@
 {-# LANGUAGE FlexibleContexts #-}
-module App (app, sqlError, isSqlError) where
+module PostgREST.App (app, sqlError, isSqlError) where

 import Control.Monad (join)
-import Control.Arrow ((***))
+import Control.Arrow ((***), second)
 import Control.Applicative

 import Data.Text hiding (map)
-import Data.Maybe (fromMaybe)
+import Data.Maybe (fromMaybe, mapMaybe)
 import Text.Regex.TDFA ((=~))
 import Data.Ord (comparing)
 import Data.Ranged.Ranges (emptyRange)
-import Data.HashMap.Strict (keys, elems, filterWithKey, toList)
+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 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 Data.Aeson
 import Data.Monoid
@@ -30,13 +34,16 @@ import qualified Hasql as H
 import qualified Hasql.Backend as B
 import qualified Hasql.Postgres as P

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

-app :: Text -> BL.ByteString -> Request -> H.Tx P.Postgres s Response
-app v1schema reqBody req =
+import Prelude
+
+app :: AppConfig -> BL.ByteString -> Request -> H.Tx P.Postgres s Response
+app conf reqBody req =
  case (path, verb) of
    ([], _) -> do
      body <- encode <$> tables (cs schema)
@@ -98,26 +105,61 @@ app v1schema reqBody req =
            , (hLocation, "/postgrest/users?id=eq." <> cs (userId u))
            ] ""

-    ([table], "POST") ->
-      handleJsonObj reqBody $ \obj -> do
-        let qt = QualifiedTable schema (cs table)
-            query = insertInto qt (map cs $ keys obj) (elems obj)
-            echoRequested = lookup "Prefer" hdrs == Just "return=representation"
-        row <- H.maybeEx query
-        let (Identity insertedJson) = fromMaybe (Identity "{}" :: Identity Text) row
-            Just inserted = decode (cs insertedJson) :: Maybe Object
+    (["postgrest", "tokens"], "POST") ->
+      case jwtSecret of
+        "secret" -> return $ responseLBS status500 [jsonH] $
+          encode . object $ [("message", String "JWT Secret is set as \"secret\" which is an unsafe default.")]
+        _ -> do
+          let user = decode reqBody :: Maybe AuthUser

-        primaryKeys <- map cs <$> primaryKeyColumns qt
-        let primaries = if Prelude.null primaryKeys
-            then inserted
-            else filterWithKey (const . (`elem` primaryKeys)) inserted
-        let params = urlEncodeVars
-              $ map (\t -> (cs $ fst t, "eq." <> cs (unquoted $ snd t)))
-              $ sortBy (comparing fst) $ toList primaries
-        return $ responseLBS status201
-          [ jsonH
-          , (hLocation, "/" <> cs table <> "?" <> cs params)
-          ] $ if echoRequested then cs insertedJson else ""
+          case user of
+            Nothing -> return $ responseLBS status400 [jsonH] $
+              encode . object $ [("message", String "Failed to parse user.")]
+            Just u -> do
+              setRole authenticator
+              login <- signInRole (cs $ userId u)
+                              (cs $ userPass u)
+              case login of
+                LoginSuccess role uid ->
+                  return $ responseLBS status201 [ jsonH ] $
+                    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"
+          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"
+      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
+                let primaries =
+                      if Prelude.null primaryKeys
+                        then obj
+                        else M.filterWithKey (const . (`elem` primaryKeys)) obj
+                let params = urlEncodeVars
+                      $ map (\t -> (cs $ fst t, cs (paramFilter $ snd t)))
+                      $ sortBy (comparing fst) $ M.toList primaries
+                responseLBS status201
+                  [ jsonH
+                  , (hLocation, "/" <> cs table <> "?" <> cs params)
+                  ] $ if echoRequested then encode obj else ""
+          return $ multipart status201 responses

    ([table], "PUT") ->
      handleJsonObj reqBody $ \obj -> do
@@ -129,10 +171,10 @@ app v1schema reqBody req =
               "You must speficy all and only primary keys as params"
          else do
            tableCols <- map (cs . colName) <$> columns qt
-            let cols = map cs $ keys obj
+            let cols = map cs $ M.keys obj
            if S.fromList tableCols == S.fromList cols
              then do
-                let vals = elems obj
+                let vals = M.elems obj
                H.unitEx $ iffNotT
                        (whereT qq $ update qt cols vals)
                        (insertSelect qt cols vals)
@@ -146,10 +188,22 @@ app v1schema reqBody req =
    ([table], "PATCH") ->
      handleJsonObj reqBody $ \obj -> do
        let qt = QualifiedTable schema (cs table)
-        H.unitEx
-          $ whereT qq
-          $ update qt (map cs $ keys obj) (elems obj)
-        return $ responseLBS status204 [ jsonH ] ""
+            up = returningStarT
+               . whereT 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
+
+        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"
+            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)
@@ -171,7 +225,9 @@ app v1schema reqBody req =
    verb   = requestMethod req
    qq     = queryString req
    hdrs   = requestHeaders req
-    schema = requestedSchema v1schema hdrs
+    schema = requestedSchema (cs $ configV1Schema conf) hdrs
+    authenticator = cs $ configDbUser conf
+    jwtSecret = cs $ configJwtSecret conf
    range  = rangeRequested hdrs
    allOrigins = ("Access-Control-Allow-Origin", "*") :: Header

@@ -227,6 +283,26 @@ handleJsonObj reqBody handler = do
        jErr = encode . object $
          [("message", String "Expecting a JSON object")]

+parseCsvCell :: BL.ByteString -> Value
+parseCsvCell s = if s == "NULL" then Null else String $ cs s
+
+multipart :: Status -> [Response] -> Response
+multipart _ [] = responseLBS status204 [] ""
+multipart _ [r] = r
+multipart s rs =
+  responseLBS s [(hContentType, "multipart/mixed; boundary=\"postgrest_boundary\"")] $
+    BL.intercalate "\n--postgrest_boundary\n" (map renderResponseBody rs)
+
+  where
+    renderHeader :: Header -> BL.ByteString
+    renderHeader (k, v) = cs (original k) <> ": " <> cs v
+
+    renderResponseBody :: Response -> BL.ByteString
+    renderResponseBody (ResponseBuilder _ headers b) =
+      BL.intercalate "\n" (map renderHeader headers)
+        <> "\n\n" <> BB.toLazyByteString b
+    renderResponseBody _ = error
+      "Unable to create multipart response from non-ResponseBuilder"

 data TableOptions = TableOptions {
  tblOptcolumns :: [Column]
@@ -1,18 +1,22 @@
 {-# LANGUAGE QuasiQuotes, ScopedTypeVariables, OverloadedStrings #-}
-module Auth where
+module PostgREST.Auth where

 import Data.Aeson
 import Control.Monad (mzero)
-import Control.Applicative ( (<*>), (<$>) )
+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 PgQuery (pgFmtLit)
+import PostgREST.PgQuery (pgFmtLit)
+
+import Prelude

 import System.IO.Unsafe

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

 instance ToJSON AuthUser where
@@ -36,12 +40,13 @@ 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
@@ -53,6 +58,15 @@ setRole role = H.unitEx $ B.Stmt ("set role " <> cs (pgFmtLit role)) V.empty Tru
 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 user_vars.user_id = " <> cs (pgFmtLit uid)) V.empty True
+else
+  resetUserId
+
+resetUserId :: H.Tx P.Postgres s ()
+resetUserId = H.unitEx [H.stmt|reset user_vars.user_id|]
+
 addUser :: Text -> Text -> Text -> H.Tx P.Postgres s ()
 addUser identity pass role = do
  let Just hashed = unsafePerformIO $ hashPasswordUsingPolicy fastBcryptHashingPolicy (cs pass)
@@ -62,10 +76,29 @@ addUser identity pass role = do

 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)) -> case maybeUserId of
+      Just (Just (String uid)) -> LoginSuccess (cs role) (cs uid)
+      _   -> LoginFailed
+    _   -> LoginFailed
+  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,4 +1,4 @@
-module Config where
+module PostgREST.Config where

 import Network.Wai
 import Control.Applicative
@@ -8,6 +8,7 @@ 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

 data AppConfig = AppConfig {
    configDbName :: String
@@ -21,6 +22,8 @@ data AppConfig = AppConfig {
  , configSecure :: Bool
  , configPool :: Int
  , configV1Schema :: String
+  
+  , configJwtSecret :: String
  }

 argParser :: Parser AppConfig
@@ -36,6 +39,7 @@ argParser = AppConfig
  <*> switch (long "secure" <> short 's' <> help "Redirect all requests to HTTPS")
  <*> option auto (long "db-pool" <> metavar "COUNT" <> value 10 <> help "Max connections in database pool" <> showDefault)
  <*> strOption (long "v1schema" <> metavar "NAME" <> value "1" <> help "Schema to use for nonspecified version (or explicit v1)" <> showDefault)
+  <*> strOption (long "jwt-secret" <> metavar "SECRET" <> value "secret" <> help "Secret used to encrypt and decrypt JWT tokens)" <> showDefault)

 defaultCorsPolicy :: CorsResourcePolicy
 defaultCorsPolicy =  CorsResourcePolicy Nothing
@@ -1,7 +1,7 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 {-# LANGUAGE FlexibleInstances, TypeSynonymInstances #-}

-module Error (PgError, errResponse) where
+module PostgREST.Error (PgError, errResponse) where

 import qualified Hasql as H
 import qualified Hasql.Postgres as P
@@ -2,9 +2,9 @@ module Main where

 import Paths_postgrest (version)

-import App
-import Middleware
-import Error(errResponse)
+import PostgREST.App
+import PostgREST.Middleware
+import PostgREST.Error(errResponse)

 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
@@ -21,7 +21,7 @@ import qualified Hasql as H
 import qualified Hasql.Postgres as P
 import Options.Applicative hiding (columns)

-import Config (AppConfig(..), argParser, corsPolicy)
+import PostgREST.Config (AppConfig(..), argParser, corsPolicy)

 main :: IO ()
 main = do
@@ -32,11 +32,14 @@ main = do
                    <> prettyVersion
                    <> " / create a REST API to an existing Postgres database"
                )
-  conf <- execParser opts
+      parserPrefs = prefs showHelpOnError
+  conf <- customExecParser parserPrefs opts
  let port = configPort conf

  unless (configSecure conf) $
    putStrLn "WARNING, running in insecure mode, auth will be in plaintext"
+  unless ("secret" /= configJwtSecret conf) $
+    putStrLn "WARNING, running in insecure mode, JWT secret is the default value"
  Prelude.putStrLn $ "Listening on port " ++
    (show $ configPort conf :: String)

@@ -52,8 +55,6 @@ main = do
        . (if configSecure conf then redirectInsecure else id)
        . gzip def . cors corsPolicy
        . staticPolicy (only [("favicon.ico", "static/favicon.ico")])
-      anonRole = cs $ configAnonRole conf
-      currRole = cs $ configDbUser conf

  poolSettings <- maybe (fail "Improper session settings") return $
                H.poolSettings (fromIntegral $ configPool conf) 30
@@ -63,7 +64,7 @@ main = do
  runSettings appSettings $ middle $ \req respond -> do
    body <- strictRequestBody req
    resOrError <- liftIO $ H.session pool $ H.tx Nothing $
-      authenticated currRole anonRole (app (cs $ configV1Schema conf) body) req
+      authenticated conf (app conf body) req
    either (respond . errResponse) respond resOrError

  where
@@ -1,10 +1,10 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 {-# LANGUAGE ScopedTypeVariables #-}

-module Middleware where
+module PostgREST.Middleware where

 import Data.Maybe (fromMaybe)
-import Data.Monoid (mconcat)
+import Data.Monoid
 import Data.Text
 -- import Data.Pool(withResource, Pool)

@@ -19,23 +19,29 @@ import Network.Wai (Application, requestHeaders, responseLBS, rawPathInfo,
                   rawQueryString, isSecure, Request(..), Response)
 import Network.URI (URI(..), parseURI)

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

-authenticated :: forall s. Text -> Text ->
+import Prelude
+
+authenticated :: forall s. AppConfig ->
                 (Request -> H.Tx P.Postgres s Response) ->
                 Request -> H.Tx P.Postgres s Response
-authenticated currentRole anon app req = do
+authenticated conf app req = do
  attempt <- httpRequesterRole (requestHeaders req)
  case attempt of
    MalformedAuth ->
      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 req
+    NoCredentials         -> if anon /= currentRole then runInRole anon "" else app req

 where
+   jwtSecret = cs $ configJwtSecret conf
+   currentRole = cs $ configDbUser conf
+   anon = cs $ configAnonRole conf
   httpRequesterRole :: RequestHeaders -> H.Tx P.Postgres s LoginAttempt
   httpRequesterRole hdrs = do
    let auth = fromMaybe "" $ lookup hAuthorization hdrs
@@ -44,13 +50,17 @@ authenticated currentRole anon app req = do
        case split (==':') (cs . decode . cs $ b64) of
          (u:p:_) -> signInRole u p
          _ -> return MalformedAuth
+      ("Bearer" : jwt : _) ->
+        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
+     resetUserId
     return res


@@ -1,9 +1,9 @@
-{-# LANGUAGE TypeSynonymInstances, FlexibleInstances #-}
+{-# LANGUAGE TypeSynonymInstances, FlexibleInstances, MultiWayIf #-}
 {-# OPTIONS_GHC -fno-warn-orphans #-}

-module PgQuery where
+module PostgREST.PgQuery where

-import RangeQuery
+import PostgREST.RangeQuery

 import qualified Hasql as H
 import qualified Hasql.Postgres as P
@@ -17,13 +17,16 @@ import qualified Data.ByteString.Char8 as BS
 import Data.Monoid
 import Data.Vector (empty)
 import Data.Maybe (fromMaybe, mapMaybe)
-import Data.Functor ( (<$>) )
+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 Prelude
+
 type PStmt = H.Stmt P.Postgres
 instance Monoid PStmt where
  mappend (B.Stmt query params prep) (B.Stmt query' params' prep') =
@@ -39,6 +42,7 @@ data QualifiedTable = QualifiedTable {
 data OrderTerm = OrderTerm {
  otTerm :: T.Text
 , otDirection :: BS.ByteString
+, otNullOrder :: Maybe BS.ByteString
 }

 limitT :: Maybe NonnegRange -> StatementT
@@ -57,6 +61,12 @@ whereT params q =
   cols = [ col | col <- params, fst col `notElem` ["order"] ]
   conjunction = mconcat $ L.intersperse andq (map wherePred cols)

+withT :: PStmt -> T.Text -> StatementT
+withT (B.Stmt eq ep epre) v (B.Stmt wq wp wpre) =
+  B.Stmt ("WITH " <> v <> " AS (" <> eq <> ") " <> wq <> " from " <> v)
+    (ep <> wp)
+    (epre && wpre)
+
 orderT :: [OrderTerm] -> StatementT
 orderT ts q =
  if L.null ts
@@ -67,7 +77,8 @@ orderT ts q =
   queryTerm :: OrderTerm -> PStmt
   queryTerm t = B.Stmt
                   (" " <> cs (pgFmtIdent $ otTerm t) <> " "
-                        <> cs (otDirection t)         <> " ")
+                        <> cs (otDirection t)         <> " "
+                        <> maybe "" cs (otNullOrder t) <> " ")
                   empty True

 parentheticT :: StatementT
@@ -106,16 +117,24 @@ returningStarT s = s { B.stmtTemplate = B.stmtTemplate s <> " RETURNING *" }
 deleteFrom :: QualifiedTable -> PStmt
 deleteFrom t = B.Stmt ("delete from " <> fromQt t) empty True

-insertInto :: QualifiedTable -> [T.Text] -> [JSON.Value] -> PStmt
-insertInto t [] _ = B.Stmt
-  ("insert into " <> fromQt t <> " default values returning *") empty True
-insertInto t cols vals = B.Stmt
-  ("insert into " <> fromQt t <> " (" <>
-    T.intercalate ", " (map pgFmtIdent cols) <>
-    ") values ("
-    <> T.intercalate ", " (map ((<> "::unknown") . pgFmtLit . unquoted) vals)
-    <> ") returning row_to_json(" <> fromQt t <> ".*)")
-  empty True
+insertInto :: QualifiedTable
+              -> 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
+  | otherwise   = B.Stmt
+    ("insert into " <> fromQt t <> " (" <>
+      T.intercalate ", " (V.toList $ V.map pgFmtIdent cols) <>
+      ") values "
+      <> T.intercalate ", "
+        (V.toList $ V.map (\v -> "("
+            <> T.intercalate ", " (V.toList $ V.map insertableValue v)
+            <> ")"
+          ) vals
+        )
+      <> " returning row_to_json(" <> fromQt t <> ".*)")
+    empty True

 insertSelect :: QualifiedTable -> [T.Text] -> [JSON.Value] -> PStmt
 insertSelect t [] _ = B.Stmt
@@ -124,7 +143,7 @@ insertSelect t cols vals = B.Stmt
  ("insert into " <> fromQt t <> " ("
    <> T.intercalate ", " (map pgFmtIdent cols)
    <> ") select "
-    <> T.intercalate ", " (map ((<> "::unknown") . pgFmtLit . unquoted) vals))
+    <> T.intercalate ", " (map insertableValue vals))
  empty True

 update :: QualifiedTable -> [T.Text] -> [JSON.Value] -> PStmt
@@ -132,19 +151,23 @@ update t cols vals = B.Stmt
  ("update " <> fromQt t <> " set ("
    <> T.intercalate ", " (map pgFmtIdent cols)
    <> ") = ("
-    <> T.intercalate ", " (map ((<> "::unknown") . pgFmtLit . unquoted) vals)
+    <> T.intercalate ", " (map insertableValue vals)
    <> ")")
  empty True

 wherePred :: Net.QueryItem -> PStmt
-wherePred (col, predicate) = B.Stmt
-  (" " <> cs (pgFmtIdent $ cs col) <> " " <> op <> " " <> cs sqlValue)
-  empty True
+wherePred (col, predicate) =
+  B.Stmt (" " <> pgFmtJsonbPath (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"])
    star c = if c == '*' then '%' else c
    unknownLiteral = (<> "::unknown ") . pgFmtLit

@@ -152,6 +175,7 @@ wherePred (col, predicate) = B.Stmt
            "like" -> unknownLiteral $ T.map star value
            "ilike" -> unknownLiteral $ T.map star value
            "in" -> "(" <> T.intercalate ", " (map unknownLiteral $ T.split (==',') value) <> ") "
+            "@@" -> "to_tsquery(" <> unknownLiteral value <> ") "
            _    -> unknownLiteral value

    op = case opCode of
@@ -164,6 +188,9 @@ wherePred (col, predicate) = B.Stmt
         "like"-> "like"
         "ilike"-> "ilike"
         "in"  -> "in"
+         "is"    -> "is"
+         "isnot" -> "is not"
+         "@@" -> "@@"
         _     -> "="

 orderParse :: Net.Query -> [OrderTerm]
@@ -175,10 +202,16 @@ orderParse q =
 orderParseTerm :: T.Text -> Maybe OrderTerm
 orderParseTerm s =
  case T.split (=='.') s of
-       [c,d] ->
+       (c:d:nls) ->
         if d `elem` ["asc", "desc"]
-            then Just $ OrderTerm c $
-              if d == "asc" then "asc" else "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

@@ -188,6 +221,34 @@ commaq  = B.Stmt ", " empty True
 andq :: PStmt
 andq = B.Stmt " and " empty True

+data JsonbPath =
+    ColIdentifier T.Text
+  | KeyIdentifier T.Text
+  | SingleArrow JsonbPath JsonbPath
+  | DoubleArrow JsonbPath JsonbPath
+  deriving (Show)
+
+parseJsonbPath :: T.Text -> Maybe JsonbPath
+parseJsonbPath p =
+  case T.splitOn "->>" p of
+    [a,b] ->
+      let i:is = T.splitOn "->" a in
+      Just $ DoubleArrow
+        (foldl SingleArrow (ColIdentifier i) (map KeyIdentifier is))
+        (KeyIdentifier b)
+    _ -> Nothing
+
+pgFmtJsonbPath :: T.Text -> T.Text
+pgFmtJsonbPath p =
+  pgFmtJsonbPath' $ fromMaybe (ColIdentifier p) (parseJsonbPath p)
+  where
+    pgFmtJsonbPath' (ColIdentifier i) = pgFmtIdent i
+    pgFmtJsonbPath' (KeyIdentifier i) = pgFmtLit i
+    pgFmtJsonbPath' (SingleArrow a b) =
+      pgFmtJsonbPath' a <> "->" <> pgFmtJsonbPath' b
+    pgFmtJsonbPath' (DoubleArrow a b) =
+      pgFmtJsonbPath' a <> "->>" <> pgFmtJsonbPath' b
+
 pgFmtIdent :: T.Text -> T.Text
 pgFmtIdent x =
  let escaped = T.replace "\"" "\"\"" (trimNullChars $ cs x) in
@@ -217,4 +278,15 @@ unquoted (JSON.String t) = t
 unquoted (JSON.Number n) =
  cs $ formatScientific Fixed (if isInteger n then Just 0 else Nothing) n
 unquoted (JSON.Bool b) = cs . show $ b
-unquoted _ = ""
+unquoted v = cs $ JSON.encode v
+
+insertableText :: T.Text -> T.Text
+insertableText = (<> "::unknown") . pgFmtLit
+
+insertableValue :: JSON.Value -> T.Text
+insertableValue JSON.Null = "null"
+insertableValue v = insertableText $ unquoted v
+
+paramFilter :: JSON.Value -> T.Text
+paramFilter JSON.Null = "is.null"
+paramFilter v = "eq." <> unquoted v
@@ -1,20 +1,23 @@
 {-# LANGUAGE QuasiQuotes, OverloadedStrings, TypeSynonymInstances,
-             MultiParamTypeClasses, ScopedTypeVariables #-}
-module PgStructure where
+             MultiParamTypeClasses, ScopedTypeVariables,
+             FlexibleContexts #-}
+module PostgREST.PgStructure where

-import PgQuery (QualifiedTable(..))
+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 qualified Data.Map as Map

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

+import Prelude
+
 foreignKeys :: QualifiedTable -> H.Tx P.Postgres s (Map.Map Text ForeignKey)
 foreignKeys table = do
  r <- H.listEx $ [H.stmt|
@@ -1,4 +1,4 @@
-module RangeQuery (
+module PostgREST.RangeQuery (
  rangeParse
 , rangeRequested
 , rangeLimit
@@ -20,6 +20,8 @@ import Text.Read (readMaybe)

 import Data.Maybe (fromMaybe, listToMaybe)

+import Prelude
+
 type NonnegRange = Range Int

 rangeParse :: BS.ByteString -> Maybe NonnegRange
@@ -1,57 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-module Types where
-
-import qualified Data.Aeson as JSON
-import Data.Aeson.Types (Parser)
-
-import Data.Scientific (floatingOrInteger)
-import Data.HashMap.Strict (foldlWithKey')
-import Data.Text (Text)
-import Data.Text.Encoding (decodeUtf8)
-import Data.Time.Calendar (showGregorian)
-import Control.Monad (mzero)
-
-instance JSON.FromJSON SqlValue where
-  parseJSON (JSON.Number n)    = return $ either toSql iToSql (floatingOrInteger n :: Either Double Int)
-  parseJSON (JSON.String s)    = return $ toSql s
-  parseJSON (JSON.Bool   b)    = return $ toSql b
-  parseJSON JSON.Null          = return SqlNull
-  parseJSON (JSON.Object o)    = return . toSql $ JSON.encode o
-  parseJSON (JSON.Array  a)    = return . toSql $ JSON.encode a
-
-instance JSON.ToJSON SqlValue where
-  toJSON (SqlString s)         = JSON.toJSON s
-  toJSON (SqlByteString s)     = JSON.toJSON $ decodeUtf8 s
-  toJSON (SqlWord32 w)         = JSON.toJSON w
-  toJSON (SqlWord64 w)         = JSON.toJSON w
-  toJSON (SqlInt32 i)          = JSON.toJSON i
-  toJSON (SqlInt64 i)          = JSON.toJSON i
-  toJSON (SqlInteger i)        = JSON.toJSON i
-  toJSON (SqlChar c)           = JSON.toJSON c
-  toJSON (SqlBool b)           = JSON.toJSON b
-  toJSON (SqlDouble n)         = JSON.toJSON n
-  toJSON (SqlRational n)       = JSON.toJSON n
-  toJSON (SqlLocalDate d)      = JSON.toJSON $ showGregorian d
-  toJSON (SqlLocalTimeOfDay t) = JSON.toJSON $ show t
-  toJSON (SqlLocalTime t)      = JSON.toJSON $ show t
-  toJSON SqlNull               = JSON.Null
-  toJSON x                     = JSON.toJSON $ show x
-
-
-newtype SqlRow = SqlRow {getRow :: [(Text, SqlValue)] } deriving (Show)
-
-sqlRowColumns :: SqlRow -> [Text]
-sqlRowColumns = map fst . getRow
-
-sqlRowValues :: SqlRow -> [SqlValue]
-sqlRowValues = map snd . getRow
-
-instance JSON.FromJSON SqlRow where
-  parseJSON (JSON.Object m) = foldlWithKey' add (return $ SqlRow []) m
-    where
-      add :: Parser SqlRow -> Text -> JSON.Value -> Parser SqlRow
-      add parser k v = do
-        SqlRow l <- parser
-        sqlV <- JSON.parseJSON v
-        return . SqlRow $ (k, sqlV) : l
-  parseJSON _ = mzero
@@ -18,13 +18,37 @@ spec = beforeAll
  it "hides tables that anonymous does not own" $
    get "/authors_only" `shouldRespondWith` 404

-  it "indicates login failure" $ do
-    let auth = authHeader "postgrest_test_author" "fakefake"
+  it "indicates login failure (BasicAuth)" $ do
+    let auth = authHeaderBasic "postgrest_test_author" "fakefake"
    request methodGet "/authors_only" [auth] ""
      `shouldRespondWith` 401

-  it "allows users with permissions to see their tables" $ do
+  it "allows users with permissions to see their tables (BasicAuth)" $ do
    _ <- post "/postgrest/users" [json| { "id":"jdoe", "pass": "1234", "role": "postgrest_test_author" } |]
-    let auth = authHeader "jdoe" "1234"
+    let auth = authHeaderBasic "jdoe" "1234"
    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" } |] 
+      `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" } |] 
+      `shouldRespondWith` ResponseMatcher {
+          matchBody = Just [json| {"message":"Failed authentication."} |]
+        , matchStatus = 401
+        , matchHeaders = ["Content-Type" <:> "application/json"]
+        }
+
+  it "allows users with permissions to see their tables (JWT)" $ do
+    _ <- 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
@@ -9,6 +9,7 @@ import SpecHelper

 import qualified Data.Aeson as JSON
 import Data.Maybe (fromJust)
+import Text.Heredoc
 import Network.HTTP.Types.Header
 import Network.HTTP.Types
 import Control.Monad (replicateM_)
@@ -66,6 +67,15 @@ spec = afterAll_ resetDb $ around withApp $ do
            simpleHeaders p `shouldSatisfy` matchHeader hLocation "/no_pk\\?a=eq.bar&b=eq.baz"
            simpleStatus p `shouldBe` created201

+        it "can post nulls" $ do
+          p <- request methodPost "/no_pk"
+                       [("Prefer", "return=representation")]
+                       [json| { "a":null, "b":"foo" } |]
+          liftIO $ do
+            simpleBody p `shouldBe` [json| { "a":null, "b":"foo" } |]
+            simpleHeaders p `shouldSatisfy` matchHeader hLocation "/no_pk\\?a=is.null&b=eq.foo"
+            simpleStatus p `shouldBe` created201
+
    context "with compound pk supplied" . after_ (clearTable "compound_pk") $
      it "builds response location header appropriately" $
        post "/compound_pk" [json| { "k1":12, "k2":42 } |]
@@ -84,6 +94,66 @@ spec = afterAll_ resetDb $ around withApp $ do
          , matchHeaders = []
          }

+    context "jsonb" . after_ (clearTable "json") $ do
+      it "serializes nested object" $ do
+        let inserted = [json| { "data": { "foo":"bar" } } |]
+        p <- request methodPost "json" [("Prefer", "return=representation")] inserted
+        liftIO $ do
+          simpleBody p `shouldBe` inserted
+          simpleHeaders p `shouldSatisfy` matchHeader hLocation "/json\\?data=eq\\.%7B%22foo%22%3A%22bar%22%7D"
+          simpleStatus p `shouldBe` created201
+      it "serializes nested array" $ do
+        let inserted = [json| { "data": [1,2,3] } |]
+        p <- request methodPost "json" [("Prefer", "return=representation")] inserted
+        liftIO $ do
+          simpleBody p `shouldBe` inserted
+          simpleHeaders p `shouldSatisfy` matchHeader hLocation "/json\\?data=eq\\.%5B1%2C2%2C3%5D"
+          simpleStatus p `shouldBe` created201
+
+  describe "CSV insert" $ do
+
+    after_ (clearTable "menagerie") . context "disparate csv types" $
+      it "succeeds with multipart response" $ do
+        p <- request methodPost "/menagerie" [("Content-Type", "text/csv")]
+               [str|integer,double,varchar,boolean,date,money,enum
+                   |13,3.14159,testing!,false,1900-01-01,$3.99,foo
+                   |12,0.1,a string,true,1929-10-01,12,bar
+                   |]
+        liftIO $ do
+          simpleBody p `shouldBe` "Content-Type: application/json\nLocation: /menagerie?integer=eq.13\n\n\n--postgrest_boundary\nContent-Type: application/json\nLocation: /menagerie?integer=eq.12\n\n"
+          simpleStatus p `shouldBe` created201
+
+    after_ (clearTable "no_pk") . context "requesting full representation" $ do
+      it "returns full details of inserted record" $
+        request methodPost "/no_pk"
+                     [("Content-Type", "text/csv"), ("Prefer", "return=representation")]
+                     "a,b\nbar,baz"
+          `shouldRespondWith` ResponseMatcher {
+            matchBody    = Just [json| { "a":"bar", "b":"baz" } |]
+          , matchStatus  = 201
+          , matchHeaders = ["Content-Type" <:> "application/json",
+                            "Location" <:> "/no_pk?a=eq.bar&b=eq.baz"]
+          }
+
+      it "can post nulls" $
+        request methodPost "/no_pk"
+                     [("Content-Type", "text/csv"), ("Prefer", "return=representation")]
+                     "a,b\nNULL,foo"
+          `shouldRespondWith` ResponseMatcher {
+            matchBody    = Just [json| { "a":null, "b":"foo" } |]
+          , matchStatus  = 201
+          , matchHeaders = ["Content-Type" <:> "application/json",
+                            "Location" <:> "/no_pk?a=is.null&b=eq.foo"]
+          }
+
+    after_ (clearTable "no_pk") . context "with wrong number of columns" $ do
+      it "fails for too few" $ do
+        p <- request methodPost "/no_pk" [("Content-Type", "text/csv")] "a,b\nfoo,bar\nbaz"
+        liftIO $ simpleStatus p `shouldBe` badRequest400
+      it "fails for too many" $ do
+        p <- request methodPost "/no_pk" [("Content-Type", "text/csv")] "a,b\nfoo,bar\nbaz,bat,bad"
+        liftIO $ simpleStatus p `shouldBe` badRequest400
+
  describe "Putting record" $ do

    context "to unkonwn uri" $
@@ -162,10 +232,10 @@ spec = afterAll_ resetDb $ around withApp $ do
            `shouldRespondWith` 404

    context "on an empty table" $
-      it "succeeds with no effect" $
+      it "indicates no records found to update" $
        request methodPatch "/simple_pk" []
          [json| { "extra":20 } |]
-            `shouldRespondWith` 204
+            `shouldRespondWith` 404

    context "in a nonempty table" . before_ (clearTable "items" >> createItems 15) .
      after_ (clearTable "items") $ do
@@ -175,7 +245,11 @@ spec = afterAll_ resetDb $ around withApp $ do
          `shouldSatisfy` matchHeader "Content-Range" "\\*/0"
        request methodPatch "/items?id=eq.1" []
          [json| { "id":42 } |]
-            `shouldRespondWith` 204
+            `shouldRespondWith` ResponseMatcher {
+              matchBody    = Nothing,
+              matchStatus  = 204,
+              matchHeaders = ["Content-Range" <:> "0-0/1"]
+            }
        g' <- get "/items?id=eq.42"
        liftIO $ simpleHeaders g'
          `shouldSatisfy` matchHeader "Content-Range" "0-0/1"
@@ -191,3 +265,32 @@ spec = afterAll_ resetDb $ around withApp $ do
        g <- get "/auto_incrementing_pk?non_nullable_string=eq.c"
        liftIO $ simpleHeaders g
          `shouldSatisfy` matchHeader "Content-Range" "0-9/10"
+
+      it "can provide a representation" $ do
+        _ <- post "/items"
+          [json| { id: 1 } |]
+        request methodPatch
+          "/items?id=eq.1"
+          [("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
@@ -3,28 +3,20 @@ module Feature.QuerySpec where
 import Test.Hspec
 import Test.Hspec.Wai
 import Test.Hspec.Wai.JSON
-import Hasql as H
-import Hasql.Postgres as H
-import Control.Monad (void)
-import Data.Text(Text)
+import Network.Wai.Test (SResponse(simpleHeaders))

 import SpecHelper

-testSet :: IO ()
-testSet = do
-  clearTable "items" >> clearTable "no_pk"
-  createItems 15
-  pool <- H.acquirePool pgSettings testPoolOpts
-  void . liftIO $ H.session pool $ H.tx Nothing $ do
-    H.unitEx $ insertNoPk "xyyx" "u"
-    H.unitEx $ insertNoPk "xYYx" "v"
-
-  where
-    insertNoPk :: Text -> Text -> H.Stmt H.Postgres
-    insertNoPk = [H.stmt|insert into "1".no_pk (a, b) values (?,?)|]
-
 spec :: Spec
-spec = beforeAll testSet . afterAll_ (clearTable "items") . around withApp $ do
+spec =
+  beforeAll (clearTable "items" >> createItems 15)
+   . beforeAll (
+       clearTable "no_pk" >>
+       createNulls 2 >>
+       createLikableStrings >>
+       createJsonData)
+   . afterAll_ (clearTable "items" >> clearTable "no_pk" >> clearTable "simple_pk")
+   . around withApp $ do
  describe "Querying a nonexistent table" $
    it "causes a 404" $
      get "/faketable" `shouldRespondWith` 404
@@ -46,19 +38,27 @@ spec = beforeAll testSet . afterAll_ (clearTable "items") . around withApp $ do
        , matchHeaders = ["Content-Range" <:> "0-2/3"]
        }

+    it "matches nulls" $
+      get "/no_pk?a=is.null" `shouldRespondWith`
+        [json| [{"a": null, "b": null}] |]
+
    it "matches with like" $ do
-      get "/no_pk?a=like.*yx" `shouldRespondWith` [json|
-        [{"a":"xyyx","b":"u"}]|]
-      get "/no_pk?a=like.xy*" `shouldRespondWith` [json|
-        [{"a":"xyyx","b":"u"}]|]
-      get "/no_pk?a=like.*YY*" `shouldRespondWith` [json|
-        [{"a":"xYYx","b":"v"}]|]
+      get "/simple_pk?k=like.*yx" `shouldRespondWith`
+        "[{\"k\":\"xyyx\",\"extra\":\"u\"}]"
+      get "/simple_pk?k=like.xy*" `shouldRespondWith`
+        "[{\"k\":\"xyyx\",\"extra\":\"u\"}]"
+      get "/simple_pk?k=like.*YY*" `shouldRespondWith`
+        "[{\"k\":\"xYYx\",\"extra\":\"v\"}]"

    it "matches with ilike" $ do
-      get "/no_pk?a=ilike.xy*&order=b.asc" `shouldRespondWith` [json|
-        [{"a":"xyyx","b":"u"},{"a":"xYYx","b":"v"}]|]
-      get "/no_pk?a=ilike.*YY*&order=b.asc" `shouldRespondWith` [json|
-        [{"a":"xyyx","b":"u"},{"a":"xYYx","b":"v"}]|]
+      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 tsearch @@" $
+      get "/tsearch?text_search_vector=@@.foo" `shouldRespondWith`
+        "[{\"text_search_vector\":\"'bar':2 'foo':1\"}]"

  describe "ordering response" $ do
    it "by a column asc" $
@@ -76,6 +76,36 @@ spec = beforeAll testSet . afterAll_ (clearTable "items") . around withApp $ do
        , matchHeaders = ["Content-Range" <:> "0-1/2"]
        }

+    it "by a column asc with nulls last" $
+      get "/no_pk?order=a.asc.nullslast"
+        `shouldRespondWith` ResponseMatcher {
+          matchBody = Just [json| [{"a":"1","b":"0"},
+                              {"a":"2","b":"0"},
+                              {"a":null,"b":null}] |]
+        , matchStatus = 200
+        , matchHeaders = ["Content-Range" <:> "0-2/3"]
+        }
+
+    it "by a column desc with nulls first" $
+      get "/no_pk?order=a.desc.nullsfirst"
+        `shouldRespondWith` ResponseMatcher {
+          matchBody = Just [json| [{"a":null,"b":null},
+                              {"a":"2","b":"0"},
+                              {"a":"1","b":"0"}] |]
+        , matchStatus = 200
+        , matchHeaders = ["Content-Range" <:> "0-2/3"]
+        }
+
+    it "by a column desc with nulls last" $
+      get "/no_pk?order=a.desc.nullslast"
+        `shouldRespondWith` ResponseMatcher {
+          matchBody = Just [json| [{"a":"2","b":"0"},
+                              {"a":"1","b":"0"},
+                              {"a":null,"b":null}] |]
+        , matchStatus = 200
+        , matchHeaders = ["Content-Range" <:> "0-2/3"]
+        }
+
    it "without other constraints" $
      get "/items?order=asc.id" `shouldRespondWith` 200

@@ -88,10 +118,16 @@ spec = beforeAll testSet . afterAll_ (clearTable "items") . around withApp $ do
        , matchHeaders = ["Content-Location" <:> "/no_pk?a=eq.1&b=eq.1"]
        }

-    it "Omits question mark when there are no params" $
-      get "/simple_pk"
-        `shouldRespondWith` ResponseMatcher {
-          matchBody    = Just "[]"
-        , matchStatus  = 200
-        , matchHeaders = ["Content-Location" <:> "/simple_pk"]
-        }
+    it "Omits question mark when there are no params" $ do
+      r <- get "/simple_pk"
+      liftIO $ do
+        let respHeaders = simpleHeaders r
+        respHeaders `shouldSatisfy` matchHeader
+          "Content-Location" "/simple_pk"
+
+  describe "jsonb" $
+    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| [] |]
@@ -18,15 +18,17 @@ spec = around withApp $ do
        , {"schema":"1","name":"compound_pk","insertable":true}
        , {"schema":"1","name":"has_fk","insertable":true}
        , {"schema":"1","name":"items","insertable":true}
+        , {"schema":"1","name":"json","insertable":true}
        , {"schema":"1","name":"menagerie","insertable":true}
        , {"schema":"1","name":"no_pk","insertable":true}
        , {"schema":"1","name":"simple_pk","insertable":true}
+        , {"schema":"1","name":"tsearch","insertable":true}
        ] |]
        {matchStatus = 200}

    it "lists only views user has permission to see" $ do
      _ <- post "/postgrest/users" [json| { "id":"jdoe", "pass": "1234", "role": "postgrest_test_author" } |]
-      let auth = authHeader "jdoe" "1234"
+      let auth = authHeaderBasic "jdoe" "1234"

      request methodGet "/" [auth] ""
        `shouldRespondWith` [json| [
@@ -5,8 +5,8 @@ import Test.Hspec
 import Test.Hspec.Wai

 import Hasql as H
-import Hasql.Backend as H
-import Hasql.Postgres as H
+import Hasql.Backend as B
+import Hasql.Postgres as P

 import Data.String.Conversions (cs)
 import Data.Monoid
@@ -24,24 +24,25 @@ import qualified Data.ByteString.Char8 as BS
 import Network.Wai.Middleware.Cors (cors)
 import System.Process (readProcess)

-import App (app)
-import Config (AppConfig(..), corsPolicy)
-import Middleware
-import Error(errResponse)
-- import Auth (addUser)
+import qualified Data.Aeson.Types as J
+
+import PostgREST.App (app)
+import PostgREST.Config (AppConfig(..), corsPolicy)
+import PostgREST.Middleware
+import PostgREST.Error(errResponse)

 isLeft :: Either a b -> Bool
 isLeft (Left _ ) = True
 isLeft _ = False

 cfg :: AppConfig
-cfg = AppConfig "postgrest_test" 5432 "postgrest_test" "" "localhost" 3000 "postgrest_anonymous" False 10 "1"
+cfg = AppConfig "postgrest_test" 5432 "postgrest_test" "" "localhost" 3000 "postgrest_anonymous" False 10 "1" "safe"

 testPoolOpts :: PoolSettings
 testPoolOpts = fromMaybe (error "bad settings") $ H.poolSettings 1 30

-pgSettings :: H.Settings
-pgSettings = H.ParamSettings (cs $ configDbHost cfg)
+pgSettings :: P.Settings
+pgSettings = P.ParamSettings (cs $ configDbHost cfg)
                             (fromIntegral $ configDbPort cfg)
                             (cs $ configDbUser cfg)
                             (cs $ configDbPass cfg)
@@ -49,15 +50,13 @@ pgSettings = H.ParamSettings (cs $ configDbHost cfg)

 withApp :: ActionWith Application -> IO ()
 withApp perform = do
-  let anonRole = cs $ configAnonRole cfg
-      currRole = cs $ configDbUser cfg
-  pool :: H.Pool H.Postgres
+  pool :: H.Pool P.Postgres
    <- H.acquirePool pgSettings testPoolOpts

  perform $ middle $ \req resp -> do
    body <- strictRequestBody req
    result <- liftIO $ H.session pool $ H.tx Nothing
-      $ authenticated currRole anonRole (app (cs $ configV1Schema cfg) body) req
+      $ authenticated cfg (app cfg body) req
    either (resp . errResponse) resp result

  where middle = cors corsPolicy
@@ -65,7 +64,7 @@ withApp perform = do

 resetDb :: IO ()
 resetDb = do
-  pool :: H.Pool H.Postgres
+  pool :: H.Pool P.Postgres
    <- H.acquirePool pgSettings testPoolOpts
  void . liftIO $ H.session pool $
    H.tx Nothing $ do
@@ -92,30 +91,56 @@ matchHeader :: CI BS.ByteString -> String -> [Header] -> Bool
 matchHeader name valRegex headers =
  maybe False (=~ valRegex) $ lookup name headers

-authHeader :: String -> String -> Header
-authHeader u p =
+authHeaderBasic :: String -> String -> Header
+authHeaderBasic u p =
  (hAuthorization, cs $ "Basic " ++ encode (u ++ ":" ++ p))
+  
+authHeaderJWT :: String -> Header
+authHeaderJWT token =
+  (hAuthorization, cs $ "Bearer " ++ token)
+
+testPool :: IO(H.Pool P.Postgres)
+testPool = H.acquirePool pgSettings testPoolOpts

 clearTable :: Text -> IO ()
 clearTable table = do
-  pool :: H.Pool H.Postgres
-    <- H.acquirePool pgSettings testPoolOpts
+  pool <- testPool
  void . liftIO $ H.session pool $ H.tx Nothing $
-    H.unitEx $ H.Stmt ("delete from \"1\"."<>table) V.empty True
+    H.unitEx $ B.Stmt ("delete from \"1\"."<>table) V.empty True

 createItems :: Int -> IO ()
 createItems n = do
-  pool :: H.Pool H.Postgres
-    <- H.acquirePool pgSettings testPoolOpts
+  pool <- testPool
  void . liftIO $ H.session pool $ H.tx Nothing txn
  where
-    txn = sequence_ $ map H.unitEx stmts
+    txn = mapM_ H.unitEx stmts
    stmts = map [H.stmt|insert into "1".items (id) values (?)|] [1..n]

-- for hspec-wai
-pending_ :: WaiSession ()
-pending_ = liftIO Test.Hspec.pending
+createNulls :: Int -> IO ()
+createNulls n = do
+  pool <- testPool
+  void . liftIO $ H.session pool $ H.tx Nothing txn
+  where
+    txn = mapM_ H.unitEx (stmt':stmts)
+    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]

-- for hspec-wai
-pendingWith_ :: String -> WaiSession ()
-pendingWith_ = liftIO . Test.Hspec.pendingWith
+createLikableStrings :: IO ()
+createLikableStrings = do
+  pool <- testPool
+  void . liftIO $ H.session pool $ H.tx Nothing $ do
+    H.unitEx $ insertSimplePk "xyyx" "u"
+    H.unitEx $ insertSimplePk "xYYx" "v"
+  where
+    insertSimplePk :: Text -> Text -> H.Stmt P.Postgres
+    insertSimplePk = [H.stmt|insert into "1".simple_pk (k, extra) values (?,?)|]
+
+createJsonData :: IO ()
+createJsonData = do
+  pool <- testPool
+  void . liftIO $ H.session pool $ H.tx Nothing $
+    H.unitEx $
+      [H.stmt|
+        insert into "1".json (data) values (?)
+      |]
+      (J.object [("foo", J.object [("bar", J.String "baz")])])
@@ -8,9 +8,11 @@ module TestTypes (
 import qualified Data.Aeson as JSON
 import Data.Aeson ((.:))
 -- import Data.Maybe (fromJust)
-import Control.Applicative ((<$>), (<*>))
+import Control.Applicative
 import Control.Monad (mzero)

+import Prelude
+
 data IncPK = IncPK {
  incId :: Int
 , incNullableStr :: Maybe String
@@ -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
@@ -1,70 +1,37 @@
--
-- PostgreSQL database dump
--
-
-- Dumped from database version 9.3.5
-- Dumped by pg_dump version 9.3.5
-- Started on 2014-10-21 15:12:44 PDT
-
 SET statement_timeout = 0;
 SET client_encoding = 'UTF8';
 SET standard_conforming_strings = on;
 SET check_function_bodies = false;
 SET client_min_messages = warning;

--
-- TOC entry 20 (class 2615 OID 337536)
-- Name: 1; Type: SCHEMA; Schema: -; Owner: postgrest_test
--

 CREATE SCHEMA "1";


 ALTER SCHEMA "1" OWNER TO postgrest_test;

--
-- TOC entry 19 (class 2615 OID 337537)
-- Name: postgrest; Type: SCHEMA; Schema: -; Owner: postgrest_test
--

 CREATE SCHEMA postgrest;


 ALTER SCHEMA postgrest OWNER TO postgrest_test;

--
-- TOC entry 16 (class 2615 OID 337538)
-- Name: private; Type: SCHEMA; Schema: -; Owner: postgrest_test
--

 CREATE SCHEMA private;


 ALTER SCHEMA private OWNER TO postgrest_test;

--
-- TOC entry 205 (class 3079 OID 12018)
-- Name: plpgsql; Type: EXTENSION; Schema: -; Owner: 
--

 CREATE EXTENSION IF NOT EXISTS plpgsql WITH SCHEMA pg_catalog;


--
-- TOC entry 2321 (class 0 OID 0)
-- Dependencies: 205
-- Name: EXTENSION plpgsql; Type: COMMENT; Schema: -; Owner: 
--

 COMMENT ON EXTENSION plpgsql IS 'PL/pgSQL procedural language';


 SET search_path = "1", pg_catalog;

--
-- TOC entry 553 (class 1247 OID 337540)
-- Name: enum_menagerie_type; Type: TYPE; Schema: 1; Owner: postgrest_test
--

 CREATE TYPE enum_menagerie_type AS ENUM (
    'foo',
@@ -76,10 +43,6 @@ ALTER TYPE "1".enum_menagerie_type OWNER TO postgrest_test;

 SET search_path = postgrest, pg_catalog;

--
-- TOC entry 218 (class 1255 OID 337545)
-- Name: check_role_exists(); Type: FUNCTION; Schema: postgrest; Owner: postgrest_test
--

 CREATE FUNCTION check_role_exists() RETURNS trigger
    LANGUAGE plpgsql
@@ -96,10 +59,6 @@ $$;

 ALTER FUNCTION postgrest.check_role_exists() OWNER TO postgrest_test;

--
-- TOC entry 219 (class 1255 OID 337546)
-- Name: update_owner(); Type: FUNCTION; Schema: postgrest; Owner: postgrest_test
--

 CREATE FUNCTION update_owner() RETURNS trigger
    LANGUAGE plpgsql
@@ -113,28 +72,33 @@ $$;

 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;
+
 SET search_path = "1", pg_catalog;

 SET default_tablespace = '';

 SET default_with_oids = false;

--
-- TOC entry 191 (class 1259 OID 337547)
-- Name: authors_only; Type: TABLE; Schema: 1; Owner: postgrest_test_author; Tablespace: 
--

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


 ALTER TABLE "1".authors_only OWNER TO postgrest_test_author;

--
-- TOC entry 192 (class 1259 OID 337553)
-- Name: auto_incrementing_pk; Type: TABLE; Schema: 1; Owner: postgrest_test; Tablespace: 
--

 CREATE TABLE auto_incrementing_pk (
    id integer NOT NULL,
@@ -146,10 +110,6 @@ CREATE TABLE auto_incrementing_pk (

 ALTER TABLE "1".auto_incrementing_pk OWNER TO postgrest_test;

--
-- TOC entry 193 (class 1259 OID 337560)
-- Name: auto_incrementing_pk_id_seq; Type: SEQUENCE; Schema: 1; Owner: postgrest_test
--

 CREATE SEQUENCE auto_incrementing_pk_id_seq
    START WITH 1
@@ -161,19 +121,10 @@ CREATE SEQUENCE auto_incrementing_pk_id_seq

 ALTER TABLE "1".auto_incrementing_pk_id_seq OWNER TO postgrest_test;

--
-- TOC entry 2324 (class 0 OID 0)
-- Dependencies: 193
-- Name: auto_incrementing_pk_id_seq; Type: SEQUENCE OWNED BY; Schema: 1; Owner: postgrest_test
--

 ALTER SEQUENCE auto_incrementing_pk_id_seq OWNED BY auto_incrementing_pk.id;


--
-- TOC entry 194 (class 1259 OID 337562)
-- Name: compound_pk; Type: TABLE; Schema: 1; Owner: postgrest_test; Tablespace: 
--

 CREATE TABLE compound_pk (
    k1 integer NOT NULL,
@@ -184,10 +135,6 @@ CREATE TABLE compound_pk (

 ALTER TABLE "1".compound_pk OWNER TO postgrest_test;

--
-- TOC entry 195 (class 1259 OID 337565)
-- Name: has_fk; Type: TABLE; Schema: 1; Owner: postgrest_test; Tablespace: 
--

 CREATE TABLE has_fk (
    id bigint NOT NULL,
@@ -198,10 +145,6 @@ CREATE TABLE has_fk (

 ALTER TABLE "1".has_fk OWNER TO postgrest_test;

--
-- TOC entry 196 (class 1259 OID 337568)
-- Name: has_fk_id_seq; Type: SEQUENCE; Schema: 1; Owner: postgrest_test
--

 CREATE SEQUENCE has_fk_id_seq
    START WITH 1
@@ -213,19 +156,10 @@ CREATE SEQUENCE has_fk_id_seq

 ALTER TABLE "1".has_fk_id_seq OWNER TO postgrest_test;

--
-- TOC entry 2327 (class 0 OID 0)
-- Dependencies: 196
-- Name: has_fk_id_seq; Type: SEQUENCE OWNED BY; Schema: 1; Owner: postgrest_test
--

 ALTER SEQUENCE has_fk_id_seq OWNED BY has_fk.id;


--
-- TOC entry 197 (class 1259 OID 337570)
-- Name: items; Type: TABLE; Schema: 1; Owner: postgrest_test; Tablespace: 
--

 CREATE TABLE items (
    id bigint NOT NULL
@@ -234,10 +168,6 @@ CREATE TABLE items (

 ALTER TABLE "1".items OWNER TO postgrest_test;

--
-- TOC entry 198 (class 1259 OID 337573)
-- Name: items_id_seq; Type: SEQUENCE; Schema: 1; Owner: postgrest_test
--

 CREATE SEQUENCE items_id_seq
    START WITH 1
@@ -249,19 +179,10 @@ CREATE SEQUENCE items_id_seq

 ALTER TABLE "1".items_id_seq OWNER TO postgrest_test;

--
-- TOC entry 2329 (class 0 OID 0)
-- Dependencies: 198
-- Name: items_id_seq; Type: SEQUENCE OWNED BY; Schema: 1; Owner: postgrest_test
--

 ALTER SEQUENCE items_id_seq OWNED BY items.id;


--
-- TOC entry 199 (class 1259 OID 337575)
-- Name: menagerie; Type: TABLE; Schema: 1; Owner: postgrest_test; Tablespace: 
--

 CREATE TABLE menagerie (
    "integer" integer NOT NULL,
@@ -276,10 +197,6 @@ CREATE TABLE menagerie (

 ALTER TABLE "1".menagerie OWNER TO postgrest_test;

--
-- TOC entry 200 (class 1259 OID 337581)
-- Name: no_pk; Type: TABLE; Schema: 1; Owner: postgrest_test; Tablespace: 
--

 CREATE TABLE no_pk (
    a character varying,
@@ -289,10 +206,6 @@ CREATE TABLE no_pk (

 ALTER TABLE "1".no_pk OWNER TO postgrest_test;

--
-- TOC entry 201 (class 1259 OID 337587)
-- Name: simple_pk; Type: TABLE; Schema: 1; Owner: postgrest_test; Tablespace: 
--

 CREATE TABLE simple_pk (
    k character varying NOT NULL,
@@ -302,12 +215,24 @@ CREATE TABLE simple_pk (

 ALTER TABLE "1".simple_pk OWNER TO postgrest_test;

+
+CREATE TABLE json
+(
+  data 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;

--
-- TOC entry 202 (class 1259 OID 337593)
-- Name: auth; Type: TABLE; Schema: postgrest; Owner: postgrest_test; Tablespace: 
--

 CREATE TABLE auth (
    id character varying NOT NULL,
@@ -320,10 +245,6 @@ ALTER TABLE postgrest.auth OWNER TO postgrest_test;

 SET search_path = private, pg_catalog;

--
-- TOC entry 203 (class 1259 OID 337599)
-- Name: articles; Type: TABLE; Schema: private; Owner: postgrest_test; Tablespace: 
--

 CREATE TABLE articles (
    body text,
@@ -334,10 +255,6 @@ CREATE TABLE articles (

 ALTER TABLE private.articles OWNER TO postgrest_test;

--
-- TOC entry 204 (class 1259 OID 337605)
-- Name: articles_id_seq; Type: SEQUENCE; Schema: private; Owner: postgrest_test
--

 CREATE SEQUENCE articles_id_seq
    START WITH 1
@@ -349,232 +266,108 @@ CREATE SEQUENCE articles_id_seq

 ALTER TABLE private.articles_id_seq OWNER TO postgrest_test;

--
-- TOC entry 2336 (class 0 OID 0)
-- Dependencies: 204
-- Name: articles_id_seq; Type: SEQUENCE OWNED BY; Schema: private; Owner: postgrest_test
--

 ALTER SEQUENCE articles_id_seq OWNED BY articles.id;


 SET search_path = "1", pg_catalog;

--
-- TOC entry 2165 (class 2604 OID 337607)
-- Name: id; Type: DEFAULT; Schema: 1; Owner: postgrest_test
--

 ALTER TABLE ONLY auto_incrementing_pk ALTER COLUMN id SET DEFAULT nextval('auto_incrementing_pk_id_seq'::regclass);


--
-- TOC entry 2166 (class 2604 OID 337608)
-- Name: id; Type: DEFAULT; Schema: 1; Owner: postgrest_test
--

 ALTER TABLE ONLY has_fk ALTER COLUMN id SET DEFAULT nextval('has_fk_id_seq'::regclass);


--
-- TOC entry 2167 (class 2604 OID 337609)
-- Name: id; Type: DEFAULT; Schema: 1; Owner: postgrest_test
--

 ALTER TABLE ONLY items ALTER COLUMN id SET DEFAULT nextval('items_id_seq'::regclass);


 SET search_path = private, pg_catalog;

--
-- TOC entry 2168 (class 2604 OID 337610)
-- Name: id; Type: DEFAULT; Schema: private; Owner: postgrest_test
--

 ALTER TABLE ONLY articles ALTER COLUMN id SET DEFAULT nextval('articles_id_seq'::regclass);


 SET search_path = "1", pg_catalog;

--
-- TOC entry 2298 (class 0 OID 337547)
-- Dependencies: 191
-- Data for Name: authors_only; Type: TABLE DATA; Schema: 1; Owner: postgrest_test_author
--



--
-- TOC entry 2299 (class 0 OID 337553)
-- Dependencies: 192
-- Data for Name: auto_incrementing_pk; Type: TABLE DATA; Schema: 1; Owner: postgrest_test
--



--
-- TOC entry 2337 (class 0 OID 0)
-- Dependencies: 193
-- Name: auto_incrementing_pk_id_seq; Type: SEQUENCE SET; Schema: 1; Owner: postgrest_test
--

-SELECT pg_catalog.setval('auto_incrementing_pk_id_seq', 54, true);
+SELECT pg_catalog.setval('auto_incrementing_pk_id_seq', 1, true);


--
-- TOC entry 2301 (class 0 OID 337562)
-- Dependencies: 194
-- Data for Name: compound_pk; Type: TABLE DATA; Schema: 1; Owner: postgrest_test
--



--
-- TOC entry 2302 (class 0 OID 337565)
-- Dependencies: 195
-- Data for Name: has_fk; Type: TABLE DATA; Schema: 1; Owner: postgrest_test
--



--
-- TOC entry 2338 (class 0 OID 0)
-- Dependencies: 196
-- Name: has_fk_id_seq; Type: SEQUENCE SET; Schema: 1; Owner: postgrest_test
--

 SELECT pg_catalog.setval('has_fk_id_seq', 1, false);


--
-- TOC entry 2304 (class 0 OID 337570)
-- Dependencies: 197
-- Data for Name: items; Type: TABLE DATA; Schema: 1; Owner: postgrest_test
--

 INSERT INTO items (id) VALUES (1);
--
-- TOC entry 2339 (class 0 OID 0)
-- Dependencies: 198
-- Name: items_id_seq; Type: SEQUENCE SET; Schema: 1; Owner: postgrest_test
--

-SELECT pg_catalog.setval('items_id_seq', 19, true);
-
-
--
-- TOC entry 2306 (class 0 OID 337575)
-- Dependencies: 199
-- Data for Name: menagerie; Type: TABLE DATA; Schema: 1; Owner: postgrest_test
--
-
-
-
--
-- TOC entry 2307 (class 0 OID 337581)
-- Dependencies: 200
-- Data for Name: no_pk; Type: TABLE DATA; Schema: 1; Owner: postgrest_test
--
-
-
-
--
-- TOC entry 2308 (class 0 OID 337587)
-- Dependencies: 201
-- Data for Name: simple_pk; Type: TABLE DATA; Schema: 1; Owner: postgrest_test
--
+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;

--
-- TOC entry 2309 (class 0 OID 337593)
-- Dependencies: 202
-- Data for Name: auth; Type: TABLE DATA; Schema: postgrest; Owner: postgrest_test
--



 SET search_path = private, pg_catalog;

--
-- TOC entry 2310 (class 0 OID 337599)
-- Dependencies: 203
-- Data for Name: articles; Type: TABLE DATA; Schema: private; Owner: postgrest_test
--



--
-- TOC entry 2340 (class 0 OID 0)
-- Dependencies: 204
-- Name: articles_id_seq; Type: SEQUENCE SET; Schema: private; Owner: postgrest_test
--

 SELECT pg_catalog.setval('articles_id_seq', 1, false);


 SET search_path = "1", pg_catalog;

--
-- TOC entry 2170 (class 2606 OID 337612)
-- Name: authors_only_pkey; Type: CONSTRAINT; Schema: 1; Owner: postgrest_test_author; Tablespace: 
--

 ALTER TABLE ONLY authors_only
    ADD CONSTRAINT authors_only_pkey PRIMARY KEY (secret);
+    
+CREATE TRIGGER secrets_owner_track BEFORE INSERT OR UPDATE ON authors_only FOR EACH ROW EXECUTE PROCEDURE postgrest.set_authors_only_owner();


--
-- TOC entry 2172 (class 2606 OID 337614)
-- Name: auto_incrementing_pk_pkey; Type: CONSTRAINT; Schema: 1; Owner: postgrest_test; Tablespace: 
--
-
 ALTER TABLE ONLY auto_incrementing_pk
    ADD CONSTRAINT auto_incrementing_pk_pkey PRIMARY KEY (id);


--
-- TOC entry 2174 (class 2606 OID 337616)
-- Name: compound_pk_pkey; Type: CONSTRAINT; Schema: 1; Owner: postgrest_test; Tablespace: 
--

 ALTER TABLE ONLY compound_pk
    ADD CONSTRAINT compound_pk_pkey PRIMARY KEY (k1, k2);


--
-- TOC entry 2182 (class 2606 OID 337618)
-- Name: contacts_pkey; Type: CONSTRAINT; Schema: 1; Owner: postgrest_test; Tablespace: 
--

 ALTER TABLE ONLY simple_pk
    ADD CONSTRAINT contacts_pkey PRIMARY KEY (k);


--
-- TOC entry 2176 (class 2606 OID 337620)
-- Name: has_fk_pkey; Type: CONSTRAINT; Schema: 1; Owner: postgrest_test; Tablespace: 
--

 ALTER TABLE ONLY has_fk
    ADD CONSTRAINT has_fk_pkey PRIMARY KEY (id);


--
-- TOC entry 2178 (class 2606 OID 337622)
-- Name: items_pkey; Type: CONSTRAINT; Schema: 1; Owner: postgrest_test; Tablespace: 
--

 ALTER TABLE ONLY items
    ADD CONSTRAINT items_pkey PRIMARY KEY (id);


--
-- TOC entry 2180 (class 2606 OID 337624)
-- Name: menagerie_pkey; Type: CONSTRAINT; Schema: 1; Owner: postgrest_test; Tablespace: 
--

 ALTER TABLE ONLY menagerie
    ADD CONSTRAINT menagerie_pkey PRIMARY KEY ("integer");
@@ -582,10 +375,6 @@ ALTER TABLE ONLY menagerie

 SET search_path = postgrest, pg_catalog;

--
-- TOC entry 2184 (class 2606 OID 337626)
-- Name: auth_pkey; Type: CONSTRAINT; Schema: postgrest; Owner: postgrest_test; Tablespace: 
--

 ALTER TABLE ONLY auth
    ADD CONSTRAINT auth_pkey PRIMARY KEY (id);
@@ -593,10 +382,6 @@ ALTER TABLE ONLY auth

 SET search_path = private, pg_catalog;

--
-- TOC entry 2186 (class 2606 OID 337628)
-- Name: articles_pkey; Type: CONSTRAINT; Schema: private; Owner: postgrest_test; Tablespace: 
--

 ALTER TABLE ONLY articles
    ADD CONSTRAINT articles_pkey PRIMARY KEY (id);
@@ -604,49 +389,28 @@ ALTER TABLE ONLY articles

 SET search_path = postgrest, pg_catalog;

--
-- TOC entry 2189 (class 2620 OID 337630)
-- Name: ensure_auth_role_exists; Type: TRIGGER; Schema: postgrest; Owner: postgrest_test
--

 CREATE CONSTRAINT TRIGGER ensure_auth_role_exists AFTER INSERT OR UPDATE ON auth NOT DEFERRABLE INITIALLY IMMEDIATE FOR EACH ROW EXECUTE PROCEDURE check_role_exists();


 SET search_path = private, pg_catalog;

--
-- TOC entry 2190 (class 2620 OID 337631)
-- Name: articles_owner_track; Type: TRIGGER; Schema: private; Owner: postgrest_test
--

 CREATE TRIGGER articles_owner_track BEFORE INSERT OR UPDATE ON articles FOR EACH ROW EXECUTE PROCEDURE postgrest.update_owner();


 SET search_path = "1", pg_catalog;

--
-- TOC entry 2187 (class 2606 OID 337632)
-- Name: has_fk_fk_fkey; Type: FK CONSTRAINT; Schema: 1; Owner: postgrest_test
--

 ALTER TABLE ONLY has_fk
    ADD CONSTRAINT has_fk_fk_fkey FOREIGN KEY (auto_inc_fk) REFERENCES auto_incrementing_pk(id);


--
-- TOC entry 2188 (class 2606 OID 337637)
-- Name: has_fk_simple_fk_fkey; Type: FK CONSTRAINT; Schema: 1; Owner: postgrest_test
--

 ALTER TABLE ONLY has_fk
    ADD CONSTRAINT has_fk_simple_fk_fkey FOREIGN KEY (simple_fk) REFERENCES simple_pk(k);


--
-- TOC entry 2317 (class 0 OID 0)
-- Dependencies: 20
-- Name: 1; Type: ACL; Schema: -; Owner: postgrest_test
--

 REVOKE ALL ON SCHEMA "1" FROM PUBLIC;
 REVOKE ALL ON SCHEMA "1" FROM postgrest_test;
@@ -655,11 +419,6 @@ GRANT USAGE ON SCHEMA "1" TO postgrest_anonymous;
 GRANT USAGE ON SCHEMA "1" TO postgrest_test_author;


--
-- TOC entry 2318 (class 0 OID 0)
-- Dependencies: 19
-- Name: postgrest; Type: ACL; Schema: -; Owner: postgrest_test
--

 REVOKE ALL ON SCHEMA postgrest FROM PUBLIC;
 REVOKE ALL ON SCHEMA postgrest FROM postgrest_test;
@@ -667,33 +426,17 @@ GRANT ALL ON SCHEMA postgrest TO postgrest_test;
 GRANT USAGE ON SCHEMA postgrest TO postgrest_anonymous;


--
-- TOC entry 2320 (class 0 OID 0)
-- Dependencies: 21
-- Name: public; Type: ACL; Schema: -; Owner: postgres
--

 REVOKE ALL ON SCHEMA public FROM PUBLIC;
-GRANT ALL ON SCHEMA public TO postgres;
 GRANT ALL ON SCHEMA public TO PUBLIC;


--
-- TOC entry 2322 (class 0 OID 0)
-- Dependencies: 191
-- Name: authors_only; Type: ACL; Schema: 1; Owner: postgrest_test_author
--

 REVOKE ALL ON TABLE authors_only FROM PUBLIC;
 REVOKE ALL ON TABLE authors_only FROM postgrest_test_author;
 GRANT ALL ON TABLE authors_only TO postgrest_test_author;


--
-- TOC entry 2323 (class 0 OID 0)
-- Dependencies: 192
-- Name: auto_incrementing_pk; Type: ACL; Schema: 1; Owner: postgrest_test
--

 REVOKE ALL ON TABLE auto_incrementing_pk FROM PUBLIC;
 REVOKE ALL ON TABLE auto_incrementing_pk FROM postgrest_test;
@@ -701,11 +444,6 @@ GRANT ALL ON TABLE auto_incrementing_pk TO postgrest_test;
 GRANT ALL ON TABLE auto_incrementing_pk TO postgrest_anonymous;


--
-- TOC entry 2325 (class 0 OID 0)
-- Dependencies: 193
-- Name: auto_incrementing_pk_id_seq; Type: ACL; Schema: 1; Owner: postgrest_test
--

 REVOKE ALL ON SEQUENCE auto_incrementing_pk_id_seq FROM PUBLIC;
 REVOKE ALL ON SEQUENCE auto_incrementing_pk_id_seq FROM postgrest_test;
@@ -713,11 +451,6 @@ GRANT ALL ON SEQUENCE auto_incrementing_pk_id_seq TO postgrest_test;
 GRANT USAGE ON SEQUENCE auto_incrementing_pk_id_seq TO postgrest_anonymous;


--
-- TOC entry 2326 (class 0 OID 0)
-- Dependencies: 194
-- Name: compound_pk; Type: ACL; Schema: 1; Owner: postgrest_test
--

 REVOKE ALL ON TABLE compound_pk FROM PUBLIC;
 REVOKE ALL ON TABLE compound_pk FROM postgrest_test;
@@ -730,11 +463,6 @@ REVOKE ALL ON TABLE has_fk FROM postgrest_test;
 GRANT ALL ON TABLE has_fk TO postgrest_test;
 GRANT ALL ON TABLE has_fk TO postgrest_anonymous;

--
-- TOC entry 2328 (class 0 OID 0)
-- Dependencies: 197
-- Name: items; Type: ACL; Schema: 1; Owner: postgrest_test
--

 REVOKE ALL ON TABLE items FROM PUBLIC;
 REVOKE ALL ON TABLE items FROM postgrest_test;
@@ -742,11 +470,6 @@ GRANT ALL ON TABLE items TO postgrest_test;
 GRANT ALL ON TABLE items TO postgrest_anonymous;


--
-- TOC entry 2330 (class 0 OID 0)
-- Dependencies: 198
-- Name: items_id_seq; Type: ACL; Schema: 1; Owner: postgrest_test
--

 REVOKE ALL ON SEQUENCE items_id_seq FROM PUBLIC;
 REVOKE ALL ON SEQUENCE items_id_seq FROM postgrest_test;
@@ -754,11 +477,6 @@ GRANT ALL ON SEQUENCE items_id_seq TO postgrest_test;
 GRANT USAGE ON SEQUENCE items_id_seq TO postgrest_anonymous;


--
-- TOC entry 2331 (class 0 OID 0)
-- Dependencies: 199
-- Name: menagerie; Type: ACL; Schema: 1; Owner: postgrest_test
--

 REVOKE ALL ON TABLE menagerie FROM PUBLIC;
 REVOKE ALL ON TABLE menagerie FROM postgrest_test;
@@ -766,11 +484,6 @@ GRANT ALL ON TABLE menagerie TO postgrest_test;
 GRANT ALL ON TABLE menagerie TO postgrest_anonymous;


--
-- TOC entry 2332 (class 0 OID 0)
-- Dependencies: 200
-- Name: no_pk; Type: ACL; Schema: 1; Owner: postgrest_test
--

 REVOKE ALL ON TABLE no_pk FROM PUBLIC;
 REVOKE ALL ON TABLE no_pk FROM postgrest_test;
@@ -778,11 +491,6 @@ GRANT ALL ON TABLE no_pk TO postgrest_test;
 GRANT ALL ON TABLE no_pk TO postgrest_anonymous;


--
-- TOC entry 2333 (class 0 OID 0)
-- Dependencies: 201
-- Name: simple_pk; Type: ACL; Schema: 1; Owner: postgrest_test
--

 REVOKE ALL ON TABLE simple_pk FROM PUBLIC;
 REVOKE ALL ON TABLE simple_pk FROM postgrest_test;
@@ -790,13 +498,22 @@ GRANT ALL ON TABLE simple_pk TO postgrest_test;
 GRANT ALL ON TABLE simple_pk TO postgrest_anonymous;


+
+REVOKE ALL ON TABLE json FROM PUBLIC;
+REVOKE ALL ON TABLE json FROM postgrest_test;
+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;
+
+
 SET search_path = postgrest, pg_catalog;

--
-- TOC entry 2334 (class 0 OID 0)
-- Dependencies: 202
-- Name: auth; Type: ACL; Schema: postgrest; Owner: postgrest_test
--

 REVOKE ALL ON TABLE auth FROM PUBLIC;
 REVOKE ALL ON TABLE auth FROM postgrest_test;
@@ -806,20 +523,7 @@ GRANT INSERT ON TABLE auth TO postgrest_anonymous;

 SET search_path = private, pg_catalog;

--
-- TOC entry 2335 (class 0 OID 0)
-- Dependencies: 203
-- Name: articles; Type: ACL; Schema: private; Owner: postgrest_test
--

 REVOKE ALL ON TABLE articles FROM PUBLIC;
 REVOKE ALL ON TABLE articles FROM postgrest_test;
 GRANT ALL ON TABLE articles TO postgrest_test;
-
-
-- Completed on 2014-10-21 15:12:44 PDT
-
--
-- PostgreSQL database dump complete
--
-
Author	SHA1	Message	Date
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
Joe Nelson	b070994912	Patch version bump for conditional -Werror flag	2015-05-21 00:18:26 -07:00
Joe Nelson	988df54e53	Use Werror on CI	2015-05-21 00:18:03 -07:00
Joe Nelson	4bbf053896	Bump version	2015-05-20 09:42:51 -07:00
Joe Nelson	da79f1da3e	Merge pull request #193 from srid/makelibrary Make postgrest a library	2015-05-19 23:59:16 -07:00
Sridhar Ratnakumar	c3ad87ffaf	Make postgrest usable as a library	2015-05-19 23:40:39 -07:00
Joe Nelson	035acebf59	Update CHANGELOG.md	2015-05-19 22:23:49 -07:00
Joe Nelson	0b665676d7	Update CHANGELOG.md	2015-05-19 22:21:28 -07:00
Joe Nelson	dcf62b020f	Merge pull request #194 from framp/jwt JWT support	2015-05-19 22:17:34 -07:00
Federico Rampazzo	77aecc9e86	JWT support	2015-05-20 06:01:50 +01:00
Joe Nelson	e35ad0f340	Update changelog, remove debugging	2015-05-12 10:55:51 -07:00
Joe Nelson	709e70561f	Provide more information in PATCH response * 404 if no records updated * Range header for number updated * Full results depending on Prefer header Fixes #187 Fixes #182	2015-05-12 10:47:55 -07:00
Joe Nelson	ef0dc26de5	Merge pull request #186 from jcristovao/patch-2 GHC 7.10.1 support	2015-04-24 09:37:27 -07:00
João Cristóvão	35d36d95c1	GHC 7.10.1 support Without it, the following error occurs: ``` src/PgStructure.hs:88:5: Non type-variable argument in the constraint: Data.String.Conversions.ConvertibleStrings Text k (Use FlexibleContexts to permit this) When checking that ‘addFK’ has the inferred type addFK :: forall k. (Ord k, Data.String.Conversions.ConvertibleStrings Text k) => Map.Map k ForeignKey -> Column -> Column In an equation for ‘columns’: columns table = do { cols <- H.listEx $ (\ _1 _2 -> Hasql.Backend.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" (GHC.ST.runST (do { ... })) True) (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} ``` Also, the regex-tdfa-text library needs a similar patch, but I didn't have time to contact the author yet. Cheers	2015-04-24 16:22:43 +01:00
Joe Nelson	13cda09c7e	Contributing	2015-04-22 17:22:39 -07:00
Joe Nelson	5688030104	Allow posting JSON array and object Fixes #168 Fixes #156	2015-04-19 17:46:11 -07:00
Joe Nelson	02228b76cc	Bump version	2015-04-17 16:26:27 -07:00
Joe Nelson	4d7cc3d67e	Merge branch 'bulk-insert'	2015-04-17 15:55:42 -07:00
Joe Nelson	ad8700e996	bulk insert in changelog	2015-04-17 15:52:57 -07:00
Joe Nelson	fbc90bdb84	Tests for csv bulk import Fixes #17	2015-04-17 15:42:58 -07:00
Joe Nelson	f4c49f03f4	Allow NULL in csv field and unquote the multipart headers	2015-04-16 12:43:22 -07:00
Joe Nelson	a87f13f9bb	Fix original tests	2015-04-16 10:45:24 -07:00
Joe Nelson	7d03a71fed	All tests but one are passing	2015-04-12 19:56:33 -07:00
Joe Nelson	70d33445db	WIP: nice but doomed approach to making multipart response	2015-04-12 13:03:16 -07:00
Joe Nelson	4dbcf45555	WIP: typechecking but not yet sending back links Rather amazing how well this actually works given it only type checked	2015-04-11 21:41:32 -07:00
Joe Nelson	87acee924e	WIP: parsing csv	2015-04-05 17:13:16 -07:00
Joe Nelson	a22cf82688	Build sql for inserting multiple rows	2015-04-04 20:20:13 -07:00
Joe Nelson	532cfdff95	Merge pull request #183 from begriffs/jsonb Filter results using properties in a jsonb column	2015-04-04 18:35:40 -07:00
Joe Nelson	5807b41997	Add jsonb to changelog	2015-04-04 18:33:08 -07:00
Joe Nelson	c78d323989	Specify hasql versions exactly to help ci	2015-04-04 17:43:14 -07:00
Joe Nelson	9792b9b46a	Allow filtering by values inside json columns	2015-04-04 17:38:54 -07:00
Joe Nelson	ca1c524ede	WIP: working on querying and ordering with jsonb paths Affects #118	2015-03-30 00:51:52 -07:00
Joe Nelson	a1822a8e08	Update whitespace	2015-03-29 12:32:14 -07:00
Joe Nelson	066cdbc697	Merge pull request #176 from brikou/patch-2 Add link to GUI demo	2015-03-23 18:35:02 -07:00
Brikou CARRE	b9c3902bd8	Add link to GUI demo You can read more about using ng-admin with postgREST here http://marmelab.com/blog/2015/03/23/using-ng-admin-with-postgrest.html	2015-03-23 15:54:34 +01:00
Joe Nelson	03613e2f8e	Add link to tutorial Thanks @prio	2015-03-22 20:27:54 -07:00
Joe Nelson	de7eecb166	Document fix from pull request	2015-03-16 21:11:57 -07:00
Joe Nelson	417d98d7fa	Merge pull request #172 from GaloisInc/master Show long help output with defaults on usage errors	2015-03-16 21:09:57 -07:00
Jonathan Daugherty	6dfbe854a0	Make postgrest show long help output with defaults on usage errors This makes optparse-applicative show the long version of help output. Its default behavior is not to do this since the showHelpOnError setting defaults to False. This turns it on.	2015-03-16 13:27:22 -07:00
Joe Nelson	a9bc119b82	Merge branch 'insert-nulls' Fixes #166	2015-03-15 18:30:47 -07:00
Joe Nelson	42d3d0de6c	Fix location header for inserted objects with nulls	2015-03-15 18:26:32 -07:00
Joe Nelson	ddb5ba8b64	Can now post nulls, but header link is wrong affects #166	2015-03-15 16:30:42 -07:00
Joe Nelson	185d5b1c62	Merge branch 'jcristovao-isnull'	2015-03-15 15:22:28 -07:00
Joe Nelson	f7ff08edf7	Test is.null matcher	2015-03-15 15:20:31 -07:00
João CristóvãoandJoe Nelson	f4e0c12cba	IS/IS NOT null, true, false	2015-03-15 13:37:45 -07:00
Joe Nelson	8ed599a769	Merge branch 'jcristovao-nullsFirst'	2015-03-15 12:30:34 -07:00
Joe Nelson	aeb62e75bd	Add nullsfirst to changelog	2015-03-15 12:30:17 -07:00
Joe Nelson	5c7ee1effc	Fix problems caused by my rebase	2015-03-15 12:24:30 -07:00
João CristóvãoandJoe Nelson	01c67ab793	Added tests for nullsfirst / nullslast	2015-03-15 11:37:06 -07:00
João CristóvãoandJoe Nelson	97c9bfe93f	Added support for nulls first / nulls last	2015-03-15 10:28:21 -07:00