feat(health-check): add health check route to index handler

Calling __health in path will return version and name of the function deployed.

Author: phenixcoder

package-lock.json

@@ -2,7 +2,7 @@
   "name": "lambda-container-service",
   "description": "Template to create a aws lambda compatibel function containers",
   "author": "Balwant",
-  "version": "0.0.0-development",
+  "version": "1.0.0",
   "license": "MIT",
   "keywords": [
     "serverless",
@@ -24,8 +24,8 @@
   "scripts": {
     "start": "tsc --watch --preserveWatchOutput & nodemon dev-server.js -e js -w ./app",
     "build": "tsc",
-    "test": "jest",
-    "test:watch": "jest --watch",
+    "test": "jest --coverage",
+    "test:watch": "jest --watch --coverage",
     "test:newman": "node dev-server.js --test",
     "lint": "tslint --fix -p ./tsconfig.json",
     "prettier": "prettier --write './src/**/*.ts?(x)'",

package.json

@@ -1,4 +1,6 @@
 #!/bin/bash
+
+npm version $1 --no-git-tag-version
 docker build -t lambda-container-service .
 docker tag lambda-container-service:latest public.ecr.aws/m0q0z2r6/lambda-container-service:$1
 docker push public.ecr.aws/m0q0z2r6/lambda-container-service:$1

publish.sh

@@ -2,54 +2,11 @@ import {
   APIGatewayEventRequestContext,
   APIGatewayProxyEventV2,
 } from 'aws-lambda';
+import { version, name } from '../package.json';
 import { handler } from '.';
-const mockContext: APIGatewayEventRequestContext = {
-  accountId: 'string',
-  apiId: 'string',
-  authorizer: {
-    jwt: {
-      claims: {
-        foo: 'string',
-      },
-      scopes: [],
-    },
-  },
-  protocol: '',
-  domainName: '',
-  domainPrefix: 'string',
-  requestId: '',
-  routeKey: '',
-  stage: '',
-  httpMethod: '',
-  identity: {
-    accessKey: '',
-    accountId: '',
-    apiKey: '',
-    apiKeyId: '',
-    caller: '',
-    clientCert: null,
-    cognitoAuthenticationProvider: '',
-    cognitoAuthenticationType: '',
-    cognitoIdentityId: '',
-    cognitoIdentityPoolId: '',
-    principalOrgId: '',
-    sourceIp: '0.0.0.0',
-    user: '',
-    userAgent: '',
-    userArn: '',
-  },
-  path: '',
-  requestTimeEpoch: 0,
-  resourceId: '',
-  resourcePath: '',
-};
-const mockRequest: APIGatewayProxyEventV2 = {
-  version: '',
-  routeKey: '',
-  rawPath: '',
-  rawQueryString: '',
-  headers: {},
-  requestContext: {
+
+function mockContext(): APIGatewayEventRequestContext {
+  return {
     accountId: 'string',
     apiId: 'string',
     authorizer: {
@@ -60,27 +17,77 @@ const mockRequest: APIGatewayProxyEventV2 = {
         scopes: [],
       },
     },
+    protocol: '',
     domainName: '',
     domainPrefix: 'string',
-    timeEpoch: 0,
-    http: {
-      method: 'string',
-      path: 'string',
-      protocol: 'string',
-      sourceIp: 'string',
-      userAgent: 'string',
-    },
     requestId: '',
     routeKey: '',
     stage: '',
-    time: '',
-  },
-  isBase64Encoded: false,
-};
+    httpMethod: '',
+    identity: {
+      accessKey: '',
+      accountId: '',
+      apiKey: '',
+      apiKeyId: '',
+      caller: '',
+      clientCert: null,
+      cognitoAuthenticationProvider: '',
+      cognitoAuthenticationType: '',
+      cognitoIdentityId: '',
+      cognitoIdentityPoolId: '',
+      principalOrgId: '',
+      sourceIp: '0.0.0.0',
+      user: '',
+      userAgent: '',
+      userArn: '',
+    },
+    path: '',
+    requestTimeEpoch: 0,
+    resourceId: '',
+    resourcePath: '',
+  };
+}
+
+function mockRequest(): APIGatewayProxyEventV2 {
+  return {
+    version: '',
+    routeKey: '',
+    rawPath: '',
+    rawQueryString: '',
+    headers: {},
+    requestContext: {
+      accountId: 'string',
+      apiId: 'string',
+      authorizer: {
+        jwt: {
+          claims: {
+            foo: 'string',
+          },
+          scopes: [],
+        },
+      },
+      domainName: '',
+      domainPrefix: 'string',
+      timeEpoch: 0,
+      http: {
+        method: 'string',
+        path: 'string',
+        protocol: 'string',
+        sourceIp: 'string',
+        userAgent: 'string',
+      },
+      requestId: '',
+      routeKey: '',
+      stage: '',
+      time: '',
+    },
+    isBase64Encoded: false,
+  };
+}
 
 describe('Index Handler', () => {
   it('Should return success response', async () => {
-    const response = await handler(mockRequest, mockContext);
+    const response = await handler(mockRequest(), mockContext());
     expect(response).toStrictEqual({
       body: JSON.stringify({
         hello: 'world',
@@ -92,4 +99,19 @@ describe('Index Handler', () => {
       statusCode: 200,
     });
   });
+  it('Should return help response when path is __health', async () => {
+    const req = mockRequest();
+    req.rawPath = '__health';
+    const response = await handler(req, mockContext());
+    expect(response).toStrictEqual({
+      body: JSON.stringify({
+        version,
+        name,
+      }),
+      headers: {
+        'content-type': 'text/json',
+      },
+      statusCode: 200,
+    });
+  });
 });

src/index.test.ts

@@ -4,11 +4,25 @@ import {
   APIGatewayProxyResultV2,
 } from 'aws-lambda';
 import Logger from './lib/logger';
+import pkg from '../package.json';
 
 export const handler = async (
   event: APIGatewayProxyEventV2,
   _context: APIGatewayEventRequestContext
 ): Promise<APIGatewayProxyResultV2> => {
+  if (event.rawPath === '__health') {
+    return {
+      statusCode: 200,
+      headers: {
+        'content-type': 'text/json',
+      },
+      body: JSON.stringify({
+        version: pkg.version,
+        name: pkg.name,
+      }),
+    };
+  }
+
   Logger.debug('This is a log message from handler', event);
   return {
     statusCode: 200,

src/index.ts

@@ -12,7 +12,7 @@
     // "sourceMap": true,                     /* Generates corresponding '.map' file. */
     // "outFile": "./",                       /* Concatenate and emit output to single file. */
     "outDir": "app",                       /* Redirect output structure to the directory. */
-    "rootDir": "src",                      /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "rootDir": "src",                      /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
     // "composite": true,                     /* Enable project compilation */
     // "removeComments": true,                /* Do not emit comments to output. */
     // "noEmit": true,                        /* Do not emit outputs. */