fastify 2.7.0 → 2.7.1

package/docs/Serverless.md

@@ -2,6 +2,11 @@
 
 Run serverless applications and REST APIs using your existing Fastify application.
 
+### Contents
+
+- [AWS Lambda](#aws-lambda)
+- [Google Cloud Run](#google-cloud-run)
+
 ### Attention Readers:
 > Fastify is not designed to run on serverless environments.
 The Fastify framework is designed to make implementing a traditional HTTP/S server easy.
@@ -12,21 +17,20 @@ it is possible to use Fastify in a serverless environment.
 Again, keep in mind that this is not Fastify's intended use case and
 we do not test for such integration scenarios.
 
-
 ## AWS Lambda
 
 The sample provided allows you to easily build serverless web applications/services
 and RESTful APIs using Fastify on top of AWS Lambda and Amazon API Gateway.
 
-*Note: This is just one possible way.*
+*Note: Using [aws-lambda-fastify](https://github.com/fastify/aws-lambda-fastify) is just one possible way.*
 
 ### app.js
 
 ```js
 const fastify = require('fastify');
 
-function init(serverFactory) {
-  const app = fastify({ serverFactory });
+function init() {
+  const app = fastify();
   app.get('/', (request, reply) => reply.send({ hello: 'world' }));
   return app;
 }
@@ -43,11 +47,9 @@ if (require.main !== module) {
 }
 ```
 
-You can simply wrap your initialization code by offering to inject an optional [serverFactory](https://www.fastify.io/docs/latest/Server/#serverfactory).
-
 When executed in your lambda function we don't need to listen to a specific port,
 so we just export the wrapper function `init` in this case.
-The [`lambda.js`](https://www.fastify.io/docs/latest/Server/#lambda.js) file will use this export.
+The [`lambda.js`](https://www.fastify.io/docs/latest/Serverless/#lambda-js) file will use this export.
 
 When you execute your Fastify application like always,
 i.e. `node app.js` *(the detection for this could be `require.main === module`)*,
@@ -56,31 +58,28 @@ you can normally listen to your port, so you can still run your Fastify function
 ### lambda.js
 
 ```js
-const awsServerlessExpress = require('aws-serverless-express');
+const awsLambdaFastify = require('aws-lambda-fastify')
 const init = require('./app');
 
-let server;
-const serverFactory = (handler) => {
-  server = awsServerlessExpress.createServer(handler);
-  return server;
-}
-const app = init(serverFactory);
-
-exports.handler = (event, context, callback) => {
-  context.callbackWaitsForEmptyEventLoop = false;
-  app.ready((e) => {
-    if (e) return console.error(e.stack || e);
-    awsServerlessExpress.proxy(server, event, context, 'CALLBACK', callback);
-  });
-};
+const proxy = awsLambdaFastify(init())
+// or
+// const proxy = awsLambdaFastify(init(), { binaryMimeTypes: ['application/octet-stream'] })
+
+exports.handler = proxy;
+// or
+// exports.handler = (event, context, callback) => proxy(event, context, callback);
+// or
+// exports.handler = (event, context) => proxy(event, context);
+// or
+// exports.handler = async (event, context) => proxy(event, context);
 ```
 
-We define a custom `serverFactory` function, in which we create a new server with the help of [`aws-serverless-express`](https://github.com/awslabs/aws-serverless-express)
-(make sure you install the dependency `npm i --save aws-serverless-express`).
-Then we call the `init` function (imported from [`app.js`](https://www.fastify.io/docs/latest/Server/#app.js)) with the `serverFactory` function as the only parameter.
-Finally inside the lambda `handler` function we wait for the Fastify app to be `ready`
-and proxy all the incoming events (API Gateway requests) to the `proxy` function from [`aws-serverless-express`](https://github.com/awslabs/aws-serverless-express).
-
+We just require [aws-lambda-fastify](https://github.com/fastify/aws-lambda-fastify)
+(make sure you install the dependency `npm i --save aws-lambda-fastify`) and our
+[`app.js`](https://www.fastify.io/docs/latest/Serverless/#app-js) file and call the
+exported `awsLambdaFastify` function with the `app` as the only parameter.
+The resulting `proxy` function has the correct signature to be used as lambda `handler` function. 
+This way all the incoming events (API Gateway requests) are passed to the `proxy` function of [aws-lambda-fastify](https://github.com/fastify/aws-lambda-fastify).
 
 ### Example
 
@@ -91,3 +90,103 @@ An example deployable with [claudia.js](https://claudiajs.com/tutorials/serverle
 
 - API Gateway doesn't support streams yet, so you're not able to handle [streams](https://www.fastify.io/docs/latest/Reply/#streams). 
 - API Gateway has a timeout of 29 seconds, so it's important to provide a reply during this time.
+
+## Google Cloud Run
+
+Unlike AWS Lambda or Google Cloud Functions, Google Cloud Run is a serverless **container** environment. It's primary purpose is to provide an infrastucture-abstracted environment to run arbitrary containers. As a result, Fastify can be deployed to Google Cloud Run with little-to-no code changes from the way you would write your Fastify app normally.
+
+*Follow the steps below to deploy to Google Cloud Run if you are already familiar with gcloud or just follow their [quickstart](https://cloud.google.com/run/docs/quickstarts/build-and-deploy)*
+
+### Adjust Fastfiy server
+
+In order for Fastify to properly listen for requests within the container, be sure to set the correct port and address:
+
+```js
+function build() {
+  const fastify = Fastify({ trustProxy: true })
+  return fastify
+}
+
+async function start() {
+  // Google Cloud Run will set this environment variable for you, so
+  // you can also use it to detect if you are running in Cloud Run
+  const IS_GOOGLE_CLOUD_RUN = process.env.K_SERVICE !== undefined
+
+  // You must listen on the port Cloud Run provides
+  const port = process.env.PORT || 3000
+
+  // You must listen on all IPV4 addresses in Cloud Run
+  const address = IS_GOOGLE_CLOUD_RUN ? "0.0.0.0" : undefined
+
+  try {
+    const server = build()
+    const address = await server.listen(port, address)
+    console.log(`Listening on ${address}`)
+  } catch (err) {
+    console.error(err)
+    process.exit(1)
+  }
+}
+
+module.exports = build
+
+if (require.main === module) {
+  start()
+}
+```
+
+### Add a Dockerfile
+
+You can add any valid `Dockerfile` that packages and runs a Node app. A basic `Dockerfile` can be found in the official [gcloud docs](https://github.com/knative/docs/blob/2d654d1fd6311750cc57187a86253c52f273d924/docs/serving/samples/hello-world/helloworld-nodejs/Dockerfile).
+
+```Dockerfile
+# Use the official Node.js 10 image.
+# https://hub.docker.com/_/node
+FROM node:10
+
+# Create and change to the app directory.
+WORKDIR /usr/src/app
+
+# Copy application dependency manifests to the container image.
+# A wildcard is used to ensure both package.json AND package-lock.json are copied.
+# Copying this separately prevents re-running npm install on every code change.
+COPY package*.json ./
+
+# Install production dependencies.
+RUN npm install --only=production
+
+# Copy local code to the container image.
+COPY . .
+
+# Run the web service on container startup.
+CMD [ "npm", "start" ]
+```
+
+### Add a .dockerignore
+
+To keep build artifacts out of your container (which keeps it small and improves build times), add a `.dockerignore` file like the one below:
+
+```.dockerignore
+Dockerfile
+README.md
+node_modules
+npm-debug.log
+```
+
+### Submit build
+
+Next, submit your app to be built into a Docker image by running the following command (replacing `PROJECT-ID` and `APP-NAME` with your GCP project id and an app name:
+
+```bash
+gcloud builds submit --tag gcr.io/PROJECT-ID/APP-NAME
+```
+
+### Deploy Image
+
+After your image has built, you can deploy it with the following command:
+
+```bash
+gcloud beta run deploy --image gcr.io/PROJECT-ID/APP-NAME --platform managed
+```
+
+Your app will be accessible from the URL GCP provides.

package/fastify.d.ts

@@ -316,7 +316,7 @@ declare namespace fastify {
       req: NodeJS.ReadableStream,
       res: http.ServerResponse
     },
-    headers: object,
+    headers: Record<string, string>,
     statusCode: number,
     statusMessage: string,
     payload: string,

package/lib/handleRequest.js

@@ -72,7 +72,7 @@ function handler (request, reply) {
 }
 
 function preValidationCallback (err, request, reply) {
-  if (reply.res.finished === true) return
+  if (reply.sent === true || reply.res.finished === true) return
   if (err != null) {
     reply.send(err)
     return
@@ -103,7 +103,7 @@ function preValidationCallback (err, request, reply) {
 }
 
 function preHandlerCallback (err, request, reply) {
-  if (reply.res.finished === true) return
+  if (reply.sent || reply.res.finished === true) return
   if (err != null) {
     reply.send(err)
     return

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "2.7.0",
+  "version": "2.7.1",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "typings": "fastify.d.ts",
@@ -88,25 +88,25 @@
     "node": ">=6"
   },
   "devDependencies": {
-    "@types/node": "^11.13.12",
-    "@typescript-eslint/eslint-plugin": "^1.4.2",
-    "@typescript-eslint/parser": "^1.4.2",
+    "@types/node": "^11.13.18",
+    "@typescript-eslint/eslint-plugin": "^1.13.0",
+    "@typescript-eslint/parser": "^1.13.0",
     "JSONStream": "^1.3.5",
     "ajv-pack": "^0.3.1",
     "autocannon": "^3.2.0",
     "branch-comparer": "^0.4.0",
-    "concurrently": "^4.1.0",
+    "concurrently": "^4.1.1",
     "cors": "^2.8.5",
-    "coveralls": "^3.0.3",
+    "coveralls": "^3.0.5",
     "dns-prefetch-control": "^0.2.0",
     "eslint-import-resolver-node": "^0.3.2",
     "fast-json-body": "^1.1.0",
     "fastify-plugin": "^1.5.0",
     "fluent-schema": "^0.7.3",
-    "form-data": "^2.3.3",
+    "form-data": "^2.5.0",
     "frameguard": "^3.0.0",
     "h2url": "^0.1.2",
-    "helmet": "^3.15.1",
+    "helmet": "^3.20.0",
     "hide-powered-by": "^1.0.0",
     "hsts": "^2.1.0",
     "http-errors": "^1.7.1",
@@ -115,9 +115,9 @@
     "license-checker": "^25.0.1",
     "lolex": "^4.0.1",
     "pre-commit": "^1.2.2",
-    "proxyquire": "^2.1.0",
+    "proxyquire": "^2.1.1",
     "pump": "^3.0.0",
-    "semver": "^6.0.0",
+    "semver": "^6.3.0",
     "send": "^0.17.0",
     "serve-static": "^1.13.2",
     "simple-get": "^3.0.3",
@@ -127,19 +127,19 @@
     "tap": "^12.5.2",
     "tap-mocha-reporter": "^3.0.7",
     "then-sleep": "^1.0.1",
-    "typescript": "^3.5.1",
+    "typescript": "^3.5.3",
     "x-xss-protection": "^1.1.0"
   },
   "dependencies": {
     "abstract-logging": "^1.0.0",
-    "ajv": "^6.9.2",
+    "ajv": "^6.10.2",
     "avvio": "^6.1.1",
     "fast-json-stringify": "^1.15.0",
     "find-my-way": "^2.0.0",
     "flatstr": "^1.0.12",
-    "light-my-request": "^3.2.0",
+    "light-my-request": "^3.4.1",
     "middie": "^4.0.1",
-    "pino": "^5.11.1",
+    "pino": "^5.13.1",
     "proxy-addr": "^2.0.4",
     "readable-stream": "^3.1.1",
     "rfdc": "^1.1.2",

package/test/hooks-async.js

@@ -4,7 +4,8 @@ const split = require('split2')
 const sget = require('simple-get').concat
 const Fastify = require('..')
 const fs = require('fs')
-const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
+const { promisify } = require('util')
+const sleep = promisify(setTimeout)
 
 function asyncHookTest (t) {
   const test = t.test
@@ -231,6 +232,53 @@ function asyncHookTest (t) {
     })
   })
 
+  test('preValidation hooks should be able to block a request with async onSend', t => {
+    t.plan(5)
+    const fastify = Fastify()
+
+    fastify.addHook('preValidation', async (req, reply) => {
+      reply.send('hello')
+    })
+
+    fastify.addHook('onSend', async (req, reply, payload) => {
+      await sleep(10)
+      t.equal(payload, 'hello')
+    })
+
+    fastify.addHook('preHandler', async (request, reply) => {
+      t.fail('we should not be here')
+    })
+
+    fastify.addHook('onResponse', async (request, reply) => {
+      t.ok('called')
+    })
+
+    fastify.post('/', {
+      schema: {
+        body: {
+          type: 'object',
+          properties: {
+            hello: {
+              type: 'string'
+            }
+          },
+          required: ['hello']
+        }
+      }
+    }, function (request, reply) {
+      t.fail('we should not be here')
+    })
+
+    fastify.inject({
+      url: '/',
+      method: 'POST'
+    }, (err, res) => {
+      t.error(err)
+      t.is(res.statusCode, 200)
+      t.is(res.payload, 'hello')
+    })
+  })
+
   test('preSerialization hooks should be able to modify the payload', t => {
     t.plan(3)
     const fastify = Fastify()
@@ -339,6 +387,37 @@ function asyncHookTest (t) {
     })
   })
 
+  test('preHandler hooks should be able to block a request (last hook) with a delay in onSend', t => {
+    t.plan(5)
+    const fastify = Fastify()
+
+    fastify.addHook('preHandler', async (req, reply) => {
+      reply.send('hello')
+    })
+
+    fastify.addHook('onSend', async (req, reply, payload) => {
+      await sleep(10)
+      t.equal(payload, 'hello')
+    })
+
+    fastify.addHook('onResponse', async (request, reply) => {
+      t.ok('called')
+    })
+
+    fastify.get('/', function (request, reply) {
+      t.fail('we should not be here')
+    })
+
+    fastify.inject({
+      url: '/',
+      method: 'GET'
+    }, (err, res) => {
+      t.error(err)
+      t.is(res.statusCode, 200)
+      t.is(res.payload, 'hello')
+    })
+  })
+
   test('onRequest respond with a stream', t => {
     t.plan(4)
     const fastify = Fastify()