@scloud/lambda-api 0.1.4 → 0.1.5

package/README.md

@@ -0,0 +1,31 @@
+# Lambda API Gateway Proxy handler
+
+A Lambda handler that routes API Gateway Proxy messages and returns an API Gateway Proxy Response.
+
+This is a piece of useful boilerplate to handle the mechanics of routing, headers and cookies, catching any errors and handling 400, 405 and 500 errors (you can optionally handle 404 and 500 with your own handler functions).
+
+## Usage
+
+Create your routes:
+
+```
+import { types } from '@scloud/lambda-api';
+
+const routes: types.Routes = {
+  '/ping': { GET: async (request: types.Request) => ({ statusCode: 200, body: {message: 'ok'} }) },
+}
+```
+
+Use `@scloud/lambda-api` in your Lambda handler:
+
+```
+import { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
+import { apiHandler, helpers } from '@scloud/lambda-api';
+
+export async function handler(event: APIGatewayProxyEvent, context: Context): Promise<APIGatewayProxyResult> {
+  const result = await apiHandler(event, context, routes);
+  return result;
+}
+```
+
+The `apiHandler` function will call your route functions according to the method and path of the request, catching any errors and returning 404/405 if a path/method isn't defined, or 500 if an error is thrown.

package/dist/handler.d.ts

@@ -0,0 +1,49 @@
+import { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
+import { Handler, Request, Routes } from './types';
+/**
+ * Ensures the path is lowercased, always has a leading slash and never a trailing slash
+ * @param path APIGatewayProxyEvent.path
+ */
+export declare function standardPath(path: string): string;
+/**
+ * Ensures a non-null object containing only query-string parameters that have a value.
+ * @param query APIGatewayProxyEvent.query
+ */
+export declare function standardQueryParameters(query: {
+    [name: string]: string | undefined;
+} | null): {
+    [name: string]: string;
+};
+/**
+ * Ensures all header names are lowercased for ease of access.
+ * @param headers APIGatewayProxyEvent.headers
+ */
+export declare function standardHeaders(headers: {
+    [name: string]: string | undefined;
+}): {
+    [name: string]: string;
+};
+/**
+ * Parses the body (if present) to a JSON string. Returns at mimimum an empty object.
+ * @param body APIGatewayProxyEvent.body
+ */
+export declare function parseBody(body: string | null): {
+    [name: string]: string;
+};
+/**
+ * Parses the cookie, if any, returning at minimum an empty object.
+ * @param headers APIGatewayProxyEvent.headers
+ */
+export declare function parseCookie(headers: {
+    [name: string]: string | undefined;
+}): {
+    [name: string]: string;
+};
+export declare function buildCookie(values: {
+    [key: string]: string;
+} | undefined): string[] | undefined;
+export declare function parseRequest(event: APIGatewayProxyEvent): Request;
+/**
+ * Generic routing handler
+ */
+export declare function apiHandler(event: APIGatewayProxyEvent, context: Context, routes?: Routes, errorHandler?: Handler, catchAll?: Handler): Promise<APIGatewayProxyResult>;

package/dist/handler.js

@@ -0,0 +1,178 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiHandler = exports.parseRequest = exports.buildCookie = exports.parseCookie = exports.parseBody = exports.standardHeaders = exports.standardQueryParameters = exports.standardPath = void 0;
+const cookie = __importStar(require("cookie"));
+/**
+ * Ensures the path is lowercased, always has a leading slash and never a trailing slash
+ * @param path APIGatewayProxyEvent.path
+ */
+function standardPath(path) {
+    // Get path segments, filtering out any blanks
+    const segments = path.split('/').filter((segment) => segment);
+    // Return path
+    return `/${segments.join('/').toLowerCase()}`;
+}
+exports.standardPath = standardPath;
+/**
+ * Ensures a non-null object containing only query-string parameters that have a value.
+ * @param query APIGatewayProxyEvent.query
+ */
+function standardQueryParameters(query) {
+    if (!query)
+        return {};
+    const result = {};
+    Object.keys(query).forEach((parameter) => {
+        const value = query[parameter];
+        if (value)
+            result[parameter] = value;
+    });
+    return result;
+}
+exports.standardQueryParameters = standardQueryParameters;
+/**
+ * Ensures all header names are lowercased for ease of access.
+ * @param headers APIGatewayProxyEvent.headers
+ */
+function standardHeaders(headers) {
+    const result = {};
+    Object.keys(headers).forEach((name) => {
+        const value = headers[name];
+        if (value)
+            result[name.toLowerCase()] = value;
+    });
+    return result;
+}
+exports.standardHeaders = standardHeaders;
+/**
+ * Parses the body (if present) to a JSON string. Returns at mimimum an empty object.
+ * @param body APIGatewayProxyEvent.body
+ */
+function parseBody(body) {
+    if (!body)
+        return {};
+    let result = {};
+    try {
+        result = JSON.parse(body);
+    }
+    catch (e) {
+        console.error(`Error parsing request body: ${e}`);
+    }
+    return result;
+}
+exports.parseBody = parseBody;
+/**
+ * Parses the cookie, if any, returning at minimum an empty object.
+ * @param headers APIGatewayProxyEvent.headers
+ */
+function parseCookie(headers) {
+    const header = headers.cookie || headers.Cookie || '';
+    return cookie.parse(header);
+}
+exports.parseCookie = parseCookie;
+function buildCookie(values) {
+    if (!values)
+        return undefined;
+    const header = [];
+    const oneYear = 60 * 60 * 24 * 365;
+    Object.keys(values).forEach((key) => {
+        const value = values[key];
+        if (value === '') {
+            // If explicitly unset, expire the cookie value
+            header.push(cookie.serialize(key, '', {
+                expires: new Date(), secure: true, httpOnly: true, sameSite: 'strict',
+            }));
+        }
+        else if (value) {
+            // Otherwise, set it only if a value was given
+            header.push(cookie.serialize(key, value, {
+                maxAge: oneYear, secure: true, httpOnly: true, sameSite: 'strict',
+            }));
+        }
+    });
+    return header;
+}
+exports.buildCookie = buildCookie;
+function parseRequest(event) {
+    return {
+        method: event.httpMethod,
+        path: standardPath(event.path),
+        query: standardQueryParameters(event.queryStringParameters),
+        headers: standardHeaders(event.headers),
+        body: parseBody(event.body),
+        cookies: parseCookie(event.headers),
+    };
+}
+exports.parseRequest = parseRequest;
+/**
+ * Generic routing handler
+ */
+async function apiHandler(event, context, routes = {
+    '/api/ping': { GET: async (request) => ({ statusCode: 200, body: request }) },
+}, errorHandler = async (request) => ({ statusCode: 500, body: { error: `Internal server error: ${request.path}` } }), catchAll = async (request) => ({ statusCode: 404, body: { error: `Not found: ${request.path}` } })) {
+    console.log(`Executing ${context.functionName} version: ${process.env.COMMIT_HASH}`);
+    const request = parseRequest(event);
+    let response;
+    try {
+        const route = routes[request.path];
+        if (!route) {
+            // Catch-all / 404
+            response = await catchAll(request);
+        }
+        else {
+            const handlerFunction = route[request.method];
+            if (!handlerFunction)
+                return { statusCode: 405, body: JSON.stringify('Method not allowed') };
+            // Handle the request:
+            response = await handlerFunction(request);
+        }
+    }
+    catch (e) {
+        console.error(`${e.message}\n${e.stack}`);
+        try {
+            // Error handling
+            response = await errorHandler(request);
+        }
+        catch (ee) {
+            response = { statusCode: 500, body: { error: `Internal server error: ${request.path}` } };
+        }
+    }
+    // QPI Gateway Proxy result
+    const result = {
+        statusCode: response.statusCode,
+        body: JSON.stringify(response.body),
+        headers: response.headers,
+    };
+    // Cookies (if set)
+    const cookieHeaders = buildCookie(response.cookies);
+    if (cookieHeaders) {
+        result.multiValueHeaders = {
+            Cookie: cookieHeaders,
+        };
+    }
+    return result;
+}
+exports.apiHandler = apiHandler;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"handler.js","sourceRoot":"","sources":["../../src/handler.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable import/prefer-default-export */\n// https://aws.amazon.com/blogs/mobile/understanding-amazon-cognito-user-pool-oauth-2-0-grants/\nimport {\n  APIGatewayProxyEvent,\n  APIGatewayProxyResult,\n  Context,\n} from 'aws-lambda';\nimport * as cookie from 'cookie';\nimport {\n  Handler, Request, Response, Route, Routes,\n} from './types';\n\n/**\n * Ensures the path is lowercased, always has a leading slash and never a trailing slash\n * @param path APIGatewayProxyEvent.path\n */\nexport function standardPath(path: string): string {\n  // Get path segments, filtering out any blanks\n  const segments = path.split('/').filter((segment) => segment);\n  // Return path\n  return `/${segments.join('/').toLowerCase()}`;\n}\n\n/**\n * Ensures a non-null object containing only query-string parameters that have a value.\n * @param query APIGatewayProxyEvent.query\n */\nexport function standardQueryParameters(query: { [name: string]: string | undefined; } | null): { [name: string]: string; } {\n  if (!query) return {};\n  const result: { [name: string]: string; } = {};\n  Object.keys(query).forEach((parameter) => {\n    const value = query[parameter];\n    if (value) result[parameter] = value;\n  });\n  return result;\n}\n\n/**\n * Ensures all header names are lowercased for ease of access.\n * @param headers APIGatewayProxyEvent.headers\n */\nexport function standardHeaders(headers: { [name: string]: string | undefined; }): { [name: string]: string; } {\n  const result: { [name: string]: string; } = {};\n  Object.keys(headers).forEach((name) => {\n    const value = headers[name];\n    if (value) result[name.toLowerCase()] = value;\n  });\n  return result;\n}\n\n/**\n * Parses the body (if present) to a JSON string. Returns at mimimum an empty object.\n * @param body APIGatewayProxyEvent.body\n */\nexport function parseBody(body: string | null): { [name: string]: string; } {\n  if (!body) return {};\n  let result = {};\n  try {\n    result = JSON.parse(body);\n  } catch (e) {\n    console.error(`Error parsing request body: ${e}`);\n  }\n  return result;\n}\n\n/**\n * Parses the cookie, if any, returning at minimum an empty object.\n * @param headers APIGatewayProxyEvent.headers\n */\nexport function parseCookie(headers: { [name: string]: string | undefined; }): { [name: string]: string; } {\n  const header = headers.cookie || headers.Cookie || '';\n  return cookie.parse(header);\n}\n\nexport function buildCookie(values: { [key: string]: string; } | undefined): string[] | undefined {\n  if (!values) return undefined;\n\n  const header: string[] = [];\n  const oneYear = 60 * 60 * 24 * 365;\n\n  Object.keys(values).forEach((key) => {\n    const value = values[key];\n    if (value === '') {\n      // If explicitly unset, expire the cookie value\n      header.push(cookie.serialize(key, '', {\n        expires: new Date(), secure: true, httpOnly: true, sameSite: 'strict',\n      }));\n    } else if (value) {\n      // Otherwise, set it only if a value was given\n      header.push(cookie.serialize(key, value, {\n        maxAge: oneYear, secure: true, httpOnly: true, sameSite: 'strict',\n      }));\n    }\n  });\n\n  return header;\n}\n\nexport function parseRequest(event: APIGatewayProxyEvent): Request {\n  return {\n    method: event.httpMethod,\n    path: standardPath(event.path),\n    query: standardQueryParameters(event.queryStringParameters),\n    headers: standardHeaders(event.headers),\n    body: parseBody(event.body),\n    cookies: parseCookie(event.headers),\n  };\n}\n\n/**\n * Generic routing handler\n */\nexport async function apiHandler(\n  event: APIGatewayProxyEvent,\n  context: Context,\n  routes: Routes = {\n    '/api/ping': { GET: async (request: Request) => ({ statusCode: 200, body: request }) },\n  },\n  errorHandler: Handler = async (request: Request) => ({ statusCode: 500, body: { error: `Internal server error: ${request.path}` } }),\n  catchAll: Handler = async (request: Request) => ({ statusCode: 404, body: { error: `Not found: ${request.path}` } }),\n): Promise<APIGatewayProxyResult> {\n  console.log(`Executing ${context.functionName} version: ${process.env.COMMIT_HASH}`);\n  const request = parseRequest(event);\n\n  let response: Response;\n  try {\n    const route = routes[request.path];\n    if (!route) {\n      // Catch-all / 404\n      response = await catchAll(request);\n    } else {\n      const handlerFunction = route[request.method as keyof Route];\n      if (!handlerFunction) return { statusCode: 405, body: JSON.stringify('Method not allowed') };\n\n      // Handle the request:\n      response = await handlerFunction(request);\n    }\n  } catch (e) {\n    console.error(`${(e as Error).message}\\n${(e as Error).stack}`);\n    try {\n      // Error handling\n      response = await errorHandler(request);\n    } catch (ee) {\n      response = { statusCode: 500, body: { error: `Internal server error: ${request.path}` } };\n    }\n  }\n\n  // QPI Gateway Proxy result\n  const result: APIGatewayProxyResult = {\n    statusCode: response.statusCode,\n    body: JSON.stringify(response.body),\n    headers: response.headers,\n  };\n\n  // Cookies (if set)\n  const cookieHeaders = buildCookie(response.cookies);\n  if (cookieHeaders) {\n    result.multiValueHeaders = {\n      Cookie: cookieHeaders,\n    };\n  }\n\n  return result;\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './handler';

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./handler"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDRDQUEwQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaGFuZGxlcic7XG4iXX0=

package/dist/types.d.ts

@@ -0,0 +1,39 @@
+export interface Request {
+    method: string;
+    path: string;
+    query: {
+        [name: string]: string;
+    };
+    headers: {
+        [name: string]: string;
+    };
+    cookies: {
+        [name: string]: string;
+    };
+    body: {
+        [name: string]: string;
+    };
+}
+export interface Response {
+    statusCode: number;
+    headers?: {
+        [name: string]: string;
+    };
+    cookies?: {
+        [name: string]: string;
+    };
+    body?: {
+        [name: string]: any;
+    };
+}
+export type Handler = (request: Request) => Promise<Response>;
+export interface Route {
+    GET?: Handler;
+    POST?: Handler;
+    PUT?: Handler;
+    DELETE?: Handler;
+    OPTIONS?: Handler;
+}
+export interface Routes {
+    [path: string]: Route;
+}

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgUmVxdWVzdCB7XG4gIG1ldGhvZDogc3RyaW5nLFxuICBwYXRoOiBzdHJpbmcsXG4gIHF1ZXJ5OiB7IFtuYW1lOiBzdHJpbmddOiBzdHJpbmc7IH0sXG4gIGhlYWRlcnM6IHsgW25hbWU6IHN0cmluZ106IHN0cmluZzsgfSxcbiAgY29va2llczogeyBbbmFtZTogc3RyaW5nXTogc3RyaW5nOyB9LFxuICBib2R5OiB7IFtuYW1lOiBzdHJpbmddOiBzdHJpbmc7IH0sXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUmVzcG9uc2Uge1xuICBzdGF0dXNDb2RlOiBudW1iZXIsXG4gIGhlYWRlcnM/OiB7IFtuYW1lOiBzdHJpbmddOiBzdHJpbmc7IH0sXG4gIGNvb2tpZXM/OiB7IFtuYW1lOiBzdHJpbmddOiBzdHJpbmc7IH0sXG4gIGJvZHk/OiB7IFtuYW1lOiBzdHJpbmddOiBhbnk7IH0sXG59XG5cbi8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby11bnVzZWQtdmFyc1xuZXhwb3J0IHR5cGUgSGFuZGxlciA9IChyZXF1ZXN0OiBSZXF1ZXN0KSA9PiBQcm9taXNlPFJlc3BvbnNlPjtcbmV4cG9ydCBpbnRlcmZhY2UgUm91dGUge1xuICBHRVQ/OiBIYW5kbGVyLFxuICBQT1NUPzogSGFuZGxlcixcbiAgUFVUPzogSGFuZGxlcixcbiAgREVMRVRFPzogSGFuZGxlcixcbiAgT1BUSU9OUz86IEhhbmRsZXIsXG59XG5leHBvcnQgaW50ZXJmYWNlIFJvdXRlcyB7IFtwYXRoOiBzdHJpbmddOiBSb3V0ZTsgfVxuIl19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scloud/lambda-api",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Lambda handler for API Gateway proxy requests",
   "main": "dist/index.js",
   "files": [