Feature request: Ability to build for zeit/now serverless functions

[barbalex]

I guess only the deploy script would have to be modified?

But I am a complete backend noob so just asking.

[benjie]

@enisdenjo mentioned on Discord that there's a bug in the Zeit pkg bundler which causes Maximum call stack size exceeded errors periodically. Reference: vercel/pkg#681

Not sure if that's relevant or not.

I am a serverless newbie myself so I'm not sure how hard it would be to support Now.

[enisdenjo]

Since lambda functions do just one task and then die, the related pkg call stack issue might not prevail here.

Through my personal experience the server was occasionally entering an invalid state which caused lots of Maximum call stack size exceeded issues on some queries (not all were affected, some were working some not). But this invalid state gets reached only when the server is running after a while; given that PostGraphile won't be running long in a lamda function, my guess is it will not occur as often... But still, haven't tested it, so don't take my word for it. :)

Maybe use a different node compiler? nexe?

[enisdenjo]

AWS lambda has a Node.js v10 runtime. So you don't even need to use any node compilation technologies.

[benjie]

Is Now lambda-compatible or does it have it's own way of running? We use the aws-serverless-express stub (it doesn't and we don't use express itself, I think the name of this package is much like the "Java" in "JavaScript" - a play on popularity) to expose an HTTP middleware as a serverless function.

postgraphile-lambda-example/src/index.js

Line 65 in 2b1a9fb

exports.handler = (event, context) => awsServerlessExpress.proxy(server, event, context);

[konsumer]

It's lambda-compatible, but they run node apps through pkg to bundle your whole app into a single file, for smaller (tree-shaken) file-sizes and ES7 syntax, among other things. I think it also simplifies & speeds up the compilation step, as it uses a fast AST-aware cache.

It's totally possible to build the graphile cache in the "build phase" and then import the cache, in the code:

const { createPostGraphileSchema } = require('postgraphile')
const { Pool } = require('pg')

const schemas = process.env.DATABASE_SCHEMAS
  ? process.env.DATABASE_SCHEMAS.split(',')
  : ['app_public']

async function main () {
  console.log('Generating cache')
  const pgPool = new Pool({
    connectionString: process.env.DATABASE_URL
  })
  await createPostGraphileSchema(pgPool, schemas, {
    writeCache: `${__dirname}/../src/postgraphile_cache.json`
  })
  await pgPool.end()
}

main().then(null, e => {
  console.error(e)
  process.exit(1)
})

then use it like this:

import { postgraphile } from 'postgraphile'

// this works, but how do I actually use the cache?
import cache from '../src/postgraphile_cache.json'

// yours go here...
const options = {}

const handler = postgraphile(process.env.DATABASE_URL, schemas, {
  ...options,
  // not this, but what should I do here?
  // readCache: `${__dirname}/../src/postgraphile_cache.json`
})

The problem here is that readCache needs a filename, and I can't seem to find an option to pass a pre-made cache (in this case, named cache) directly to postgraphile.

__dirname is overwritten with /, unhelpfully, but also the deploy setup only pushes what it has in the bundle, so a JSON file wouldn't be included, automatically.

I think there are some options in now for including asset sort of files (non-imported) in the bundle that gets run on lambda (and pkg does interesting things to include compiled native node-libs, similar to this.) There may also be a hacky way to do it, by putting the JSON file in the public static files, then making a web-request to grab it, but I hate that. It would be ideal if I could just import the JSON directly (it would be inside the bundle) as this would simplify the end-users configuration, and work more reliably.

Does anyone know a way to inject the cache directly into postgraphile?

[benjie]

Looks like just requiring the JSON should work:

import { postgraphile } from 'postgraphile'

// this works, but how do I actually use the cache?
import cache from '../src/postgraphile_cache.json'

// yours go here...
const options = {}

const handler = postgraphile(process.env.DATABASE_URL, schemas, {
  ...options,
  readCache: require(`${__dirname}/../src/postgraphile_cache.json`)
})

(If you're in TypeScript you might need an (require(...) as any) to bypass types.)

[konsumer]

Looks like just requiring the JSON should work:

Hmm, no, that is a JSON object, not a filename (as readCache expects)

[enisdenjo]

readCache can parse objects since postgraphile@v4.4.4 (check out: graphile/graphile-engine#479). The documentation needs an update.

[konsumer]

That is awesome, thanks @benjie and @enisdenjo I'd be happy to make a demo that deploys to now.

If that's the case, then I think in the above example I should be able to just pass it cache directly:

import { postgraphile } from 'postgraphile'

import readCache from '../src/postgraphile_cache.json'

// yours go here...
const options = {readCache}

const handler = postgraphile(process.env.DATABASE_URL, schemas, options)

[konsumer]

Oh, wait, there already is one at bottom of readme. doh!

https://github.com/ggascoigne/now-postgraphile

But weirdly, it uses a file. I'm pretty sure that wouldn't work:
https://github.com/ggascoigne/now-postgraphile/blob/master/api/graphql.ts#L36

[benjie]

I assume it must work since there's a demo of it: https://now-postgraphile.now.sh/