Merge pull request #207 from enter-at/feat/request-timeout-error

Request timeout error

Author: Martin Pirkl

package-lock.json

@@ -0,0 +1,5 @@
+import {LambdaHandlerError} from './LambdaHandlerError';
+
+export class RequestTimeoutError extends LambdaHandlerError {
+    public readonly name = 'RequestTimeoutError';
+}

src/error/RequestTimeoutError.ts

@@ -5,3 +5,4 @@ export {InternalServerError} from './InternalServerError';
 export {NotFoundError} from './NotFoundError';
 export {FormatError} from './FormatError';
 export {ValidationError} from './ValidationError';
+export {RequestTimeoutError} from './RequestTimeoutError';

src/error/index.ts

@@ -0,0 +1,88 @@
+import { APIGatewayProxyHandler } from "./APIGatewayProxyHandler";
+import { APIGatewayProxyEvent, Handler, APIGatewayProxyResult, Context } from "aws-lambda";
+import {
+    RequestTimeoutError,
+    InternalServerError,
+    NotFoundError,
+    ValidationError,
+    FormatError,
+    ForbiddenError,
+    BadRequestError,
+} from "../error";
+import * as ContextFactory from "../../test/fixtures/ContextFactory";
+import * as APIGatewayProxyEventFactory from "../../test/fixtures/APIGatewayProxyEventFactory";
+
+describe(APIGatewayProxyHandler.name, () => {
+    let handler: APIGatewayProxyHandler;
+    let context: Context;
+    let event: APIGatewayProxyEvent;
+
+    beforeEach(() => {
+        handler = new APIGatewayProxyHandler();
+        context = ContextFactory.factory();
+        event = APIGatewayProxyEventFactory.factory();
+    });
+
+    it("handles BadRequestError response correctly", async () => {
+        const fn = handler.wrapper(() => {
+            throw new BadRequestError("BadRequestError message");
+        }) as Handler<APIGatewayProxyEvent, APIGatewayProxyResult>;
+
+        const result = await fn(event, context, () => {});
+        expect(result).toMatchSnapshot();
+    });
+
+    it("handles ForbiddenError response correctly", async () => {
+        const fn = handler.wrapper(() => {
+            throw new ForbiddenError("ForbiddenError message");
+        }) as Handler<APIGatewayProxyEvent, APIGatewayProxyResult>;
+
+        const result = await fn(event, context, () => {});
+        expect(result).toMatchSnapshot();
+    });
+
+    it("handles FormatError response correctly", async () => {
+        const fn = handler.wrapper(() => {
+            throw new FormatError("FormatError message");
+        }) as Handler<APIGatewayProxyEvent, APIGatewayProxyResult>;
+
+        const result = await fn(event, context, () => {});
+        expect(result).toMatchSnapshot();
+    });
+
+    it("handles InternalServerError response correctly", async () => {
+        const fn = handler.wrapper(() => {
+            throw new InternalServerError("InternalServerError message");
+        }) as Handler<APIGatewayProxyEvent, APIGatewayProxyResult>;
+
+        const result = await fn(event, context, () => {});
+        expect(result).toMatchSnapshot();
+    });
+
+    it("handles NotFoundError response correctly", async () => {
+        const fn = handler.wrapper(() => {
+            throw new NotFoundError("NotFoundError message");
+        }) as Handler<APIGatewayProxyEvent, APIGatewayProxyResult>;
+
+        const result = await fn(event, context, () => {});
+        expect(result).toMatchSnapshot();
+    });
+
+    it("handles RequestTimeoutError response correctly", async () => {
+        const fn = handler.wrapper(() => {
+            throw new RequestTimeoutError("RequestTimeoutError message");
+        }) as Handler<APIGatewayProxyEvent, APIGatewayProxyResult>;
+
+        const result = await fn(event, context, () => {});
+        expect(result).toMatchSnapshot();
+    });
+
+    it("handles ValidationError response correctly", async () => {
+        const fn = handler.wrapper(() => {
+            throw new ValidationError("ValidationError message");
+        }) as Handler<APIGatewayProxyEvent, APIGatewayProxyResult>;
+
+        const result = await fn(event, context, () => {});
+        expect(result).toMatchSnapshot();
+    });
+});

src/handler/APIGatewayProxyHandler.spec.ts

@@ -1,22 +1,36 @@
-import {APIGatewayProxyEvent, APIGatewayProxyResult} from 'aws-lambda';
-import {BadRequestError, FormatError, NotFoundError, ValidationError} from '../error';
-import {ContentTypeHeader, CORSHeader, IHeader, IHeaders} from '../header';
-import {badRequest, IAPIGatewayResponse, internalServerError, noContent, notFound, ok} from '../response';
-import {BaseHandler, IBaseHandlerArguments} from './BaseHandler';
+import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
+import { BadRequestError, FormatError, NotFoundError, ValidationError, RequestTimeoutError, ForbiddenError } from '../error';
+import { ContentTypeHeader, CORSHeader, IHeader, IHeaders } from '../header';
+import {
+    badRequest,
+    IAPIGatewayResponse,
+    internalServerError,
+    noContent,
+    notFound,
+    ok,
+    requestTimeout,
+    forbidden,
+} from '../response';
+import { BaseHandler, IBaseHandlerArguments } from './BaseHandler';
 
 export interface IAPIGatewayProxyHandlerArguments extends IBaseHandlerArguments {
     cors?: CORSHeader;
 }
 
 export class APIGatewayProxyHandler extends BaseHandler {
-
     private static handleError(err: Error): IAPIGatewayResponse {
         if (err instanceof NotFoundError) {
             return notFound(err.details);
         }
         if (err instanceof BadRequestError || err instanceof FormatError || err instanceof ValidationError) {
             return badRequest(err.details);
         }
+        if (err instanceof RequestTimeoutError) {
+            return requestTimeout(err.details);
+        }
+        if (err instanceof ForbiddenError) {
+            return forbidden(err.details);
+        }
         return internalServerError();
     }
 
@@ -50,7 +64,7 @@ export class APIGatewayProxyHandler extends BaseHandler {
             return event;
         } catch (err) {
             if (err instanceof FormatError) {
-                throw new FormatError([{body: [err.details]}]);
+                throw new FormatError([{ body: [err.details] }]);
             }
             throw err;
         }

src/handler/APIGatewayProxyHandler.ts

@@ -0,0 +1,85 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`APIGatewayProxyHandler handles BadRequestError response correctly 1`] = `
+Object {
+  "body": "{\\"errors\\":[{\\"name\\":\\"BadRequestError\\",\\"details\\":\\"BadRequestError message\\"}]}",
+  "headers": Object {
+    "Access-Control-Allow-Credentials": true,
+    "Access-Control-Allow-Origin": "*",
+    "Content-Type": "application/json",
+  },
+  "statusCode": 400,
+}
+`;
+
+exports[`APIGatewayProxyHandler handles ForbiddenError response correctly 1`] = `
+Object {
+  "body": "{\\"errors\\":[{\\"name\\":\\"ForbiddenError\\",\\"details\\":\\"ForbiddenError message\\"}]}",
+  "headers": Object {
+    "Access-Control-Allow-Credentials": true,
+    "Access-Control-Allow-Origin": "*",
+    "Content-Type": "application/json",
+  },
+  "statusCode": 403,
+}
+`;
+
+exports[`APIGatewayProxyHandler handles FormatError response correctly 1`] = `
+Object {
+  "body": "{\\"errors\\":[{\\"name\\":\\"BadRequestError\\",\\"details\\":\\"FormatError message\\"}]}",
+  "headers": Object {
+    "Access-Control-Allow-Credentials": true,
+    "Access-Control-Allow-Origin": "*",
+    "Content-Type": "application/json",
+  },
+  "statusCode": 400,
+}
+`;
+
+exports[`APIGatewayProxyHandler handles InternalServerError response correctly 1`] = `
+Object {
+  "body": "{\\"errors\\":[{\\"name\\":\\"InternalServerError\\",\\"details\\":\\"InternalServerError\\"}]}",
+  "headers": Object {
+    "Access-Control-Allow-Credentials": true,
+    "Access-Control-Allow-Origin": "*",
+    "Content-Type": "application/json",
+  },
+  "statusCode": 500,
+}
+`;
+
+exports[`APIGatewayProxyHandler handles NotFoundError response correctly 1`] = `
+Object {
+  "body": "{\\"errors\\":[{\\"name\\":\\"NotFoundError\\",\\"details\\":\\"NotFoundError message\\"}]}",
+  "headers": Object {
+    "Access-Control-Allow-Credentials": true,
+    "Access-Control-Allow-Origin": "*",
+    "Content-Type": "application/json",
+  },
+  "statusCode": 404,
+}
+`;
+
+exports[`APIGatewayProxyHandler handles RequestTimeoutError response correctly 1`] = `
+Object {
+  "body": "{\\"errors\\":[{\\"name\\":\\"RequestTimeoutError\\",\\"details\\":\\"RequestTimeoutError message\\"}]}",
+  "headers": Object {
+    "Access-Control-Allow-Credentials": true,
+    "Access-Control-Allow-Origin": "*",
+    "Content-Type": "application/json",
+  },
+  "statusCode": 408,
+}
+`;
+
+exports[`APIGatewayProxyHandler handles ValidationError response correctly 1`] = `
+Object {
+  "body": "{\\"errors\\":[{\\"name\\":\\"BadRequestError\\",\\"details\\":\\"ValidationError message\\"}]}",
+  "headers": Object {
+    "Access-Control-Allow-Credentials": true,
+    "Access-Control-Allow-Origin": "*",
+    "Content-Type": "application/json",
+  },
+  "statusCode": 400,
+}
+`;

src/handler/__snapshots__/APIGatewayProxyHandler.spec.ts.snap

@@ -1,6 +1,6 @@
 import {APIGatewayProxyResult} from 'aws-lambda';
 import * as httpStatusCode from 'http-status-codes';
-import {BadRequestError, ForbiddenError, InternalServerError, LambdaHandlerError, NotFoundError} from './error';
+import {BadRequestError, ForbiddenError, InternalServerError, LambdaHandlerError, NotFoundError, RequestTimeoutError} from './error';
 
 export interface IAPIGatewayResponse extends APIGatewayProxyResult {
     body: any | undefined;
@@ -31,6 +31,11 @@ export function notFound(details: string | undefined): IAPIGatewayResponse {
     return buildResult<NotFoundError>(error, httpStatusCode.NOT_FOUND);
 }
 
+export function requestTimeout(details: string | undefined): IAPIGatewayResponse {
+    const error: RequestTimeoutError = new RequestTimeoutError(details);
+    return buildResult<RequestTimeoutError>(error, httpStatusCode.REQUEST_TIMEOUT);
+}
+
 export function ok<T>(result: T): IAPIGatewayResponse {
     return buildResult<T>(result, httpStatusCode.OK);
 }