graphile · calebmer · Oct 16, 2016 · Aug 31, 2016 · Aug 31, 2016 · Aug 31, 2016
diff --git a/.babelrc b/.babelrc
diff --git a/.eslintignore b/.eslintignore
diff --git a/.eslintrc b/.eslintrc
diff --git a/.gitignore b/.gitignore
@@ -1,5 +1,5 @@
 .DS_Store
 node_modules
-npm-debug.log
-dist/
+npm-debug.log*
+build/
 TODO.md
diff --git a/.npmignore b/.npmignore
@@ -0,0 +1,16 @@
+.DS_Store
+node_modules
+npm-debug.log*
+TODO.md
+.editorconfig
+tsconfig.json
+tslint.json
+.vscode
+src
+build/**/__tests__
+build/**/__mocks__
+typings
+scripts
+examples
+docs
+resources/jest-*
diff --git a/.travis.yml b/.travis.yml
@@ -2,14 +2,20 @@ language: node_js
 
 node_js:
   - "6"
-  - "5"
 
 addons:
   postgresql: "9.4"
 
 env:
-  TEST_DB: postgres://localhost:5432/travis
+  TEST_PG_URL: postgres://localhost:5432/travis
+
+cache:
+  directories:
+    - node_modules
+    - $NVM_DIR
 
 script:
-  - npm run lint
-  - npm test
+  - scripts/ci
+
+after_success:
+  - "cd examples/forum && scripts/run-schema-demo $DEMO_PG_URL"
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -0,0 +1,4 @@
+{
+  "typescript.tsdk": "./node_modules/typescript/lib",
+  "eslint.enable": false
+}
diff --git a/README.md b/README.md
@@ -22,21 +22,30 @@ First install using npm:
 npm install -g postgraphql
 ```
 
-and then just run it!
+…and then just run it! By default, PostGraphQL will connect to your local database at `postgres://localhost:5432` and introspect the `public` schema.
 
 ```bash
-postgraphql postgres://localhost:5432/mydb --schema forum --development
+postgraphql
 ```
 
-For more information run:
+For information about how to change these defaults, just run:
 
 ```bash
 postgraphql --help
 ```
 
-Check out the **[forum example][]** for a demo of PostGraphQL in action.
+You can also use PostGraphQL as native HTTP, Connect, Express, or Koa middleware. Just import `postgraphql`:
 
-Also check out relevant [documentation links](#documentation).
+```js
+import { createServer } from 'http'
+import postgraphql from 'postgraphql'
+
+createServer(postgraphql())
+```
+
+For more information around using PostGraphQL as a library, and the options the API expects read the [library usage documentation article](https://github.com/calebmer/postgraphql/blob/master/docs/library.md).
+
+Also make sure to check out the **[forum example][]** for a demo of a PostGraphQL compliant schema.
 
 [forum example]: https://github.com/calebmer/postgraphql/tree/master/examples/forum
 
@@ -62,12 +71,14 @@ Can query relations like so:
 
 ```graphql
 {
-  postNodes {
-    nodes {
-      headline
-      body
-      author: userByAuthorId {
-        name
+  allPosts {
+    edges {
+      node {
+        headline
+        body
+        author: userByAuthorId {
+          name
+        }
       }
     }
   }
@@ -98,9 +109,12 @@ And queried through GraphQL like this:
       hasNextPage
     }
     totalCount
-    nodes {
-      headline
-      body
+    edges {
+      cursor
+      node {
+        headline
+        body
+      }
     }
   }
 }
@@ -192,18 +206,11 @@ The specific specs PostGraphQL implements are:
 * * *
 
 ## Documentation
-- [Using PostGraphQL as ExpressJS or Connect middleware.](https://github.com/calebmer/postgraphql/blob/master/docs/library.md)
+- [Using PostGraphQL as Express, Connect, or Koa middleware.](https://github.com/calebmer/postgraphql/blob/master/docs/library.md)
 - [Adding advanced queries to PostGraphQL.](https://github.com/calebmer/postgraphql/blob/master/docs/advanced-queries.md)
 - [Using PostgreSQL functions to extend your PostGraphQL schema.](https://github.com/calebmer/postgraphql/blob/master/docs/procedures.md)
 - [A crash course in PostgreSQL roles for PostGraphQL.](https://github.com/calebmer/postgraphql/blob/master/docs/anonymous-role.md)
 
-## Roadmap
-In the future, things PostGraphQL will be able to do will include:
-
-- Authentication using PostgreSQL roles.
-- Whitelisted queries in production.
-- Subscriptions using the PostgreSQL [`NOTIFY`][pg-notify] feature.
-
 ## Evaluating PostGraphQL For Your Project
 Hopefully you’ve been convinced that PostGraphQL serves an awesome GraphQL API, but now let’s take a more critical look at whether or not you should adopt PostGraphQL for your project.
 

diff --git a/docs/anonymous-role.md b/docs/anonymous-role.md
@@ -6,23 +6,23 @@ You can make any number of PostgreSQL roles with [`CREATE ROLE`](https://www.pos
 PostgreSQL roles are also hierarchical. That is you can “grant” roles to other roles. For example if I had role `editor` which could change the data in our database and role `admin`, if I granted the `editor` role to `admin` with the command:
 
 ```sql
-GRANT editor TO admin;
+grant editor to admin;
 ```
 
 Then the `admin` role would have the same permissions the `editor` role has. The `admin` role would also be able to *change* its role to the `editor` role. This means for the rest of the session you don’t have any `admin` permissions, but only permissions given to the `editor` role.
 
 In PostgreSQL you also have the idea of a user. A user is just a role that can login. So for example, the following are equivalent as the create an `admin` role that can log in (or a user):
 
 ```sql
-CREATE ROLE admin LOGIN;
-CREATE USER admin;
+create role admin login;
+create user admin;
 ```
 
 …and the following are also equivalent as they create a role that *can’t* log in:
 
 ```sql
-CREATE ROLE editor;
-CREATE ROLE editor NOLOGIN;
+create role editor;
+create role editor nologin;
 ```
 
 “Logging in” just means we can use the role when authenticating in the PostgreSQL authentication section of the connection string. So with the above roles you could start a PostgreSQL connection with `postgres://admin@localhost:5432/mydb`, but not `postgres://editor@localhost:5432/mydb`.

diff --git a/docs/library.md b/docs/library.md
@@ -1,7 +1,12 @@
 # Using PostGraphQL as a Library
-Some people may want to use PostGraphQL as a dependency of their current node projects. This is a functionality PostGraphQL intends to support. As long as you are using a server framework that supports [connect][]-styled middleware, you can use PostGraphQL as a dependency.
+Some people may want to use PostGraphQL as 
3D11
a dependency of their current node projects and mount the PostGraphQL instance on their own web server. For this usecase PostGraphQL exports itself as a HTTP middleware for the following HTTP frameworks:
 
-To use PostGraphQL as a library just do the following:
+- [`connect`](http://npmjs.com/connect)
+- [`express`](https://www.npmjs.com/package/express)
+- [`koa` 2.0](https://www.npmjs.com/package/koa)
+- [Vanilla `http`](https://nodejs.org/api/http.html)
+
+To use PostGraphQL with `express` just do the following:
 
 ```js
 import express from 'express'
@@ -23,23 +28,30 @@ import postgraphql from 'postgraphql'
 http.createServer(postgraphql('postgres://localhost:5432')).listen(3000)
 ```
 
-To import the function with CommonJS:
+To import the middleware with CommonJS:
 
 ```js
-var postgraphql = require('postgraphql').default
+var postgraphql = require('postgraphql').postgraphql
 ```
 
-The API for creating handlers is as follows:
+The `postgraphql` function can take the following arguments:
 
-## postgraphql(pgConfig, schemaName? = 'public', options)
+## postgraphql(pgConfig?, schemaName? = 'public', options?)
 Arguments include:
 
 - **`pgConfig`**: An object or string that will be passed to the [`pg`][] library and used to connect to a PostgreSQL backend.
-- **`schemaName`**: A string which specifies the PostgreSQL schema you will be serving with PostGraphQL. The default schema is the `public` schema.
+- **`schemaName`**: A string which specifies the PostgreSQL schema you will be serving with PostGraphQL. The default schema is the `public` schema. May be an array for multiple schemas.
 - **`options`**: An object containing other miscellaneous options. Options could be:
-  - `secret`: The secret for your application. This enables PostGraphQL’s authorization features. Make it something secure and obscure!
-  - `development`: Enables development features like GraphiQL and more descriptive error formatting.
-  - `log`: If true, PostGraphQL will log every request using the dev style of [morgan][].
+  - `classicIds`: Enables classic ids for Relay 1 support. Instead of using the field name `__id` for globally unique ids, PostGraphQL will instead use the field name `id` for its globally unique ids. This means that table `id` columns will also get renamed to `rowId`.
+  - `dynamicJson`: Setting this to `true` enables dynamic JSON which will allow you to use any JSON as input and get any arbitrary JSON as output. By default JSON types are just a JSON string.
+  - `graphiql`: Set this to `true` to enable the GraphiQL interface.
+  - `graphqlRoute`: The endpoint the GraphQL executer will listen on. Defaults to `/graphql`.
+  - `graphiqlRoute`: The endpoint the GraphiQL query interface will listen on (**NOTE:** GraphiQL will not be enabled unless the `graphiql` option is set to `true`). Defaults to `/graphiql`.
+  - `pgDefaultRole`: The default Postgres role to use. If no role was provided in a provided JWT token, this role will be used.
+  - `jwtSecret`: The secret for your JSON web tokens. This will be used to verify tokens in the `Authorization` header, and signing JWT tokens you return in procedures.
+  - `jwtPGTypeIdentifier`: The Postgres type identifier for the compound type which will be signed as a JWT token if ever found as the return type of a procedure. Can be of the form: `my_schema.my_type`. You may use quotes as needed: `"my-special-schema".my_type`.
+  - `disableQueryLog`: Turns off GraphQL query logging. By default PostGraphQL will log every GraphQL query it processes along with some other information. Set this to `true` to disable that feature.
+  - `enableCors`: Enables some generous CORS settings for the GraphQL endpoint. There are some costs associated when enabling this, if at all possible try to put your API behind a reverse proxy.
 
 [connect]: https://www.npmjs.com/connect
 [express]: https://www.npmjs.com/express

diff --git a/docs/naming.md b/docs/naming.md
diff --git a/docs/procedures.md b/docs/procedures.md
@@ -90,13 +90,13 @@ $$ language sql immutable strict;
 By default, a procedure is “volatile” and PostGraphQL will treat it as a mutation. So for example, a procedure defined as:
 
 ```sql
-CREATE FUNCTION my_function(a int, b int) RETURNS int AS $$ … $$ LANGUAGE SQL;
+create function my_function(a int, b int) returns int as $$ … $$ language sql;
 ```
 
 Is equivalent to a procedure defined as:
 
 ```sql
-CREATE FUNCTION my_function(a int, b int) RETURNS int AS $$ … $$ LANGUAGE SQL VOLATILE;
+create function my_function(a int, b int) returns int as $$ … $$ language sql volatile;
 ```
 
 From the PostgreSQL docs:
@@ -123,15 +123,15 @@ Always look at the documentation in GraphiQL to find all the parameters you may
 Similar to how you use `VOLATILE` to specify a mutative procedure, a query procedure can be specified using `IMMUTABLE` or `STABLE` identifiers. For example:
 
 ```sql
-CREATE FUNCTION my_function(a int, b int) RETURNS int AS $$ … $$ LANGUAGE SQL STABLE;
+create function my_function(a int, b int) returns int as $$ … $$ language sql stable;
 
 -- or…
 
-CREATE FUNCTION my_function(a int, b int) RETURNS int AS $$ … $$ LANGUAGE SQL IMMUTABLE;
+create function my_function(a int, b int) returns int as $$ … $$ language sql immutable;
 
 -- or if you wanted to return a row from a table…
 
-CREATE FUNCTION my_function(a int, b int) RETURNS my_table AS $$ … $$ LANGUAGE SQL STABLE;
+create function my_function(a int, b int) returns my_table as $$ … $$ language sql stable;
 ```
 
 From the PostgreSQL docs:
@@ -169,7 +169,7 @@ To create a function that returns a connection, use the following SQL:
 ```sql
 -- Assuming we already have a table named `person`…
 
-CREATE FUNCTION my_function(a int, b int) RETURNS SETOF person AS $$ … $$ LANGUAGE SQL;
+create function my_function(a int, b int) returns setof person as $$ … $$ language sql;
 ```
 
 To query a set in PostGraphQL, you would use all of the connection arguments you are familiar with in addition to the arguments to your procedure. For example:
@@ -196,23 +196,15 @@ For more information on constructing advanced queries, read [this article][advan
 [advanced-queries]: https://github.com/calebmer/postgraphql/blob/master/docs/advanced-queries.md
 
 ## Computed Columns
-PostGraphQL also provides support for computed columns. In order to define a computed column, just write a function that is `STABLE` or `IMMUTABLE` and has a table in your schema as its first argument. For example:
+PostGraphQL also provides support for computed columns. In order to define a computed column, just write a function that is `STABLE` or `IMMUTABLE`, has a table in your schema as its first argument, and the name starts with the table’s name. For example:
 
 ```sql
-CREATE FUNCTION full_name(person person) RETURNS text AS $$
+create function person_full_name(person person) returns text as $$
   select person.given_name || ' ' || person.family_name
-$$ LANGUAGE SQL;
+$$ language sql stable;
 ```
 
-Will create a computed column for your table named `person`. If you want, you can also prefix your computed procedure’s name with your table name. This is helpful when you want to avoid namespacing clashes but it is not required.
-
-```sql
--- PostGraphQL will treat this the same as the procedure above.
-
-CREATE FUNCTION person_full_name(person person) RETURNS text AS $$
-  select person.given_name || ' ' || person.family_name
-$$ LANGUAGE SQL;
-```
+Will create a computed column for your table named `person`.
 
 To query these in the PostGraphQL schema, its pretty intuitive: