PostGraphQL V4 - announcing graphile-build

.dockerignore

@@ -0,0 +1 @@
+Dockerfile

Dockerfile

@@ -0,0 +1,19 @@
+FROM node:alpine
+LABEL description="A GraphQL API created by reflection over a PostgreSQL schmea https://github.com/postgraphql/postgraphql"
+
+# alpine linux standard doesn't include bash, and postgraphql scripts have #! bash
+RUN apk add --update bash && rm -rf /var/cache/apk/*
+
+RUN mkdir -p /postgraphql
+WORKDIR /postgraphql
+
+COPY . /postgraphql
+
+RUN npm install
+RUN scripts/build
+RUN npm pack
+RUN npm install -g postgraphql-*.tgz
+
+RUN rm -rf /postgraphql
+EXPOSE 5000
+ENTRYPOINT ["postgraphql", "-n", "0.0.0.0"]

README.md

@@ -50,6 +50,19 @@ 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).
 
+There is also a docker image for running PostGraphQL maintained by @angelosarto, simply pass the same options to the docker container:
+
+```bash
+docker pull postgraphql/postgraphql
+docker run postgraphql/postgraphql --help
+```
+
+To connect to a database and expose the PostGraphQL port try this:
+
+```bash
+docker run -p 5000:5000 postgraphql/postgraphql --connection postgres://POSTGRES_USER:POSTGRES_PASSWORD@POSTGRES_HOST:POSTGRES_PORT/POSTGRES_SCHEMA
+```
+
 Also make sure to check out the **[forum example][]** and especially **[step by step tutorial][]** for a demo of a PostGraphQL compliant schema and authentication.
 
 [forum example]: https://github.com/calebmer/postgraphql/tree/master/examples/forum

docs/default-role.md

@@ -38,7 +38,7 @@ The `auth_user` will have all the priveleges PostGraphQL might need.
 
 You can also specify a `default_role` with PostGraphQL. The `default_role` will be used by PostGraphQL whenever no authorization token is provided or when the role claim in the authorization token is not specified. So all users that don’t explicitly specify a role will automatically use the `default_role`.
 
-So the `default_role` should have restricted priveleges to only your data that is publicly accessible.
+So the `default_role` should have restricted privileges to only your data that is publicly accessible.
 
 After that you could also specify more roles like a `user_role` which should be included in the payload of your authorization tokens which may have more or less permissions then `default_role`.
 

examples/forum/TUTORIAL.md

@@ -482,7 +482,7 @@ After we insert a profile into `forum_example.person`, we use the `pgcrypto` ext
 >
 > For an overview of passwords in Postgres past the `pgcrypto` documentation, see the answer to the StackOverflow question “[How can I hash passwords in Postgres?](http://stackoverflow.com/a/18687445/1568890)”
 
-At the end of the implementation you will see `language plpgsql strict security definer`. `language plpgsql` we already understand, but the other words are new. The word `strict` means that if the function gets null input, than the output will be automatically null as well and Postgres won’t call the function. That is `password` cannot be null or `first_name` cannot be null otherwise the result will also be null and nothing will be executed. The words `security definer` mean that this function is executed with the privileges of the Postgres user who created it. Remember how we said users would never be able to insert into `forum_example_private.person_account`? Well this function can insert into `forum_example_private.person_account` because it uses the privileges of the definer.
+At the end of the implementation you will see `language plpgsql strict security definer`. `language plpgsql` we already understand, but the other words are new. The word `strict` means that if the function gets null input, then the output will be automatically null as well and Postgres won’t call the function. That is `password` cannot be null or `first_name` cannot be null otherwise the result will also be null and nothing will be executed. The words `security definer` mean that this function is executed with the privileges of the Postgres user who created it. Remember how we said users would never be able to insert into `forum_example_private.person_account`? Well this function can insert into `forum_example_private.person_account` because it uses the privileges of the definer.
 
 > **Warning:** Make sure that when you create a function with `security definer` there are no ‘holes’ a user could use to see or mutate more data than they are not allowed to. Since the above is a simple function, we are fine. If you don’t need `security definer`, try not to use it.
 

package.json

@@ -48,7 +48,7 @@
     "pg-connection-string": "^0.1.3",
     "pg-minify": "^0.4.1",
     "pluralize": "^3.0.0",
-    "postgraphql-build": "0.0.1-alpha5.1",
+    "postgraphql-build": "0.0.1-alpha6.0",
     "postgres-interval": "^1.0.2",
     "send": "^0.14.1",
     "tslib": "^1.5.0"

src/postgraphql/__tests__/__mocks__/postgraphql-build.js

@@ -0,0 +1,17 @@
+const { GraphQLSchema, GraphQLObjectType, GraphQLInt } = require('graphql');
+
+const dummySchema = new GraphQLSchema({
+  query: new GraphQLObjectType({
+    name: 'MockSchemaQuery',
+    fields: {
+      foo: {
+        type: GraphQLInt,
+      }
+    }
+  })
+})
+
+module.exports = {
+  createPostGraphQLSchema: jest.fn(async (a, b, c) => dummySchema),
+  watchPostGraphQLSchema: jest.fn(async (a, b, c, cb) => cb(dummySchema)),
+}

src/postgraphql/__tests__/postgraphql-test.js

@@ -1,67 +1,26 @@
 jest.mock('pg')
 jest.mock('pg-connection-string')
-jest.mock('../schema/createPostGraphQLSchema')
+jest.mock('postgraphql-build')
 jest.mock('../http/createPostGraphQLHttpRequestHandler')
-jest.mock('../watch/watchPgSchemas')
 
 import { Pool } from 'pg'
 import { parse as parsePgConnectionString } from 'pg-connection-string'
-import createPostGraphQLSchema from '../schema/createPostGraphQLSchema'
+import { createPostGraphQLSchema, watchPostGraphQLSchema } from '..'
 import createPostGraphQLHttpRequestHandler from '../http/createPostGraphQLHttpRequestHandler'
-import watchPgSchemas from '../watch/watchPgSchemas'
 import postgraphql from '../postgraphql'
 
 const chalk = require('chalk')
 
 createPostGraphQLHttpRequestHandler.mockImplementation(({ getGqlSchema }) => Promise.resolve(getGqlSchema()).then(() => null))
-watchPgSchemas.mockImplementation(() => Promise.resolve())
-
-test('will use the first parameter as the pool if it is an instance of `Pool`', async () => {
-  const pgPool = new Pool()
-  await postgraphql(pgPool)
-  expect(pgPool.connect.mock.calls).toEqual([[]])
-  expect(createPostGraphQLHttpRequestHandler.mock.calls.length).toBe(1)
-  expect(createPostGraphQLHttpRequestHandler.mock.calls[0][0].pgPool).toBe(pgPool)
-})
-
-test('will use the config to create a new pool', async () => {
-  Pool.mockClear()
-  createPostGraphQLHttpRequestHandler.mockClear()
-  const pgPoolConfig = Symbol('pgPoolConfig')
-  await postgraphql(pgPoolConfig)
-  expect(Pool.mock.calls).toEqual([[pgPoolConfig]])
-  expect(Pool.mock.instances[0].connect.mock.calls).toEqual([[]])
-  expect(createPostGraphQLHttpRequestHandler.mock.calls.length).toBe(1)
-  expect(createPostGraphQLHttpRequestHandler.mock.calls[0][0].pgPool).toBe(Pool.mock.instances[0])
-})
-
-test('will parse a string config before creating a new pool', async () => {
-  Pool.mockClear()
-  createPostGraphQLHttpRequestHandler.mockClear()
-  parsePgConnectionString.mockClear()
-  const pgPoolConnectionString = 'abcdefghijklmnopqrstuvwxyz'
-  const pgPoolConfig = Symbol('pgPoolConfig')
-  parsePgConnectionString.mockReturnValueOnce(pgPoolConfig)
-  await postgraphql(pgPoolConnectionString)
-  expect(parsePgConnectionString.mock.calls).toEqual([[pgPoolConnectionString]])
-  expect(Pool.mock.calls).toEqual([[pgPoolConfig]])
-  expect(Pool.mock.instances[0].connect.mock.calls).toEqual([[]])
-  expect(createPostGraphQLHttpRequestHandler.mock.calls.length).toBe(1)
-  expect(createPostGraphQLHttpRequestHandler.mock.calls[0][0].pgPool).toBe(Pool.mock.instances[0])
-})
 
 test('will use a connected client from the pool, the schemas, and options to create a GraphQL schema', async () => {
   createPostGraphQLSchema.mockClear()
   createPostGraphQLHttpRequestHandler.mockClear()
   const pgPool = new Pool()
   const schemas = [Symbol('schemas')]
   const options = Symbol('options')
-  const pgClient = { release: jest.fn() }
-  pgPool.connect.mockReturnValue(Promise.resolve(pgClient))
   await postgraphql(pgPool, schemas, options)
-  expect(pgPool.connect.mock.calls).toEqual([[]])
-  expect(createPostGraphQLSchema.mock.calls).toEqual([[pgClient, schemas, options]])
-  expect(pgClient.release.mock.calls).toEqual([[]])
+  expect(createPostGraphQLSchema.mock.calls).toEqual([[pgPool, schemas, options]])
 })
 
 test('will use a connected client from the pool, the default schema, and options to create a GraphQL schema', async () => {
@@ -70,14 +29,12 @@ test('will use a connected client from the pool, the default schema, and options
   const pgPool = new Pool()
   const options = Symbol('options')
   const pgClient = { release: jest.fn() }
-  pgPool.connect.mockReturnValue(Promise.resolve(pgClient))
   await postgraphql(pgPool, options)
-  expect(pgPool.connect.mock.calls).toEqual([[]])
-  expect(createPostGraphQLSchema.mock.calls).toEqual([[pgClient, ['public'], options]])
-  expect(pgClient.release.mock.calls).toEqual([[]])
+  expect(createPostGraphQLSchema.mock.calls).toEqual([[pgPool, ['public'], options]])
 })
 
 test('will use a created GraphQL schema to create the HTTP request handler and pass down options', async () => {
+  createPostGraphQLSchema.mockClear()
   createPostGraphQLHttpRequestHandler.mockClear()
   const pgPool = new Pool()
   const gqlSchema = Symbol('gqlSchema')
@@ -95,48 +52,20 @@ test('will use a created GraphQL schema to create the HTTP request handler and p
 })
 
 test('will watch Postgres schemas when `watchPg` is true', async () => {
+  createPostGraphQLSchema.mockClear()
+  watchPostGraphQLSchema.mockClear()
   const pgPool = new Pool()
   const pgSchemas = [Symbol('a'), Symbol('b'), Symbol('c')]
   await postgraphql(pgPool, pgSchemas, { watchPg: false })
   await postgraphql(pgPool, pgSchemas, { watchPg: true })
-  expect(watchPgSchemas.mock.calls.length).toBe(1)
-  expect(watchPgSchemas.mock.calls[0].length).toBe(1)
-  expect(Object.keys(watchPgSchemas.mock.calls[0][0])).toEqual(['pgPool', 'pgSchemas', 'onChange'])
-  expect(watchPgSchemas.mock.calls[0][0].pgPool).toBe(pgPool)
-  expect(watchPgSchemas.mock.calls[0][0].pgSchemas).toBe(pgSchemas)
-  expect(typeof watchPgSchemas.mock.calls[0][0].onChange).toBe('function')
-})
+  expect(createPostGraphQLSchema.mock.calls).toEqual([[pgPool, pgSchemas, { watchPg: false }]])
 
-test('will create a new PostGraphQL schema on when `watchPgSchemas` emits a change', async () => {
-  watchPgSchemas.mockClear()
-  createPostGraphQLHttpRequestHandler.mockClear()
-  const gqlSchemas = [Symbol('a'), Symbol('b'), Symbol('c')]
-  let gqlSchemaI = 0
-  createPostGraphQLSchema.mockClear()
-  createPostGraphQLSchema.mockImplementation(() => Promise.resolve(gqlSchemas[gqlSchemaI++]))
-  const pgPool = new Pool()
-  const pgClient = { release: jest.fn() }
-  pgPool.connect.mockReturnValue(Promise.resolve(pgClient))
-  const mockLog = jest.fn()
-  const origLog = console.log
-  console.log = mockLog
-  await postgraphql(pgPool, [], { watchPg: true })
-  const { onChange } = watchPgSchemas.mock.calls[0][0]
-  const { getGqlSchema } = createPostGraphQLHttpRequestHandler.mock.calls[0][0]
-  expect(pgPool.connect.mock.calls).toEqual([[]])
-  expect(pgClient.release.mock.calls).toEqual([[]])
-  expect(await getGqlSchema()).toBe(gqlSchemas[0])
-  onChange({ commands: ['a', 'b', 'c'] })
-  expect(await getGqlSchema()).toBe(gqlSchemas[1])
-  onChange({ commands: ['d', 'e'] })
-  expect(await getGqlSchema()).toBe(gqlSchemas[2])
-  expect(pgPool.connect.mock.calls).toEqual([[], [], []])
-  expect(pgClient.release.mock.calls).toEqual([[], [], []])
-  expect(mockLog.mock.calls).toEqual([
-    [`Rebuilding PostGraphQL API after Postgres command(s): ️${chalk.bold.cyan('a')}, ${chalk.bold.cyan('b')}, ${chalk.bold.cyan('c')}`],
-    [`Rebuilding PostGraphQL API after Postgres command(s): ️${chalk.bold.cyan('d')}, ${chalk.bold.cyan('e')}`],
-  ])
-  console.log = origLog
+  expect(watchPostGraphQLSchema.mock.calls.length).toBe(1);
+  expect(watchPostGraphQLSchema.mock.calls[0].length).toBe(4);
+  expect(watchPostGraphQLSchema.mock.calls[0][0]).toEqual(pgPool)
+  expect(watchPostGraphQLSchema.mock.calls[0][1]).toEqual(pgSchemas)
+  expect(watchPostGraphQLSchema.mock.calls[0][2]).toEqual({ watchPg: true })
+  expect(typeof watchPostGraphQLSchema.mock.calls[0][3]).toBe('function')
 })
 
 test('will not error if jwtSecret is provided without jwtPgTypeIdentifier', async () => {

src/postgraphql/__tests__/postgraphqlIntegrationMutations-test.js

@@ -1,9 +1,11 @@
+jest.unmock('postgraphql-build')
+
 import { resolve as resolvePath } from 'path'
 import { readFile, readdirSync } from 'fs'
 import { graphql } from 'graphql'
 import withPgClient from '../../__tests__/utils/withPgClient'
 import { $$pgClient } from '../../postgres/inventory/pgClientFromContext'
-import createPostGraphQLSchema from '../schema/createPostGraphQLSchema'
+import { createPostGraphQLSchema } from '..'
 
 // This test suite can be flaky. Increase it’s timeout.
 jasmine.DEFAULT_TIMEOUT_INTERVAL = 1000 * 20

src/postgraphql/__tests__/postgraphqlIntegrationQueries-test.js

@@ -1,9 +1,12 @@
+jest.unmock('postgraphql-build')
+
 import { resolve as resolvePath } from 'path'
 import { readFile, readdirSync } from 'fs'
 import { graphql } from 'graphql'
 import withPgClient from '../../__tests__/utils/withPgClient'
 import { $$pgClient } from '../../postgres/inventory/pgClientFromContext'
-import createPostGraphQLSchema from '../schema/createPostGraphQLSchema'
+import { createPostGraphQLSchema } from '..'
+
 
 // This test suite can be flaky. Increase it’s timeout.
 jasmine.DEFAULT_TIMEOUT_INTERVAL = 1000 * 20

src/postgraphql/__tests__/postgraphqlIntegrationSchema-test.js

@@ -1,9 +1,11 @@
 // TODO: There may be some excessive waste, if we could somehow filter what
 // these guys see, that would be great 👍
 
+jest.unmock('postgraphql-build')
+
 import { printSchema } from 'graphql'
 import withPgClient from '../../__tests__/utils/withPgClient'
-import createPostGraphQLSchema from '../schema/createPostGraphQLSchema'
+import { createPostGraphQLSchema } from '..'
 
 // This test suite can be flaky. Increase it’s timeout.
 jasmine.DEFAULT_TIMEOUT_INTERVAL = 1000 * 20

src/postgraphql/__tests__/postgraphqlIntegrationSchemaExport-test.js

@@ -1,7 +1,8 @@
 jest.mock('fs')
+jest.unmock('postgraphql-build')
 
 import withPgClient from '../../__tests__/utils/withPgClient'
-import createPostGraphQLSchema from '../schema/createPostGraphQLSchema'
+import { createPostGraphQLSchema } from '..'
 import exportPostGraphQLSchema from '../schema/exportPostGraphQLSchema'
 import { writeFile } from 'fs'
 

src/postgraphql/postgraphql.ts

@@ -96,30 +96,26 @@ export default function postgraphql (
   //
   // This is not a constant because when we are in watch mode, we want to swap
   // out the `gqlSchema`.
-  let gqlSchema = createGqlSchema();
+  let gqlSchema
+  let gqlSchemaPromise = createGqlSchema()
 
   // Finally create our Http request handler using our options, the Postgres
   // pool, and GraphQL schema. Return the final result.
   return createPostGraphQLHttpRequestHandler(Object.assign({}, options, {
-    getGqlSchema: () => gqlSchema,
+    getGqlSchema: () => gqlSchema || gqlSchemaPromise,
     pgPool,
     _emitter,
   }))
 
   async function createGqlSchema (): Promise<GraphQLSchema> {
     try {
       if (options.watchPg) {
-        let firstSchema = true;
         await watchPostGraphQLSchema(pgPool, pgSchemas, options, schema => {
           gqlSchema = schema
-          if (firstSchema) {
-            firstSchema = false;
-          } else {
-            _emitter.emit('schemas:changed')
-          }
+          _emitter.emit('schemas:changed')
           exportGqlSchema(gqlSchema)
         });
-        if (firstSchema) {
+        if (!gqlSchema) {
           throw new Error("Consistency error: watchPostGraphQLSchema promises to call the callback before the promise resolves; but this hasn't happened")
         }
       } else {
@@ -146,8 +142,7 @@ export default function postgraphql (
 }
 
 function handleFatalError (error: Error): never {
-  // tslint:disable-next-line no-console
-  console.error(`${error.stack}\n`)
+  process.stderr.write(`${error.stack}\n`) // console.error fails under the tests
   process.exit(1)
 
   // `process.exit` will mean all code below it will never get called.

yarn.lock

@@ -2678,20 +2678,21 @@ graphiql@^0.11.2:
     codemirror-graphql "^0.6.8"
     marked "0.3.6"
 
-graphql-build-pg@^0.0.1-alpha5.1:
-  version "0.0.1-alpha5.1"
-  resolved "https://registry.yarnpkg.com/graphql-build-pg/-/graphql-build-pg-0.0.1-alpha5.1.tgz#1b093d16402d62c49b8d7ac96a40c27fccb9b0f4"
+graphql-build-pg@^0.0.1-alpha6.0:
+  version "0.0.1-alpha6.0"
+  resolved "https://registry.yarnpkg.com/graphql-build-pg/-/graphql-build-pg-0.0.1-alpha6.0.tgz#09ccbf1a6d78a2c84b8651b7be65ac881a40ea13"
   dependencies:
     graphql-iso-date "^3.2.0"
     graphql-type-json "^0.1.4"
+    jsonwebtoken "^7.4.1"
     lru-cache "4.1.1"
     pg-range-parser "^1.0.0"
     pg-sql2 "^0.0.1-alpha5.1"
     pluralize "^5.0.0"
 
-graphql-build@^0.0.1-alpha5.1:
-  version "0.0.1-alpha5.1"
-  resolved "https://registry.yarnpkg.com/graphql-build/-/graphql-build-0.0.1-alpha5.1.tgz#ee634a4d34611e5f52ffb59a07bab9964d244e94"
+graphql-build@^0.0.1-alpha6.0:
+  version "0.0.1-alpha6.0"
+  resolved "https://registry.yarnpkg.com/graphql-build/-/graphql-build-0.0.1-alpha6.0.tgz#c4c389681acfb16557e313acf7586012ae410e37"
   dependencies:
     graphql-parse-resolve-info "^0.0.1-alpha5.1"
     graphql-type-json "^0.1.4"
@@ -3612,7 +3613,7 @@ jsonpointer@^4.0.0:
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/jsonpointer/-/jsonpointer-4.0.1.tgz#4fd92cb34e0e9db3c89c8622ecf51f9b978c6cb9"
 
-jsonwebtoken@^7.1.9:
+jsonwebtoken@^7.1.9, jsonwebtoken@^7.4.1:
   version "7.4.1"
   resolved "https://registry.yarnpkg.com/jsonwebtoken/-/jsonwebtoken-7.4.1.tgz#7ca324f5215f8be039cd35a6c45bb8cb74a448fb"
   dependencies:
@@ -4819,12 +4820,12 @@ postcss@^6.0.1:
     source-map "^0.5.6"
     supports-color "^4.1.0"
 
-postgraphql-build@0.0.1-alpha5.1:
-  version "0.0.1-alpha5.1"
-  resolved "https://registry.yarnpkg.com/postgraphql-build/-/postgraphql-build-0.0.1-alpha5.1.tgz#e2c3de4c61454b3d5fcb67efad5cb5a20a96d71b"
+postgraphql-build@0.0.1-alpha6.0:
+  version "0.0.1-alpha6.0"
+  resolved "https://registry.yarnpkg.com/postgraphql-build/-/postgraphql-build-0.0.1-alpha6.0.tgz#fb039c710584de9bc2b6447520fc9ca0cf0f2abd"
   dependencies:
-    graphql-build "^0.0.1-alpha5.1"
-    graphql-build-pg "^0.0.1-alpha5.1"
+    graphql-build "^0.0.1-alpha6.0"
+    graphql-build-pg "^0.0.1-alpha6.0"
 
 postgres-array@~1.0.0:
   version "1.0.2"