try new approach to callback wrapping

Author: manwaring

package-lock.json

@@ -1,7 +1,7 @@
 {
   "name": "@manwaring/lambda-wrapper",
   "description": "A lambda handler wrapper to abstract common functionality and provide useful defaults",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "scripts": {
     "publish-please-dry-run": "publish-please --dry-run",
     "publish-please": "publish-please",

package.json

@@ -1,46 +1,55 @@
-import createEvent from '@serverless/event-mocks';
-import { success, error, invalid, redirect } from './responses';
+import { Responses } from './responses';
+import { Metrics } from '../common';
 
 describe('API responses', () => {
-  // @ts-ignore
-  const event = createEvent('aws:apiGateway', {});
+  const metrics = new Metrics('API Gateway');
+  const callback = jest.fn((err, result) => (err ? new Error(err) : result));
+  const responses = new Responses(metrics, callback);
+
+  beforeEach(() => jest.resetAllMocks());
 
   it('Handles success response', () => {
-    expect(success('success')).toEqual({
+    responses.success('success');
+    expect(callback).toHaveBeenCalledWith(null, {
       body: JSON.stringify('success'),
       headers: { 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Credentials': true },
       statusCode: 200
     });
   });
 
   it('Handles success response without payload', () => {
-    expect(success()).toEqual({
+    responses.success();
+    expect(callback).toHaveBeenCalledWith(null, {
       headers: { 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Credentials': true },
       statusCode: 200
     });
   });
 
   it('Handles error response', () => {
-    expect(() => error('error')).toThrow('error');
+    responses.error('error');
+    expect(callback).toHaveBeenCalledWith(new Error('error'));
   });
 
   it('Handles invalid response', () => {
-    expect(invalid(['invalid'])).toEqual({
+    responses.invalid(['invalid']);
+    expect(callback).toHaveBeenCalledWith(null, {
       body: JSON.stringify({ errors: ['invalid'] }),
       headers: { 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Credentials': true },
       statusCode: 400
     });
   });
 
   it('Handles invalid response without validation errors', () => {
-    expect(invalid()).toEqual({
+    responses.invalid();
+    expect(callback).toHaveBeenCalledWith(null, {
       headers: { 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Credentials': true },
       statusCode: 400
     });
   });
 
   it('Handles redirect response', () => {
-    expect(redirect('url')).toEqual({
+    responses.redirect('url');
+    expect(callback).toHaveBeenCalledWith(null, {
       headers: { 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Credentials': true, Location: 'url' },
       statusCode: 302
     });

src/api/responses.test.ts

@@ -1,38 +1,41 @@
+import { Callback } from 'aws-lambda';
 import { Metrics } from '../common';
 
-const metrics = new Metrics('API Gateway');
-
 const HEADERS = {
   'Access-Control-Allow-Origin': '*',
   'Access-Control-Allow-Credentials': true
 };
 
-export function success(payload?: any) {
-  const response = { statusCode: 200, headers: HEADERS };
-  if (payload) {
-    response['body'] = JSON.stringify(payload);
+export class Responses {
+  constructor(private metrics: Metrics, private callback: Callback) {}
+
+  success(payload?: any) {
+    const response = { statusCode: 200, headers: HEADERS };
+    if (payload) {
+      response['body'] = JSON.stringify(payload);
+    }
+    this.metrics.success(payload);
+    this.callback(null, response);
   }
-  metrics.success(payload);
-  return response;
-}
 
-export function invalid(errors?: string[]) {
-  const response = { statusCode: 400, headers: HEADERS };
-  if (errors) {
-    response['body'] = JSON.stringify({ errors });
+  invalid(errors?: string[]) {
+    const response = { statusCode: 400, headers: HEADERS };
+    if (errors) {
+      response['body'] = JSON.stringify({ errors });
+    }
+    this.metrics.invalid(response);
+    this.callback(null, response);
   }
-  metrics.invalid(response);
-  return response;
-}
 
-export function redirect(url: string) {
-  HEADERS['Location'] = url;
-  const response = { statusCode: 302, headers: HEADERS };
-  metrics.redirect(response);
-  return response;
-}
+  redirect(url: string) {
+    HEADERS['Location'] = url;
+    const response = { statusCode: 302, headers: HEADERS };
+    this.metrics.redirect(response);
+    this.callback(null, response);
+  }
 
-export function error(error?: any) {
-  metrics.error(error);
-  throw new Error(error);
+  error(error?: any) {
+    this.metrics.error(error);
+    this.callback(new Error(error));
+  }
 }

src/api/responses.ts

@@ -1,9 +1,13 @@
-import { APIGatewayEvent } from 'aws-lambda';
+import { APIGatewayEvent, Context, Callback } from 'aws-lambda';
 import { Request } from './parser';
-import { success, invalid, redirect, error } from './responses';
+import { Metrics } from '../common';
+import { Responses } from './responses';
+
+const metrics = new Metrics('API Gateway');
 
 export function api<T extends Function>(fn: T): T {
-  return <any>function(event: APIGatewayEvent) {
+  return <any>function(event: APIGatewayEvent, context: Context, callback: Callback) {
+    const responses = new Responses(metrics, callback);
     const { body, path, query, auth, headers, testRequest } = new Request(event).getProperties();
 
     const signature: ApiSignature = {
@@ -14,10 +18,10 @@ export function api<T extends Function>(fn: T): T {
       headers,
       testRequest,
       auth,
-      success,
-      invalid,
-      redirect,
-      error
+      success: responses.success,
+      invalid: responses.invalid,
+      redirect: responses.redirect,
+      error: responses.error
     };
     return fn(signature);
   };

src/api/wrapper.ts

@@ -10,7 +10,7 @@ export function cloudFormation<T extends Function>(fn: T): T {
 
     const signature: CloudFormationSignature = {
       event,
-      // We need to call these response wrappers so that we can pass in context (necessary for CloudFormation responses) so that
+      // We need to call these response wrappers so that we can pass in context (necessary for CloudFormation responses) to keep it abstracted from users
       success: successWrapper(event, context),
       failure: failureWrapper(event, context)
     };