feat(errors): add support for http 409 conflict

src/error/ConflictError.ts

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

src/error/index.ts

@@ -8,3 +8,4 @@ export { RequestTimeoutError } from "./RequestTimeoutError";
 export { UnauthorizedError } from "./UnauthorizedError";
 export { ValidationError } from "./ValidationError";
 export { UnprocessableEntityError } from "./UnprocessableEntityError";
+export { ConflictError } from "./ConflictError";

src/handler/APIGatewayProxyHandler.spec.ts

@@ -14,6 +14,7 @@ import { ok, created, noContent } from "../response";
 import * as ContextFactory from "../../test/fixtures/ContextFactory";
 import * as APIGatewayProxyEventFactory from "../../test/fixtures/APIGatewayProxyEventFactory";
 import { UnprocessableEntityError } from "../error/UnprocessableEntityError";
+import { ConflictError } from "../error/ConflictError";
 
 describe(APIGatewayProxyHandler.name, () => {
     let handler: APIGatewayProxyHandler;
@@ -133,4 +134,13 @@ describe(APIGatewayProxyHandler.name, () => {
         const result = await fn(event, context, () => undefined);
         expect(result).toMatchSnapshot();
     });
+
+    it("handles ConflictError response correctly", async () => {
+        const fn = handler.wrapper(() => {
+            throw new ConflictError("ConflictError message");
+        }) as Handler<APIGatewayProxyEvent, APIGatewayProxyResult>;
+
+        const result = await fn(event, context, () => undefined);
+        expect(result).toMatchSnapshot();
+    });
 });

src/handler/APIGatewayProxyHandler.ts

@@ -7,8 +7,9 @@ import {
     RequestTimeoutError,
     ValidationError,
     UnauthorizedError,
+    UnprocessableEntityError,
+    ConflictError,
 } from "../error";
-import { UnprocessableEntityError } from "../error";
 import { ContentTypeHeader, CORSHeader, Header, Headers } from "../header";
 import {
     badRequest,
@@ -21,6 +22,7 @@ import {
     requestTimeout,
     unauthorized,
     unprocessableEntity,
+    conflict,
 } from "../response";
 import { BaseHandler, BaseHandlerArguments } from "./BaseHandler";
 import { config } from "../index";
@@ -49,6 +51,9 @@ export class APIGatewayProxyHandler extends BaseHandler {
         if (err instanceof NotFoundError) {
             return notFound(err.details);
         }
+        if (err instanceof ConflictError) {
+            return conflict(err.details);
+        }
         config.logger.error({
             name: err.name,
             message: err.message,

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

@@ -12,6 +12,18 @@ Object {
 }
 `;
 
+exports[`APIGatewayProxyHandler handles ConflictError response correctly 1`] = `
+Object {
+  "body": "{\\"errors\\":[{\\"name\\":\\"ConflictError\\",\\"details\\":\\"ConflictError message\\"}]}",
+  "headers": Object {
+    "Access-Control-Allow-Credentials": true,
+    "Access-Control-Allow-Origin": "*",
+    "Content-Type": "application/json",
+  },
+  "statusCode": 409,
+}
+`;
+
 exports[`APIGatewayProxyHandler handles ForbiddenError response correctly 1`] = `
 Object {
   "body": "{\\"errors\\":[{\\"name\\":\\"ForbiddenError\\",\\"details\\":\\"ForbiddenError message\\"}]}",

src/response.ts

@@ -10,6 +10,7 @@ import {
     UnauthorizedError,
     UnprocessableEntityError,
 } from "./error";
+import { ConflictError } from "./error/ConflictError";
 
 export interface APIGatewayResponse extends Omit<APIGatewayProxyResult, "body"> {
     body: unknown | undefined;
@@ -50,6 +51,11 @@ export function unprocessableEntity(details: string | undefined): APIGatewayResp
     return buildResult<UnprocessableEntityError>(error, constants.HTTP_STATUS_UNPROCESSABLE_ENTITY);
 }
 
+export function conflict(details: string | undefined): APIGatewayResponse {
+    const error: ConflictError = new ConflictError(details);
+    return buildResult<ConflictError>(error, constants.HTTP_STATUS_CONFLICT);
+}
+
 export function ok<T>(result: T): APIGatewayResponse {
     return buildResult<T>(result, constants.HTTP_STATUS_OK);
 }