Copy files from next-aws-lambda

Copy over the files from the next-aws-lambda package and manually
bundle them into our Netlify Functions. This gives us more flexibility
to customize the compatibility layer between Netlify Functions and
Next.js. For now, no changes have been made to the next-aws-lambda
files and they have been copied as-is.

next-aws-lambda source: https://github.com/serverless-nextjs/serverless-next.js/tree/master/packages/compat-layers/apigw-lambda-compat

Author: FinnWoelm

lib/config.js

@@ -19,12 +19,11 @@ const NEXT_CONFIG_PATH = join(".", "next.config.js");
 // This is the folder that NextJS builds to; default is .next
 const NEXT_DIST_DIR = getNextDistDir({ nextConfigPath: NEXT_CONFIG_PATH });
 
+// This is the folder with templates for Netlify Functions
+const TEMPLATES_DIR = join(__dirname, "templates");
+
 // This is the Netlify Function template that wraps all SSR pages
-const FUNCTION_TEMPLATE_PATH = join(
-  __dirname,
-  "templates",
-  "netlifyFunction.js"
-);
+const FUNCTION_TEMPLATE_PATH = join(TEMPLATES_DIR, "netlifyFunction.js");
 
 // This is the file where custom redirects can be configured
 const CUSTOM_REDIRECTS_PATH = join(".", "_redirects");
@@ -35,6 +34,7 @@ module.exports = {
   PUBLIC_PATH,
   NEXT_CONFIG_PATH,
   NEXT_DIST_DIR,
+  TEMPLATES_DIR,
   FUNCTION_TEMPLATE_PATH,
   CUSTOM_REDIRECTS_PATH,
 };

lib/helpers/setupNetlifyFunctionForPage.js

@@ -2,6 +2,7 @@ const { copySync } = require("fs-extra");
 const { join } = require("path");
 const {
   NEXT_DIST_DIR,
+  TEMPLATES_DIR,
   NETLIFY_FUNCTIONS_PATH,
   FUNCTION_TEMPLATE_PATH,
 } = require("../config");
@@ -23,6 +24,14 @@ const setupNetlifyFunctionForPage = (filePath) => {
     errorOnExist: true,
   });
 
+  // Copy function helpers
+  ["compat.js", "reqResMapper.js"].forEach((helper) => {
+    copySync(join(TEMPLATES_DIR, helper), join(functionDirectory, helper), {
+      overwrite: false,
+      errorOnExist: true,
+    });
+  });
+
   // Copy page
   const nextPageCopyPath = join(functionDirectory, "nextJsPage.js");
   copySync(join(NEXT_DIST_DIR, "serverless", filePath), nextPageCopyPath, {

lib/templates/compat.js

@@ -0,0 +1,22 @@
+// API Gateway Lambda Compat
+// License: MIT
+// Source: https://github.com/serverless-nextjs/serverless-next.js/blob/master/packages/compat-layers/apigw-lambda-compat/index.js
+
+const reqResMapper = require("./reqResMapper");
+
+const handlerFactory = (page) => (event, _context, callback) => {
+  const { req, res, responsePromise } = reqResMapper(event, callback);
+  if (page.render instanceof Function) {
+    // Is a React component
+    page.render(req, res);
+  } else {
+    // Is an API
+    page.default(req, res);
+  }
+
+  if (responsePromise) {
+    return responsePromise;
+  }
+};
+
+module.exports = handlerFactory;

lib/templates/netlifyFunction.js

@@ -2,7 +2,7 @@
 //           running next-on-netlify
 
 // Compatibility wrapper for NextJS page
-const compat = require("next-aws-lambda");
+const compat = require("./compat");
 // Load the NextJS page
 const page = require("./nextJsPage");
 

lib/templates/reqResMapper.js

@@ -0,0 +1,159 @@
+// API Gateway Lambda Compat
+// License: MIT
+// Source: https://github.com/serverless-nextjs/serverless-next.js/blob/master/packages/compat-layers/apigw-lambda-compat/lib/compatLayer.js
+
+const Stream = require("stream");
+const queryString = require("querystring");
+const http = require("http");
+
+const reqResMapper = (event, callback) => {
+  const base64Support = process.env.BINARY_SUPPORT === "yes";
+  const response = {
+    isBase64Encoded: base64Support,
+    multiValueHeaders: {},
+  };
+  let responsePromise;
+
+  const newStream = new Stream.Readable();
+  const req = Object.assign(newStream, http.IncomingMessage.prototype);
+  req.url =
+    (event.requestContext.path || event.path || "").replace(
+      new RegExp("^/" + event.requestContext.stage),
+      ""
+    ) || "/";
+
+  let qs = "";
+
+  if (event.multiValueQueryStringParameters) {
+    qs += queryString.stringify(event.multiValueQueryStringParameters);
+  }
+
+  if (event.pathParameters) {
+    const pathParametersQs = queryString.stringify(event.pathParameters);
+
+    if (qs.length > 0) {
+      qs += `&${pathParametersQs}`;
+    } else {
+      qs += pathParametersQs;
+    }
+  }
+
+  const hasQueryString = qs.length > 0;
+
+  if (hasQueryString) {
+    req.url += `?${qs}`;
+  }
+
+  req.method = event.httpMethod;
+  req.rawHeaders = [];
+  req.headers = {};
+
+  const headers = event.multiValueHeaders || {};
+
+  for (const key of Object.keys(headers)) {
+    for (const value of headers[key]) {
+      req.rawHeaders.push(key);
+      req.rawHeaders.push(value);
+    }
+    req.headers[key.toLowerCase()] = headers[key].toString();
+  }
+
+  req.getHeader = (name) => {
+    return req.headers[name.toLowerCase()];
+  };
+  req.getHeaders = () => {
+    return req.headers;
+  };
+
+  req.connection = {};
+
+  const res = new Stream();
+  Object.defineProperty(res, "statusCode", {
+    get() {
+      return response.statusCode;
+    },
+    set(statusCode) {
+      response.statusCode = statusCode;
+    },
+  });
+  res.headers = {};
+  res.writeHead = (status, headers) => {
+    response.statusCode = status;
+    if (headers) res.headers = Object.assign(res.headers, headers);
+  };
+  res.write = (chunk) => {
+    if (!response.body) {
+      response.body = Buffer.from("");
+    }
+
+    response.body = Buffer.concat([
+      Buffer.isBuffer(response.body)
+        ? response.body
+        : Buffer.from(response.body),
+      Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk),
+    ]);
+  };
+  res.setHeader = (name, value) => {
+    res.headers[name.toLowerCase()] = value;
+  };
+  res.removeHeader = (name) => {
+    delete res.headers[name.toLowerCase()];
+  };
+  res.getHeader = (name) => {
+    return res.headers[name.toLowerCase()];
+  };
+  res.getHeaders = () => {
+    return res.headers;
+  };
+  res.hasHeader = (name) => {
+    return !!res.getHeader(name);
+  };
+
+  const onResEnd = (callback, resolve) => (text) => {
+    if (text) res.write(text);
+    if (!res.statusCode) {
+      res.statusCode = 200;
+    }
+
+    if (response.body) {
+      response.body = Buffer.from(response.body).toString(
+        base64Support ? "base64" : undefined
+      );
+    }
+    response.multiValueHeaders = res.headers;
+    res.writeHead(response.statusCode);
+    fixApiGatewayMultipleHeaders();
+
+    if (callback) {
+      callback(null, response);
+    } else {
+      resolve(response);
+    }
+  };
+
+  if (typeof callback === "function") {
+    res.end = onResEnd(callback);
+  } else {
+    responsePromise = new Promise((resolve) => {
+      res.end = onResEnd(null, resolve);
+    });
+  }
+
+  if (event.body) {
+    req.push(event.body, event.isBase64Encoded ? "base64" : undefined);
+  }
+
+  req.push(null);
+
+  function fixApiGatewayMultipleHeaders() {
+    for (const key of Object.keys(response.multiValueHeaders)) {
+      if (!Array.isArray(response.multiValueHeaders[key])) {
+        response.multiValueHeaders[key] = [response.multiValueHeaders[key]];
+      }
+    }
+  }
+
+  return { req, res, responsePromise };
+};
+
+module.exports = reqResMapper;

package-lock.json

@@ -52,8 +52,7 @@
   "dependencies": {
     "@sls-next/lambda-at-edge": "^1.5.2",
     "commander": "^6.0.0",
-    "fs-extra": "^9.0.1",
-    "next-aws-lambda": "^2.5.0"
+    "fs-extra": "^9.0.1"
   },
   "husky": {
     "hooks": {