next-aws-lambda can now be consumed using async signature (#131)

* feat: compat layer can now be consumed using async signature

Author: danielcondemarin

packages/next-aws-lambda/README.md

@@ -8,7 +8,16 @@ Compat layer between next.js serverless page and AWS Lambda.
 const compat = require("next-aws-lambda");
 const page = require(".next/serverless/pages/somePage.js");
 
+// using callback
+
 module.exports.render = (event, context, callback) => {
   compat(page)(event, context, callback);
 };
+
+// using async promise
+
+module.exports.render = async (event, context, callback) => {
+  const responsePromise = compat(page)(event, context); // don't pass the callback parameter
+  return responsePromise;
+};
 ```

packages/next-aws-lambda/__tests__/index.test.js

@@ -30,9 +30,7 @@ describe("next-aws-lambda", () => {
     expect(mockRender).toBeCalledWith(req, res);
     expect(mockDefault).not.toBeCalled();
   });
-});
 
-describe("next-aws-lambda", () => {
   it("passes request and response to next api", () => {
     const event = { foo: "bar" };
     const callback = () => {};
@@ -56,4 +54,26 @@ describe("next-aws-lambda", () => {
 
     expect(mockDefault).toBeCalledWith(req, res);
   });
+
+  it("supports async signature", () => {
+    expect.assertions(1);
+
+    const event = { foo: "bar" };
+    const context = {};
+    const page = {
+      render: () => {}
+    };
+    const response = {
+      statusCode: 200
+    };
+    compatLayer.mockReturnValue({
+      responsePromise: Promise.resolve(response)
+    });
+
+    const responsePromise = compat(page)(event, context);
+
+    return responsePromise.then(result => {
+      expect(result).toEqual(response);
+    });
+  });
 });

packages/next-aws-lambda/index.js

@@ -1,14 +1,18 @@
 const reqResMapper = require("./lib/compatLayer");
 
 const handlerFactory = page => (event, _context, callback) => {
-  const { req, res } = reqResMapper(event, 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;

packages/next-aws-lambda/lib/__tests__/compatLayer.response.test.js

@@ -20,6 +20,24 @@ describe("compatLayer.response", () => {
     res.end();
   });
 
+  it("[Promise] statusCode writeHead 404", async () => {
+    expect.assertions(1);
+
+    const { res, responsePromise } = create({
+      requestContext: {
+        path: "/"
+      },
+      headers: {}
+    });
+
+    res.writeHead(404);
+    res.end();
+
+    return responsePromise.then(response => {
+      expect(response.statusCode).toEqual(404);
+    });
+  });
+
   it("statusCode statusCode=200", done => {
     const { res } = create(
       {
@@ -38,6 +56,24 @@ describe("compatLayer.response", () => {
     res.end();
   });
 
+  it("[Promise] statusCode statusCode=200", () => {
+    expect.assertions(1);
+
+    const { res, responsePromise } = create({
+      requestContext: {
+        path: "/"
+      },
+      headers: {}
+    });
+
+    res.statusCode = 200;
+    res.end();
+
+    return responsePromise.then(response => {
+      expect(response.statusCode).toEqual(200);
+    });
+  });
+
   it("writeHead headers", done => {
     const { res } = create(
       {
@@ -62,6 +98,30 @@ describe("compatLayer.response", () => {
     res.end();
   });
 
+  it("[Promise] writeHead headers", () => {
+    expect.assertions(1);
+
+    const { res, responsePromise } = create({
+      requestContext: {
+        path: "/"
+      },
+      headers: {}
+    });
+
+    res.writeHead(200, {
+      "x-custom-1": "1",
+      "x-custom-2": "2"
+    });
+    res.end();
+
+    return responsePromise.then(response => {
+      expect(response.multiValueHeaders).toEqual({
+        "x-custom-1": ["1"],
+        "x-custom-2": ["2"]
+      });
+    });
+  });
+
   it("setHeader", done => {
     const { res } = create(
       {
@@ -84,6 +144,28 @@ describe("compatLayer.response", () => {
     res.end();
   });
 
+  it("[Promise] setHeader", () => {
+    expect.assertions(1);
+
+    const { res, responsePromise } = create({
+      requestContext: {
+        path: "/"
+      },
+      headers: {}
+    });
+
+    res.setHeader("x-custom-1", "1");
+    res.setHeader("x-custom-2", "2");
+    res.end();
+
+    return responsePromise.then(response => {
+      expect(response.multiValueHeaders).toEqual({
+        "x-custom-1": ["1"],
+        "x-custom-2": ["2"]
+      });
+    });
+  });
+
   it("multi header support for api gateway", done => {
     const { res } = create(
       {
@@ -104,6 +186,25 @@ describe("compatLayer.response", () => {
     res.end();
   });
 
+  it("[Promise] multi header support for api gateway", () => {
+    expect.assertions(1);
+
+    const { res, responsePromise } = create({
+      requestContext: {
+        path: "/"
+      },
+      headers: {}
+    });
+    res.setHeader("x-custom-1", ["1", "1"]);
+    res.end();
+
+    return responsePromise.then(response => {
+      expect(response.multiValueHeaders).toEqual({
+        "x-custom-1": ["1", "1"]
+      });
+    });
+  });
+
   it("setHeader + removeHeader", done => {
     const { res } = create(
       {
@@ -126,6 +227,27 @@ describe("compatLayer.response", () => {
     res.end();
   });
 
+  it("[Promise] setHeader + removeHeader", () => {
+    expect.assertions(1);
+
+    const { res, responsePromise } = create({
+      requestContext: {
+        path: "/"
+      },
+      headers: {}
+    });
+    res.setHeader("x-custom-1", "1");
+    res.setHeader("x-custom-2", "2");
+    res.removeHeader("x-custom-1");
+    res.end();
+
+    return responsePromise.then(response => {
+      expect(response.multiValueHeaders).toEqual({
+        "x-custom-2": ["2"]
+      });
+    });
+  });
+
   it("getHeader/s", () => {
     const { res } = create({
       requestContext: {
@@ -162,6 +284,24 @@ describe("compatLayer.response", () => {
     res.end();
   });
 
+  it(`[Promise] res.write('ok')`, () => {
+    expect.assertions(2);
+
+    const { res, responsePromise } = create({
+      requestContext: {
+        path: "/"
+      },
+      headers: {}
+    });
+    res.write("ok");
+    res.end();
+
+    return responsePromise.then(response => {
+      expect(response.isBase64Encoded).toEqual(false);
+      expect(response.body).toEqual("ok");
+    });
+  });
+
   it(`res.end('ok')`, done => {
     const { res } = create(
       {
@@ -180,6 +320,23 @@ describe("compatLayer.response", () => {
     res.end("ok");
   });
 
+  it(`[Promise] res.end('ok')`, () => {
+    expect.assertions(2);
+
+    const { res, responsePromise } = create({
+      requestContext: {
+        path: "/"
+      },
+      headers: {}
+    });
+    res.end("ok");
+
+    return responsePromise.then(response => {
+      expect(response.isBase64Encoded).toEqual(false);
+      expect(response.body).toEqual("ok");
+    });
+  });
+
   it("req.pipe(res)", done => {
     const { req, res } = create(
       {
@@ -199,6 +356,24 @@ describe("compatLayer.response", () => {
     res.end("ok");
   });
 
+  it("[Promise] req.pipe(res)", () => {
+    expect.assertions(2);
+
+    const { res, responsePromise } = create({
+      requestContext: {
+        path: "/"
+      },
+      headers: {}
+    });
+
+    res.end("ok");
+
+    return responsePromise.then(response => {
+      expect(response.isBase64Encoded).toEqual(false);
+      expect(response.body).toEqual("ok");
+    });
+  });
+
   it("base64 support", done => {
     process.env.BINARY_SUPPORT = "yes";
     const { res } = create(
@@ -217,4 +392,23 @@ describe("compatLayer.response", () => {
     );
     res.end("ok");
   });
+
+  it("[Promise] base64 support", () => {
+    expect.assertions(2);
+
+    process.env.BINARY_SUPPORT = "yes";
+    const { res, responsePromise } = create({
+      requestContext: {
+        path: "/"
+      },
+      headers: {}
+    });
+
+    res.end("ok");
+
+    return responsePromise.then(response => {
+      expect(response.body).toEqual(Buffer.from("ok").toString("base64"));
+      expect(response.isBase64Encoded).toEqual(true);
+    });
+  });
 });

packages/next-aws-lambda/lib/compatLayer.js

@@ -9,6 +9,7 @@ const reqResMapper = (event, callback) => {
     statusCode: 200,
     multiValueHeaders: {}
   };
+  let responsePromise;
 
   const req = new Stream.Readable();
   req.url = (event.requestContext.path || event.path || "").replace(
@@ -93,19 +94,35 @@ const reqResMapper = (event, callback) => {
   res.getHeaders = () => {
     return res.headers;
   };
-  res.end = text => {
+
+  const onResEnd = (callback, resolve) => text => {
     if (text) res.write(text);
     response.body = Buffer.from(response.body).toString(
       base64Support ? "base64" : undefined
     );
     response.multiValueHeaders = res.headers;
     res.writeHead(response.statusCode);
     fixApiGatewayMultipleHeaders();
-    callback(null, response);
+
+    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() {
@@ -116,7 +133,7 @@ const reqResMapper = (event, callback) => {
     }
   }
 
-  return { req, res };
+  return { req, res, responsePromise };
 };
 
 module.exports = reqResMapper;