feat: Better TypeScript support

Also using Promise instad of callback in main handler

Author: muratcorlu

README.md

@@ -61,7 +61,26 @@ const getUser = (req, res) => {
 exports.handler = use(checkUser, getUser);
 ```
 
-You can use many popular Express Middlewares. Some examples are:
+TypeScript example:
+
+```ts
+import { use, Request, Response } from 'lambda-expressless';
+import * as bodyParser from "body-parser";
+
+const addUser = (req: Request, res: Response, next: Function) => {
+  UserService.add(req.body);
+
+  // add user
+  res.json({success: true});
+};
+
+export const handler = use(
+  bodyParser.json(),
+  addUser
+);
+```
+
+You can use many popular Express Middlewares. Some tested examples are:
 
 - [body-parser](https://github.com/expressjs/body-parser)
 

package-lock.json

@@ -20,12 +20,14 @@
   },
   "homepage": "https://github.com/muratcorlu/lambda-expressless#readme",
   "devDependencies": {
+    "@types/accepts": "^1.3.5",
+    "@types/aws-lambda": "^8.10.33",
+    "@types/connect": "^3.4.33",
     "body-parser": "^1.19.0",
     "jest": "^24.9.0",
     "semantic-release": "^15.13.21"
   },
   "dependencies": {
-    "@types/aws-lambda": "^8.10.33",
     "accepts": "^1.3.7",
     "type-is": "^1.6.18"
   }

package.json

@@ -1,12 +1,14 @@
 import { Request } from './request';
 import { Response } from './response';
 import { APIGatewayProxyHandler } from 'aws-lambda';
+import { NextFunction, NextHandleFunction } from "connect";
 
-export interface Middleware {
-    (request: Request, response: Response, next: Function): void
+
+export interface Middleware extends NextHandleFunction {
+    (request: Request, response: Response, next: NextFunction): void
 }
 
-export function use(...handlers: Middleware[]): ApiGatewayProxyHandler;
+export function use(...handlers: Middleware[]): APIGatewayProxyHandler;
 
 export { Request } from './request';
 export { Response } from './response';

src/lambda-wrapper.d.ts

@@ -1,21 +1,33 @@
 const { Response } = require('./response');
 const { Request } = require('./request');
 
+const promisify = (handler, req, res) => new Promise((resolve, reject) => {
+  try {
+    handler(req, res, resolve);
+  } catch (error) {
+    reject(error);
+  }
+});
+
 exports.use = (...handlers) => {
-  return (event, context, callback) => {
+  return (event, context) => {
     context.callbackWaitsForEmptyEventLoop = false;
 
     const request = new Request(event);
-    const response = new Response(request, callback);
+    const response = new Response(request);
+
     request.res = response;
 
-    handlers = [].concat(...handlers);
+    return new Promise((resolve, reject) => {
+
+      response.promise.then(resolve, reject);
 
-    handlers.reduce((chain, handler) => chain.then(
-      () => new Promise((resolve) => {
-        request.next = resolve;
-        return handler(request, response, resolve);
-      })
-    ).catch(callback), Promise.resolve());
+      [].concat(...handlers).reduce(
+        (queue, handler) =>
+          queue.then(() => promisify(handler, request, response)
+        ),
+        Promise.resolve()
+      ).catch(reject);
+    });
   }
 }

src/lambda-wrapper.js

@@ -2,123 +2,117 @@ const { use } = require('./lambda-wrapper');
 const bodyParser = require('body-parser');
 
 describe('Lambda Wrapper', () => {
-  const proxyRequest = {
-    body: null,
-    headers: {},
-    multiValueHeaders: {},
-    httpMethod: 'POST',
-    isBase64Encoded: false,
-    path: '/path',
-    pathParameters: { },
-    queryStringParameters: { },
-    multiValueQueryStringParameters: { },
-    stageVariables: { },
-    requestContext: {},
-    resource: ''
-  };
+  let proxyRequest;
+  beforeEach(() => {
+    proxyRequest = {
+      body: null,
+      headers: {},
+      multiValueHeaders: {},
+      httpMethod: 'POST',
+      isBase64Encoded: false,
+      path: '/path',
+      pathParameters: {},
+      queryStringParameters: {},
+      multiValueQueryStringParameters: {},
+      stageVariables: {},
+      requestContext: {},
+      resource: ''
+    };
+  });
 
   it('should send json output properly', async () => {
 
     const lambdaHandler = use((req, res) => {
-      res.json({a: 1});
+      res.json({ a: 1 });
     });
 
-    const proxyRequest = {
+    proxyRequest = {
       body: '',
       headers: {},
       multiValueHeaders: {},
       httpMethod: 'GET',
       isBase64Encoded: false,
       path: '/path',
-      pathParameters: { },
-      queryStringParameters: { },
-      multiValueQueryStringParameters: { },
-      stageVariables: { },
+      pathParameters: {},
+      queryStringParameters: {},
+      multiValueQueryStringParameters: {},
+      stageVariables: {},
       requestContext: {},
       resource: ''
     };
-    const callback = (err, payload) => {
-      expect(err).toBe(null);
-      expect(payload).toEqual({
-        statusCode: 200,
-        headers: {
-          'content-type': 'application/json'
-        },
-        body: '{"a":1}'
-      });
-    };
 
-    await lambdaHandler(proxyRequest, {}, callback);
+    const payload = await lambdaHandler(proxyRequest, {});
+    expect(payload).toEqual({
+      statusCode: 200,
+      headers: {
+        'content-type': 'application/json'
+      },
+      body: '{"a":1}'
+    });
 
   });
 
 
-  it('should handle json body on a post request', () => {
+  it('should handle json body on a post request', async () => {
 
     const lambdaHandler = use(bodyParser.json(), (req, res) => {
       res.json(req.body);
     });
 
-    const requestObject = JSON.stringify({a: 1});
+    const requestObject = JSON.stringify({ a: 1 });
 
-    const proxyRequest = {
+    proxyRequest = {
       body: requestObject,
       headers: {
         'Content-Type': 'application/json',
         'Content-Length': requestObject.length
       },
       multiValueHeaders: {
-        'Content-Type': [ 'application/json' ],
-        'Content-Length': [ requestObject.length ]
+        'Content-Type': ['application/json'],
+        'Content-Length': [requestObject.length]
       },
       httpMethod: 'POST',
       isBase64Encoded: false,
       path: '/path',
-      pathParameters: { },
-      queryStringParameters: { },
-      multiValueQueryStringParameters: { },
-      stageVariables: { },
+      pathParameters: {},
+      queryStringParameters: {},
+      multiValueQueryStringParameters: {},
+      stageVariables: {},
       requestContext: {},
       resource: ''
     };
-    const callback = (err, payload) => {
-      expect(err).toBe(null);
-      expect(payload).toEqual({
-        statusCode: 200,
-        headers: {
-          'content-type': 'application/json'
-        },
-        body: requestObject
-      });
-    }
-
-    lambdaHandler(proxyRequest, {}, callback);
 
+    const payload = await lambdaHandler(proxyRequest, {});
+
+    expect(payload).toEqual({
+      statusCode: 200,
+      headers: {
+        'content-type': 'application/json'
+      },
+      body: requestObject
+    });
   });
 
-  it('should run multiple middlewares', () => {
+  it('should run multiple middlewares', async () => {
     const lambdaHandler = use((req, res, next) => {
       req.params.fromFirstEndpoint = '1';
       next();
     }, (req, res) => {
-      res.json({b: req.params.fromFirstEndpoint});
+      res.json({ b: req.params.fromFirstEndpoint });
     });
 
-    const callback = (err, payload) => {
-      expect(err).toBe(null);
-      expect(payload).toEqual({
-        statusCode: 200,
-        headers: {
-          'content-type': 'application/json'
-        },
-        body: JSON.stringify({"b":"1"})
-      });
-    }
-
-    lambdaHandler(proxyRequest, {}, callback);
+    const payload = await lambdaHandler(proxyRequest, {});
+
+    expect(payload).toEqual({
+      statusCode: 200,
+      headers: {
+        'content-type': 'application/json'
+      },
+      body: JSON.stringify({ "b": "1" })
+    });
   });
 
-  it('should run multiple middlewares as arrays', () => {
+  it('should run multiple middlewares as arrays', async () => {
     const lambdaHandler = use([(req, res, next) => {
       req.params.fromFirstEndpoint = '1';
       next();
@@ -132,32 +126,28 @@ describe('Lambda Wrapper', () => {
       })
     });
 
-    const callback = (err, payload) => {
-      expect(err).toBe(null);
-      expect(payload).toEqual({
-        statusCode: 200,
-        headers: {
-          'content-type': 'application/json'
-        },
-        body: JSON.stringify({
-          fromFirstEndpoint: '1',
-          fromSecondEndpoint: '1',
-        })
-      });
-    }
-
-    lambdaHandler(proxyRequest, {}, callback);
+    const payload = await lambdaHandler(proxyRequest, {});
+
+    expect(payload).toEqual({
+      statusCode: 200,
+      headers: {
+        'content-type': 'application/json'
+      },
+      body: JSON.stringify({
+        fromFirstEndpoint: '1',
+        fromSecondEndpoint: '1',
+      })
+    });
   });
 
-  it('should handle errors', () => {
+  it('should handle errors', async () => {
+    expect.assertions(1);
+
     const lambdaHandler = use((req, res, next) => {
-      throw Error('test');
+      throw new Error('test');
     });
 
-    const callback = (err, payload) => {
-      expect(err).toStrictEqual(Error('test'));
-    }
+    await expect(lambdaHandler(proxyRequest, {})).rejects.toThrow(Error);
 
-    lambdaHandler(proxyRequest, {}, callback);
-  })
+  });
 });

src/lambda-wrapper.spec.js

@@ -2,8 +2,9 @@
 import { APIGatewayProxyEvent } from 'aws-lambda';
 import { Accepts } from 'accepts';
 import { Readable } from 'stream';
+import { IncomingMessage } from 'http';
 
-export class Request extends Readable {
+export interface Request extends IncomingMessage {
     constructor(event: APIGatewayProxyEvent);
     headers: { [name: string]: string };
     hostname: string | null;

src/request.d.ts

@@ -41,6 +41,8 @@ class Request extends ReadableStream {
     this.host = this.get('X-Forwarded-Host') || this.hostname;
     this.xhr = (this.get('X-Requested-With') || '').toLowerCase() === 'xmlhttprequest';
 
+    this.url = `${this.headers}${this.path}`;
+
     this.event = event;
     this.accept = accepts(this);