Merge pull request #33 from jkyberneees/support-http-lambda-proxy

adding http-lambda-proxy integration

Author: jkyberneees

.npmignore

@@ -0,0 +1,7 @@
+.env
+test/
+demos/
+.nyc_output
+.github/
+.travis.yml
+.benchmark/

README.md

@@ -12,7 +12,10 @@ npm i fast-gateway
 ```
 
 ## Usage
-### Gateway
+Next we describe two examples proxying HTTP and Lambda downstream services.  
+> For simplicity of reading, both examples are separated, however a single gateway configuration supports all routes configurations.
+### HTTP Proxying
+#### Gateway
 ```js
 const gateway = require('fast-gateway')
 const server = gateway({
@@ -24,14 +27,56 @@ const server = gateway({
 
 server.start(8080)
 ```
-### Remote Service
+#### Remote Service
 ```js
 const service = require('restana')()
 service.get('/get', (req, res) => res.send('Hello World!'))
 
 service.start(3000)
 ```
 
+### Lambda Proxying
+#### Gateway
+```bash
+npm i http-lambda-proxy
+```
+```js
+const gateway = require('fast-gateway')
+const server = gateway({
+  routes: [{
+    prefix: '/service',
+    target: 'my-lambda-serverless-api',
+    lambdaProxy: {
+      region: 'eu-central-1'
+    }
+  }]
+})
+
+server.start(8080)
+```
+#### Lambda Implementation
+```js
+const serverless = require('serverless-http')
+const json = require('serverless-json-parser')
+const query = require('connect-query')
+
+const service = require('restana')()
+service.use(query())
+service.use(json())
+
+// routes
+service.get('/get', (req, res) => {
+  res.send({ msg: 'Go Serverless!' })
+})
+service.post('/post', (req, res) => {
+  res.send(req.body)
+})
+
+// export handler
+module.exports.handler = serverless(service)
+
+```
+
 ## Configuration options explained
 ```js
 {
@@ -42,7 +87,6 @@ service.start(3000)
   // If omitted, restana is used as default HTTP framework
   server, 
   // Optional restana library configuration (https://www.npmjs.com/package/restana#configuration)  
-  // 
   // Please note that if "server" is provided, this settings are ignored.
   restana: {},
   // Optional global middlewares in the format: (req, res, next) => next() 
@@ -51,23 +95,36 @@ service.start(3000)
   // Optional global value for routes "pathRegex". Default value: '/*'
   pathRegex: '/*',
   // Optional global requests timeout value (given in milliseconds). Default value: '0' (DISABLED)
+  // Ignored if proxyType = 'lambda'
   timeout: 0,
   // Optional "target" value that overrides the routes "target" config value. Feature intended for testing purposes.
   targetOverride: "https://yourdev.api-gateway.com",
 
   // HTTP proxy
   routes: [{
+    // Optional proxy type definition. Supported values: http, lambda
+    // Default value: http
+    proxyType: 'http'
     // Optional `fast-proxy` library configuration (https://www.npmjs.com/package/fast-proxy#options)
     // base parameter defined as the route target. Default value: {}
+    // This settings apply only when proxyType = 'http'
     fastProxy: {},
+    // Optional `http-lambda-proxy` library configuration (https://www.npmjs.com/package/http-lambda-proxy#options)
+    // The 'target' parameter is extracted from route.target, default region = 'eu-central-1'
+    // This settings apply only when proxyType = 'lambda'
+    lambdaProxy: {
+      region: 'eu-central-1'
+    },
     // Optional proxy handler function. Default value: (req, res, url, proxy, proxyOpts) => proxy(req, res, url, proxyOpts)
     proxyHandler: () => {},
     // Optional flag to indicate if target uses the HTTP2 protocol. Default value: false
+    // This setting apply only when proxyType = 'http'
     http2: false,
     // Optional path matching regex. Default value: '/*'
     // In order to disable the 'pathRegex' at all, you can use an empty string: ''
     pathRegex: '/*',
     // Optional service requests timeout value (given in milliseconds). Default value: '0' (DISABLED)
+    // This setting apply only when proxyType = 'http'
     timeout: 0,
     // route prefix
     prefix: '/public',
@@ -79,7 +136,8 @@ service.start(3000)
     },
     // Optional "prefix rewrite" before request is forwarded. Default value: ''
     prefixRewrite: '',
-    // Remote HTTP server URL to forward the request
+    // Remote HTTP server URL to forward the request. 
+    // If proxyType = 'lambda', the value is the name of the Lambda function, version, or alias.
     target: 'http://localhost:3000',
     // Optional HTTP methods to limit the requests proxy to certain verbs only
     // Supported HTTP methods: ['GET', 'DELETE', 'PATCH', 'POST', 'PUT', 'HEAD', 'OPTIONS', 'TRACE']
@@ -99,54 +157,14 @@ service.start(3000)
         // ...
       }
 
-      // other options allowed https://www.npmjs.com/package/fast-proxy#opts
+      // if proxyType= 'http', other options allowed https://www.npmjs.com/package/fast-proxy#opts
     }
   }]
 }
 ```
-### onResponse Hook default implementation
-For developers reference, next we describe how the default `onResponse` hook looks like: 
-```js
-const pump = require('pump')
-const toArray = require('stream-to-array')
-const TRANSFER_ENCODING_HEADER_NAME = 'transfer-encoding'
-
-const onResponse = async (req, res, stream) => {
-  const chunked = stream.headers[TRANSFER_ENCODING_HEADER_NAME]
-    ? stream.headers[TRANSFER_ENCODING_HEADER_NAME].endsWith('chunked')
-    : false
-
-  if (req.headers.connection === 'close' && chunked) {
-    try {
-      // remove transfer-encoding header
-      const transferEncoding = stream.headers[TRANSFER_ENCODING_HEADER_NAME].replace(/(,( )?)?chunked/, '')
-      if (transferEncoding) {
-        res.setHeader(TRANSFER_ENCODING_HEADER_NAME, transferEncoding)
-      } else {
-        res.removeHeader(TRANSFER_ENCODING_HEADER_NAME)
-      }
-
-      if (!stream.headers['content-length']) {
-        // pack all pieces into 1 buffer to calculate content length
-        const resBuffer = Buffer.concat(await toArray(stream))
-
-        // add content-length header and send the merged response buffer
-        res.setHeader('content-length', '' + Buffer.byteLength(resBuffer))
-        res.statusCode = stream.statusCode
-        res.end(resBuffer)
-
-        return
-      }
-    } catch (err) {
-      res.statusCode = 500
-      res.end(err.message)
-    }
-  }
+### onResponse hooks default implementation
+For developers reference, default hooks implementation are located in `lib/default-hooks.js` file.
 
-  res.statusCode = stream.statusCode
-  pump(stream, res)
-}
-```
 ## The "*GET /services.json*" endpoint
 Since version `1.3.5` the gateway exposes minimal documentation about registered services at: `GET /services.json`
 
@@ -312,6 +330,7 @@ This is your repo ;)
 ## Related projects
 - middleware-if-unless (https://www.npmjs.com/package/middleware-if-unless)
 - fast-proxy (https://www.npmjs.com/package/fast-proxy)
+- http-lambda-proxy (https://www.npmjs.com/package/http-lambda-proxy)
 - restana (https://www.npmjs.com/package/restana)
 
 ## Benchmarks

index.js

@@ -1,13 +1,11 @@
 /* eslint-disable no-useless-call */
 
-const fastProxy = require('fast-proxy')
+const proxyFactory = require('./lib/proxy-factory')
 const restana = require('restana')
-const pump = require('pump')
-const toArray = require('stream-to-array')
 const defaultProxyHandler = (req, res, url, proxy, proxyOpts) => proxy(req, res, url, proxyOpts)
 const DEFAULT_METHODS = require('restana/libs/methods').filter(method => method !== 'all')
 const send = require('@polka/send-type')
-const TRANSFER_ENCODING_HEADER_NAME = 'transfer-encoding'
+const PROXY_TYPES = ['http', 'lambda']
 
 const gateway = (opts) => {
   opts = Object.assign({
@@ -37,6 +35,15 @@ const gateway = (opts) => {
       route.prefixRewrite = ''
     }
 
+    // retrieve proxy type
+    const { proxyType = 'http' } = route
+    if (!PROXY_TYPES.includes(proxyType)) {
+      throw new Error('Unsupported proxy type, expecting one of ' + PROXY_TYPES.toString())
+    }
+
+    // retrieve default hooks for proxy
+    const { onRequestNoOp, onResponse } = require('./lib/default-hooks')[proxyType]
+
     // populating required NOOPS
     route.hooks = route.hooks || {}
     route.hooks.onRequest = route.hooks.onRequest || onRequestNoOp
@@ -49,11 +56,7 @@ const gateway = (opts) => {
     route.pathRegex = undefined === route.pathRegex ? opts.pathRegex : String(route.pathRegex)
 
     // instantiate route proxy
-    const { proxy } = fastProxy({
-      base: opts.targetOverride || route.target,
-      http2: !!route.http2,
-      ...(opts.fastProxy)
-    })
+    const proxy = proxyFactory({ opts, route, proxyType })
 
     // route proxy handler function
     const proxyHandler = route.proxyHandler || defaultProxyHandler
@@ -102,41 +105,4 @@ const handler = (route, proxy, proxyHandler) => async (req, res, next) => {
   }
 }
 
-const onRequestNoOp = (req, res) => { }
-const onResponse = async (req, res, stream) => {
-  const chunked = stream.headers[TRANSFER_ENCODING_HEADER_NAME]
-    ? stream.headers[TRANSFER_ENCODING_HEADER_NAME].endsWith('chunked')
-    : false
-
-  if (req.headers.connection === 'close' && chunked) {
-    try {
-      // remove transfer-encoding header
-      const transferEncoding = stream.headers[TRANSFER_ENCODING_HEADER_NAME].replace(/(,( )?)?chunked/, '')
-      if (transferEncoding) {
-        res.setHeader(TRANSFER_ENCODING_HEADER_NAME, transferEncoding)
-      } else {
-        res.removeHeader(TRANSFER_ENCODING_HEADER_NAME)
-      }
-
-      if (!stream.headers['content-length']) {
-      // pack all pieces into 1 buffer to calculate content length
-        const resBuffer = Buffer.concat(await toArray(stream))
-
-        // add content-length header and send the merged response buffer
-        res.setHeader('content-length', '' + Buffer.byteLength(resBuffer))
-        res.statusCode = stream.statusCode
-        res.end(resBuffer)
-
-        return
-      }
-    } catch (err) {
-      res.statusCode = 500
-      res.end(err.message)
-    }
-  }
-
-  res.statusCode = stream.statusCode
-  pump(stream, res)
-}
-
 module.exports = gateway

lib/default-hooks.js

@@ -0,0 +1,56 @@
+'use strict'
+
+const pump = require('pump')
+const toArray = require('stream-to-array')
+const TRANSFER_ENCODING_HEADER_NAME = 'transfer-encoding'
+
+module.exports = {
+  lambda: {
+    onRequestNoOp (req, res) { },
+    onResponse (req, res, response) {
+      const { statusCode, body } = JSON.parse(response.Payload)
+
+      res.statusCode = statusCode
+      res.end(body)
+    }
+  },
+  http: {
+    onRequestNoOp (req, res) { },
+    async onResponse (req, res, stream) {
+      const chunked = stream.headers[TRANSFER_ENCODING_HEADER_NAME]
+        ? stream.headers[TRANSFER_ENCODING_HEADER_NAME].endsWith('chunked')
+        : false
+
+      if (req.headers.connection === 'close' && chunked) {
+        try {
+          // remove transfer-encoding header
+          const transferEncoding = stream.headers[TRANSFER_ENCODING_HEADER_NAME].replace(/(,( )?)?chunked/, '')
+          if (transferEncoding) {
+            // header format includes many encodings, example: gzip, chunked
+            res.setHeader(TRANSFER_ENCODING_HEADER_NAME, transferEncoding)
+          } else {
+            res.removeHeader(TRANSFER_ENCODING_HEADER_NAME)
+          }
+
+          if (!stream.headers['content-length']) {
+            // pack all pieces into 1 buffer to calculate content length
+            const resBuffer = Buffer.concat(await toArray(stream))
+
+            // add content-length header and send the merged response buffer
+            res.setHeader('content-length', '' + Buffer.byteLength(resBuffer))
+            res.statusCode = stream.statusCode
+            res.end(resBuffer)
+
+            return
+          }
+        } catch (err) {
+          res.statusCode = 500
+          res.end(err.message)
+        }
+      }
+
+      res.statusCode = stream.statusCode
+      pump(stream, res)
+    }
+  }
+}

lib/proxy-factory.js

@@ -0,0 +1,22 @@
+'use strict'
+const fastProxy = require('fast-proxy')
+const lambdaProxy = require('http-lambda-proxy')
+
+module.exports = ({ proxyType, opts, route }) => {
+  let proxy
+  if (proxyType === 'http') {
+    proxy = fastProxy({
+      base: opts.targetOverride || route.target,
+      http2: !!route.http2,
+      ...(opts.fastProxy)
+    }).proxy
+  } else if (proxyType === 'lambda') {
+    proxy = lambdaProxy({
+      target: opts.targetOverride || route.target,
+      region: 'eu-central-1',
+      ...(route.lambdaProxy || {})
+    })
+  }
+
+  return proxy
+}

package.json

@@ -40,6 +40,7 @@
     "express-jwt": "^5.3.1",
     "express-rate-limit": "^5.1.1",
     "helmet": "^3.21.3",
+    "http-lambda-proxy": "^1.0.1",
     "mocha": "^7.1.0",
     "nyc": "^15.0.0",
     "opossum": "^4.2.4",

test/config.js

@@ -77,6 +77,17 @@ module.exports = async () => {
       prefixRewrite: '/endpoint-proxy-methods-put',
       target: 'http://localhost:3000',
       methods: ['PUT']
+    }, {
+      prefix: '/lambda',
+      proxyType: 'lambda',
+      target: 'a-lambda-function-name',
+      hooks: {
+        async onRequest (req, res) {
+          res.end('Go Serverless!')
+
+          return true
+        }
+      }
     }]
   }
 }