update api wrapper responses

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.5",
+  "version": "1.0.6",
   "scripts": {
     "publish-please-dry-run": "publish-please --dry-run",
     "publish-please": "publish-please",

package.json

@@ -1,15 +1,15 @@
-import { Responses } from './responses';
+import { successWrapper, errorWrapper, invalidWrapper, redirectWrapper } from './responses';
 import { Metrics } from '../common';
 
 describe('API responses', () => {
   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', () => {
-    responses.success('success');
+    const success = successWrapper(metrics, callback);
+    success('success');
     expect(callback).toHaveBeenCalledWith(null, {
       body: JSON.stringify('success'),
       headers: { 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Credentials': true },
@@ -18,20 +18,23 @@ describe('API responses', () => {
   });
 
   it('Handles success response without payload', () => {
-    responses.success();
+    const success = successWrapper(metrics, callback);
+    success();
     expect(callback).toHaveBeenCalledWith(null, {
       headers: { 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Credentials': true },
       statusCode: 200
     });
   });
 
   it('Handles error response', () => {
-    responses.error('error');
+    const error = errorWrapper(metrics, callback);
+    error('error');
     expect(callback).toHaveBeenCalledWith(new Error('error'));
   });
 
   it('Handles invalid response', () => {
-    responses.invalid(['invalid']);
+    const invalid = invalidWrapper(metrics, callback);
+    invalid(['invalid']);
     expect(callback).toHaveBeenCalledWith(null, {
       body: JSON.stringify({ errors: ['invalid'] }),
       headers: { 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Credentials': true },
@@ -40,15 +43,17 @@ describe('API responses', () => {
   });
 
   it('Handles invalid response without validation errors', () => {
-    responses.invalid();
+    const invalid = invalidWrapper(metrics, callback);
+    invalid();
     expect(callback).toHaveBeenCalledWith(null, {
       headers: { 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Credentials': true },
       statusCode: 400
     });
   });
 
   it('Handles redirect response', () => {
-    responses.redirect('url');
+    const redirect = redirectWrapper(metrics, callback);
+    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

@@ -6,36 +6,40 @@ const HEADERS = {
   'Access-Control-Allow-Credentials': true
 };
 
-export class Responses {
-  constructor(private metrics: Metrics, private callback: Callback) {}
-
-  success(payload?: any) {
+export function successWrapper(metrics: Metrics, callback: Callback) {
+  return function 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);
+    callback(null, response);
+  };
+}
 
-  invalid(errors?: string[]) {
+export function invalidWrapper(metrics: Metrics, callback: Callback) {
+  return function 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);
+    callback(null, response);
+  };
+}
 
-  redirect(url: string) {
+export function errorWrapper(metrics: Metrics, callback: Callback) {
+  return function error(error?: any) {
+    metrics.error(error);
+    callback(new Error(error));
+  };
+}
+
+export function redirectWrapper(metrics: Metrics, callback: Callback) {
+  return function redirect(url: string) {
     HEADERS['Location'] = url;
     const response = { statusCode: 302, headers: HEADERS };
-    this.metrics.redirect(response);
-    this.callback(null, response);
-  }
-
-  error(error?: any) {
-    this.metrics.error(error);
-    this.callback(new Error(error));
-  }
+    metrics.redirect(response);
+    callback(null, response);
+  };
 }

src/api/responses.ts

@@ -9,6 +9,8 @@ describe('API wrapper', () => {
     queryStringParameters: { name: 'a test' },
     headers: { 'content-type': 'application/json', 'Test-Request': 'true' }
   });
+  const context = {};
+  const callback = jest.fn((err, result) => (err ? new Error(err) : result));
 
   it('Has expected properties and response functions', () => {
     function mockHandler({
@@ -35,7 +37,9 @@ describe('API wrapper', () => {
       expect(invalid).toBeInstanceOf(Function);
       expect(redirect).toBeInstanceOf(Function);
       expect(error).toBeInstanceOf(Function);
+      success('success');
     }
-    api(mockHandler)(requestEvent);
+    // @ts-ignore
+    api(mockHandler)(requestEvent, context, callback);
   });
 });

src/api/wrapper.test.ts

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