@contextualize/lambda-router 0.0.4

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const path = require("path");
+const _1 = require(".");
+const stream_1 = require("stream");
+class DummyWritable extends stream_1.Writable {
+    data = [];
+    result;
+    resolve;
+    constructor() {
+        super();
+        this.result = new Promise(resolve => {
+            this.resolve = resolve;
+        });
+    }
+    _write(chunk, encoding, callback) {
+        this.data.push(chunk.toString());
+        callback();
+    }
+    _final(callback) {
+        this.resolve(this.data.join(''));
+        callback();
+    }
+}
+async function main() {
+    commander_1.program.version('0.0.1')
+        .name("lambda-router")
+        .description("Contextualize's solution for creating RESTful lambda applications");
+    commander_1.program.command("serve")
+        .description("Run lambda as a dedicated server")
+        .argument('<main>', 'Main file for starting the lambda')
+        .option('-p, --port <number>', 'server port', '8000')
+        .option('-e, --entry <string>', 'entry point function', 'lambdaHandler')
+        .action(async (entry, options) => {
+        const absoluteEntryPt = path.join(process.cwd(), entry);
+        console.log(absoluteEntryPt);
+        Object.defineProperty(global, "awslambda", {
+            value: {
+                streamifyResponse: (lambda) => {
+                    _1.Server.serve((req, res) => {
+                        const writable = new DummyWritable();
+                        lambda(req, writable);
+                        writable.result.then((value) => res(JSON.parse(value)));
+                    }, {
+                        port: parseInt(options.port)
+                    });
+                }
+            }
+        });
+        const entryPointFile = require(absoluteEntryPt);
+        if (typeof entryPointFile[options.entry] === 'function') {
+            const handlerFunc = entryPointFile[options.entry];
+            _1.Server.serve(async (req, res) => {
+                const response = await handlerFunc(req);
+                res(response);
+            });
+        }
+    });
+    await commander_1.program.parseAsync(process.argv);
+}
+main();

package/dist/errors.d.ts

@@ -0,0 +1,32 @@
+export declare class PublicError extends Error {
+    code: number;
+    constructor(code: number | undefined, message: string);
+}
+export declare class BadRequestError extends PublicError {
+    constructor(message?: string);
+}
+export declare class NotFoundError extends PublicError {
+    constructor(message?: string);
+}
+export declare class MethodNotAllowedError extends PublicError {
+    constructor(message?: string);
+}
+export declare class NotImplementedError extends PublicError {
+    constructor(message?: string);
+}
+export declare class ConflictError extends PublicError {
+    constructor(message?: string);
+}
+export declare class NotAuthenticatedError extends PublicError {
+    constructor(message?: string);
+}
+export declare class PermissionDeniedError extends PublicError {
+    constructor(message?: string);
+}
+export declare class ExpectedBodyError extends BadRequestError {
+    constructor();
+}
+export declare class BodyValidationError extends BadRequestError {
+    missingField: string;
+    constructor(missingField: string);
+}

package/dist/errors.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BodyValidationError = exports.ExpectedBodyError = exports.PermissionDeniedError = exports.NotAuthenticatedError = exports.ConflictError = exports.NotImplementedError = exports.MethodNotAllowedError = exports.NotFoundError = exports.BadRequestError = exports.PublicError = void 0;
+// Base class for errors that are safe to show the end user
+class PublicError extends Error {
+    code;
+    constructor(code = 500, message) {
+        super(message);
+        this.code = code;
+    }
+}
+exports.PublicError = PublicError;
+class BadRequestError extends PublicError {
+    constructor(message = "Bad Request") {
+        super(400, message);
+    }
+}
+exports.BadRequestError = BadRequestError;
+class NotFoundError extends PublicError {
+    constructor(message = "Not Found") {
+        super(404, message);
+    }
+}
+exports.NotFoundError = NotFoundError;
+class MethodNotAllowedError extends PublicError {
+    constructor(message = "Method Not Allowed") {
+        super(405, message);
+    }
+}
+exports.MethodNotAllowedError = MethodNotAllowedError;
+class NotImplementedError extends PublicError {
+    constructor(message = "Not Implemented") {
+        super(501, message);
+    }
+}
+exports.NotImplementedError = NotImplementedError;
+class ConflictError extends PublicError {
+    constructor(message = "Conflict Error") {
+        super(409, message);
+    }
+}
+exports.ConflictError = ConflictError;
+class NotAuthenticatedError extends PublicError {
+    constructor(message = "Not Authenticated") {
+        super(401, message);
+    }
+}
+exports.NotAuthenticatedError = NotAuthenticatedError;
+class PermissionDeniedError extends PublicError {
+    constructor(message = "Permission Denied") {
+        super(403, message);
+    }
+}
+exports.PermissionDeniedError = PermissionDeniedError;
+class ExpectedBodyError extends BadRequestError {
+    constructor() {
+        super("No body included in request");
+    }
+}
+exports.ExpectedBodyError = ExpectedBodyError;
+class BodyValidationError extends BadRequestError {
+    missingField;
+    constructor(missingField) {
+        super(`Required field '${missingField}' missing`);
+        this.missingField = missingField;
+    }
+}
+exports.BodyValidationError = BodyValidationError;

package/dist/handler.d.ts

@@ -0,0 +1,19 @@
+import { APIGatewayEvent } from "aws-lambda";
+import Router from "./router";
+import APIGatewayResponse from "./response";
+import Server from "./server";
+import { MinimumAPIGatewayEvent } from "./request";
+export type HandlerSetup = (event: MinimumAPIGatewayEvent) => (Router | Promise<Router>);
+export type HandlerCleanup = (event: MinimumAPIGatewayEvent) => void | Promise<void>;
+export type BackgroundProcess = Promise<any | void>;
+export default class Handler {
+    private isInHandler;
+    private canDoBackground;
+    private backgroundProcesses;
+    private static executeRouter;
+    static handler(setup: HandlerSetup, cleanup?: HandlerCleanup): (event: APIGatewayEvent) => Promise<APIGatewayResponse<any>>;
+    background(process: BackgroundProcess | (() => BackgroundProcess)): void;
+    waitForBackgroundProcesses(): Promise<void>;
+    static serverHandler(setup: HandlerSetup, cleanup?: HandlerCleanup, props?: Parameters<typeof Server.serve>[1]): Promise<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> | import("https").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>;
+    static backgroundHandler(setup: HandlerSetup, cleanup?: HandlerCleanup): import("aws-lambda").Handler<any, any>;
+}

package/dist/handler.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const response_1 = require("./response");
+const server_1 = require("./server");
+class Handler {
+    isInHandler = false;
+    canDoBackground = false;
+    backgroundProcesses = [];
+    static async executeRouter(event, handler, setup) {
+        handler.isInHandler = true;
+        let result;
+        try {
+            const router = await setup(event);
+            result = await router.process(event, handler);
+        }
+        catch (e) {
+            console.error(e);
+            result = new response_1.default();
+            result.status(500).json({ message: "An unhandled error was encountered" });
+        }
+        handler.isInHandler = false;
+        return result;
+    }
+    static handler(setup, cleanup) {
+        const handler = new Handler();
+        handler.canDoBackground = false;
+        return async (event) => {
+            const result = await this.executeRouter(event, handler, setup);
+            if (cleanup) {
+                await cleanup(event);
+            }
+            return result;
+        };
+    }
+    background(process) {
+        console.log("Registering background process");
+        if (!this.canDoBackground) {
+            throw new Error("Lambda handler not configured to use background processes");
+        }
+        if (!this.isInHandler) {
+            throw new Error("Cannot push a new background process outside of router execution");
+        }
+        if (typeof process === 'function') {
+            process = process();
+        }
+        this.backgroundProcesses.push(process);
+    }
+    async waitForBackgroundProcesses() {
+        this.canDoBackground = false;
+        if (this.backgroundProcesses.length > 0) {
+            console.log("Awaiting background processes");
+            const results = await Promise.allSettled(this.backgroundProcesses);
+            results.forEach(result => {
+                if (result.status === 'rejected') {
+                    console.error(`Background process failed with error:`);
+                    console.error(result.reason);
+                }
+            });
+        }
+    }
+    static serverHandler(setup, cleanup, props) {
+        const handler = new Handler();
+        handler.canDoBackground = true;
+        return server_1.default.serve((async (event, response) => {
+            let result = await this.executeRouter(event, handler, setup);
+            response(result);
+            await handler.waitForBackgroundProcesses();
+            if (cleanup) {
+                await cleanup(event);
+            }
+        }), props);
+    }
+    static backgroundHandler(setup, cleanup) {
+        return awslambda.streamifyResponse(async (event, responseStream, _context) => {
+            const handler = new Handler();
+            handler.canDoBackground = true;
+            let result = await this.executeRouter(event, handler, setup);
+            responseStream.write(JSON.stringify(result));
+            responseStream.end();
+            await handler.waitForBackgroundProcesses();
+            if (cleanup) {
+                await cleanup(event);
+            }
+        });
+    }
+}
+exports.default = Handler;

package/dist/healthcheck.d.ts

@@ -0,0 +1,19 @@
+import { MaybePromise } from ".";
+export interface DependancyHealthcheckStatus {
+    ok: boolean;
+    status?: any;
+}
+export interface Dependancy {
+    name: string;
+    optional?: boolean;
+    check: () => MaybePromise<DependancyHealthcheckStatus>;
+}
+export interface DependancyStatus extends DependancyHealthcheckStatus {
+    name: string;
+}
+export interface HealthcheckStatus {
+    live: boolean;
+    dependancies: DependancyStatus[];
+    serverTime: Date;
+}
+export default function Healthcheck(dependancies: Dependancy[]): Promise<HealthcheckStatus>;

package/dist/healthcheck.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = Healthcheck;
+async function Healthcheck(dependancies) {
+    let live = true;
+    const checkingDependancies = dependancies.map(async (dependancy) => {
+        try {
+            return await dependancy.check();
+        }
+        catch (e) {
+            return { ok: false };
+        }
+    });
+    const statuses = (await Promise.allSettled(checkingDependancies)).map((status, i) => {
+        const srcDependancy = dependancies[i];
+        if (status.status === 'rejected') {
+            return {
+                name: srcDependancy.name,
+                ok: false,
+                status: status.reason
+            };
+        }
+        else {
+            if (!status.value.ok && !srcDependancy.optional) {
+                live = false;
+            }
+            return {
+                name: srcDependancy.name,
+                ...status.value
+            };
+        }
+    });
+    return {
+        live,
+        dependancies: statuses,
+        serverTime: new Date()
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import Router from './router';
+import Handler from './handler';
+import * as Errors from './errors';
+import APIGatewayRequest from './request';
+import APIGatewayResponse from './response';
+import Server from './server';
+import Healthcheck from './healthcheck';
+export type MaybePromise<T> = Promise<T> | T;
+export { Router, Errors, Handler, APIGatewayRequest, APIGatewayResponse, Server, Healthcheck };

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Healthcheck = exports.Server = exports.APIGatewayResponse = exports.APIGatewayRequest = exports.Handler = exports.Errors = exports.Router = void 0;
+const router_1 = require("./router");
+exports.Router = router_1.default;
+const handler_1 = require("./handler");
+exports.Handler = handler_1.default;
+const Errors = require("./errors");
+exports.Errors = Errors;
+const request_1 = require("./request");
+exports.APIGatewayRequest = request_1.default;
+const response_1 = require("./response");
+exports.APIGatewayResponse = response_1.default;
+const server_1 = require("./server");
+exports.Server = server_1.default;
+const healthcheck_1 = require("./healthcheck");
+exports.Healthcheck = healthcheck_1.default;

package/dist/path.d.ts

@@ -0,0 +1,26 @@
+import APIGatewayRequest from "./request";
+import Router, { Endpoint } from "./router";
+interface MiddlewareWrapped<T> {
+    handler: T;
+    middlewareIndex: number;
+}
+export default class Path<T> {
+    router: Router<T>;
+    methods: Record<string, MiddlewareWrapped<Endpoint<T>>>;
+    subroute?: MiddlewareWrapped<Router<T & any>>;
+    children: Record<string, Path<T>>;
+    regexp: RegexPath<T>[];
+    constructor(router: Router<T>);
+    getEnd(path: string[], index: number): Path<T>;
+    find(request: APIGatewayRequest<T>, path: string[], index: number, routers: {
+        router: Router<T & any>;
+        index: number;
+    }[]): Endpoint<T>;
+}
+export declare class RegexPath<T> extends Path<T> {
+    key: string;
+    regex: string;
+    constructor(router: Router<T>, key: string);
+    matches(pathSegment: string): boolean;
+}
+export {};

package/dist/path.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegexPath = void 0;
+const errors_1 = require("./errors");
+class Path {
+    router;
+    methods = {};
+    subroute;
+    children = {};
+    regexp = [];
+    constructor(router) {
+        this.router = router;
+    }
+    getEnd(path, index) {
+        if (path.length === index) {
+            return this;
+        }
+        const currentPath = path[index];
+        let reg;
+        if (reg = /^\{(.*)\}$/.exec(currentPath)) {
+            const key = reg[1];
+            let regHandler = this.regexp.find((regex) => {
+                return regex.key === key;
+            });
+            if (!regHandler) {
+                regHandler = new RegexPath(this.router, key);
+                this.regexp.push(regHandler);
+            }
+            return regHandler.getEnd(path, index + 1);
+        }
+        if (!(currentPath in this.children)) {
+            this.children[currentPath] = new Path(this.router);
+        }
+        return this.children[currentPath].getEnd(path, index + 1);
+    }
+    find(request, path, index, routers) {
+        if (path.length === index) {
+            let methodHandler;
+            if (!(request.method in this.methods)) {
+                if (!('ANY' in this.methods)) {
+                    if (this.subroute) {
+                        const result = this.subroute.handler.basePath.find(request, path, index, routers);
+                        routers.push({ router: this.router, index: this.subroute.middlewareIndex });
+                        return result;
+                    }
+                    if (Object.keys(this.methods).length === 0) {
+                        throw new errors_1.NotFoundError();
+                    }
+                    throw new errors_1.MethodNotAllowedError();
+                }
+                methodHandler = this.methods['ANY'];
+            }
+            else {
+                methodHandler = this.methods[request.method];
+            }
+            routers.push({ router: this.router, index: methodHandler.middlewareIndex });
+            return methodHandler.handler;
+        }
+        const currentPath = path[index];
+        if (currentPath in this.children) {
+            const inPath = this.children[currentPath];
+            try {
+                const result = inPath.find(request, path, index + 1, routers);
+                return result;
+            }
+            catch (e) {
+                if (e instanceof errors_1.MethodNotAllowedError) {
+                    throw e;
+                }
+            }
+        }
+        if (this.subroute) {
+            const inPath = this.subroute;
+            try {
+                const result = inPath.handler.basePath.find(request, path, index, routers);
+                routers.push({ router: this.router, index: inPath.middlewareIndex });
+                return result;
+            }
+            catch (e) {
+                if (e instanceof errors_1.MethodNotAllowedError) {
+                    throw e;
+                }
+            }
+        }
+        for (const regex of this.regexp) {
+            if (regex.matches(currentPath)) {
+                request.params[regex.key] = currentPath;
+                const result = regex.find(request, path, index + 1, routers);
+                return result;
+            }
+        }
+        throw new errors_1.NotFoundError();
+    }
+}
+exports.default = Path;
+class RegexPath extends Path {
+    key;
+    regex;
+    constructor(router, key) {
+        super(router);
+        this.key = key;
+    }
+    matches(pathSegment) {
+        return true;
+    }
+}
+exports.RegexPath = RegexPath;

package/dist/request.d.ts

@@ -0,0 +1,20 @@
+import { APIGatewayEvent } from "aws-lambda";
+import Handler from "./handler";
+export declare enum CommonHeaders {
+    ContentLength = "Content-Length",
+    ContentType = "Content-Type",
+    Authorization = "Authorization"
+}
+export type MinimumAPIGatewayEvent = Pick<APIGatewayEvent, 'headers' | 'path' | 'httpMethod' | 'queryStringParameters' | 'body'>;
+export default class APIGatewayRequest<Application = {}> {
+    handler?: Handler | undefined;
+    headers: Record<CommonHeaders | string, any>;
+    path: string;
+    method: string;
+    query: Record<string, any>;
+    params: any;
+    body: any;
+    app: Application;
+    constructor(event: MinimumAPIGatewayEvent, handler?: Handler | undefined);
+    assertBody(...fields: string[]): boolean;
+}

package/dist/request.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonHeaders = void 0;
+const errors_1 = require("./errors");
+// {
+//     "body": "eyJ0ZXN0IjoiYm9keSJ9",
+//     "resource": "/{proxy+}",
+//     "path": "/",
+//     "httpMethod": "GET",
+//     "isBase64Encoded": true,
+//     "queryStringParameters": {
+//       "foo": "bar"
+//     },
+//     "multiValueQueryStringParameters": {
+//       "foo": [
+//         "bar"
+//       ]
+//     },
+//     "pathParameters": {
+//       "proxy": "/path/to/resource"
+//     },
+//     "stageVariables": {
+//       "baz": "qux"
+//     },
+//     "headers": {
+//       "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+//       "Accept-Encoding": "gzip, deflate, sdch",
+//       "Accept-Language": "en-US,en;q=0.8",
+//       "Cache-Control": "max-age=0",
+//       "CloudFront-Forwarded-Proto": "https",
+//       "CloudFront-Is-Desktop-Viewer": "true",
+//       "CloudFront-Is-Mobile-Viewer": "false",
+//       "CloudFront-Is-SmartTV-Viewer": "false",
+//       "CloudFront-Is-Tablet-Viewer": "false",
+//       "CloudFront-Viewer-Country": "US",
+//       "Host": "1234567890.execute-api.us-east-1.amazonaws.com",
+//       "Upgrade-Insecure-Requests": "1",
+//       "User-Agent": "Custom User Agent String",
+//       "Via": "1.1 08f323deadbeefa7af34d5feb414ce27.cloudfront.net (CloudFront)",
+//       "X-Amz-Cf-Id": "cDehVQoZnx43VYQb9j2-nvCh-9z396Uhbp027Y2JvkCPNLmGJHqlaA==",
+//       "X-Forwarded-For": "127.0.0.1, 127.0.0.2",
+//       "X-Forwarded-Port": "443",
+//       "X-Forwarded-Proto": "https"
+//     },
+//     "multiValueHeaders": {
+//       "Accept": [
+//         "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"
+//       ],
+//       "Accept-Encoding": [
+//         "gzip, deflate, sdch"
+//       ],
+//       "Accept-Language": [
+//         "en-US,en;q=0.8"
+//       ],
+//       "Cache-Control": [
+//         "max-age=0"
+//       ],
+//       "CloudFront-Forwarded-Proto": [
+//         "https"
+//       ],
+//       "CloudFront-Is-Desktop-Viewer": [
+//         "true"
+//       ],
+//       "CloudFront-Is-Mobile-Viewer": [
+//         "false"
+//       ],
+//       "CloudFront-Is-SmartTV-Viewer": [
+//         "false"
+//       ],
+//       "CloudFront-Is-Tablet-Viewer": [
+//         "false"
+//       ],
+//       "CloudFront-Viewer-Country": [
+//         "US"
+//       ],
+//       "Host": [
+//         "0123456789.execute-api.us-east-1.amazonaws.com"
+//       ],
+//       "Upgrade-Insecure-Requests": [
+//         "1"
+//       ],
+//       "User-Agent": [
+//         "Custom User Agent String"
+//       ],
+//       "Via": [
+//         "1.1 08f323deadbeefa7af34d5feb414ce27.cloudfront.net (CloudFront)"
+//       ],
+//       "X-Amz-Cf-Id": [
+//         "cDehVQoZnx43VYQb9j2-nvCh-9z396Uhbp027Y2JvkCPNLmGJHqlaA=="
+//       ],
+//       "X-Forwarded-For": [
+//         "127.0.0.1, 127.0.0.2"
+//       ],
+//       "X-Forwarded-Port": [
+//         "443"
+//       ],
+//       "X-Forwarded-Proto": [
+//         "https"
+//       ]
+//     },
+//     "requestContext": {
+//       "accountId": "123456789012",
+//       "resourceId": "123456",
+//       "stage": "prod",
+//       "requestId": "c6af9ac6-7b61-11e6-9a41-93e8deadbeef",
+//       "requestTime": "09/Apr/2015:12:34:56 +0000",
+//       "requestTimeEpoch": 1428582896000,
+//       "identity": {
+//         "cognitoIdentityPoolId": null,
+//         "accountId": null,
+//         "cognitoIdentityId": null,
+//         "caller": null,
+//         "accessKey": null,
+//         "sourceIp": "127.0.0.1",
+//         "cognitoAuthenticationType": null,
+//         "cognitoAuthenticationProvider": null,
+//         "userArn": null,
+//         "userAgent": "Custom User Agent String",
+//         "user": null
+//       },
+//       "path": "/prod/path/to/resource",
+//       "resourcePath": "/{proxy+}",
+//       "httpMethod": "POST",
+//       "apiId": "1234567890",
+//       "protocol": "HTTP/1.1"
+//     }
+//   }
+var CommonHeaders;
+(function (CommonHeaders) {
+    CommonHeaders["ContentLength"] = "Content-Length";
+    CommonHeaders["ContentType"] = "Content-Type";
+    CommonHeaders["Authorization"] = "Authorization";
+})(CommonHeaders || (exports.CommonHeaders = CommonHeaders = {}));
+class APIGatewayRequest {
+    handler;
+    headers;
+    ;
+    path;
+    method;
+    query;
+    params;
+    body;
+    app;
+    constructor(event, handler) {
+        this.handler = handler;
+        this.headers = event.headers;
+        this.params = {};
+        this.path = event.path;
+        this.method = event.httpMethod;
+        this.query = event.queryStringParameters ?? {};
+        this.body = event.body;
+        if (CommonHeaders.ContentType in this.headers) {
+            switch (this.headers[CommonHeaders.ContentType]) {
+                case 'application/json':
+                    this.body = event.body ? JSON.parse(event.body) : undefined;
+                    break;
+            }
+        }
+    }
+    assertBody(...fields) {
+        if (!this.body) {
+            throw new errors_1.ExpectedBodyError();
+        }
+        for (const field of fields) {
+            if (!(field in this.body)) {
+                throw new errors_1.BodyValidationError(field);
+            }
+        }
+        return true;
+    }
+}
+exports.default = APIGatewayRequest;

package/dist/response.d.ts

@@ -0,0 +1,13 @@
+export declare enum StatusCode {
+    ok = 200,
+    new = 201
+}
+export default class APIGatewayResponse<T = any> {
+    statusCode: number;
+    headers: Record<string, string>;
+    body?: any;
+    constructor();
+    status(code: number): this;
+    json(body: T): this;
+    text(body: string): this;
+}

package/dist/response.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusCode = void 0;
+var StatusCode;
+(function (StatusCode) {
+    StatusCode[StatusCode["ok"] = 200] = "ok";
+    StatusCode[StatusCode["new"] = 201] = "new";
+})(StatusCode || (exports.StatusCode = StatusCode = {}));
+class APIGatewayResponse {
+    statusCode;
+    headers;
+    ;
+    body;
+    constructor() {
+        this.statusCode = 200;
+        this.headers = {};
+        this.body = undefined;
+    }
+    status(code) {
+        this.statusCode = code;
+        return this;
+    }
+    json(body) {
+        this.headers['Content-Type'] = "application/json";
+        this.body = JSON.stringify(body);
+        return this;
+    }
+    text(body) {
+        this.headers['Content-Type'] = "text/plain";
+        this.body = body;
+        return this;
+    }
+}
+exports.default = APIGatewayResponse;

package/dist/router.d.ts

@@ -0,0 +1,20 @@
+import Path from "./path";
+import APIGatewayRequest, { MinimumAPIGatewayEvent } from "./request";
+import APIGatewayResponse from "./response";
+import Handler from "./handler";
+export type Endpoint<App> = (request: APIGatewayRequest<App>, response: APIGatewayResponse) => void;
+export type Middleware<T> = (request: APIGatewayRequest<T>) => void;
+export default class Router<T = {}> {
+    basePath: Path<T>;
+    middleware: Middleware<T>[];
+    constructor();
+    get(path: string, callback: Endpoint<T>): void;
+    post(path: string, callback: Endpoint<T>): void;
+    put(path: string, callback: Endpoint<T>): void;
+    delete(path: string, callback: Endpoint<T>): void;
+    any(path: string, callback: Endpoint<T>): void;
+    route(method: string, endpoint: string, handler: Endpoint<T>): void;
+    use(middleware: Middleware<T>): void;
+    subroute<Y extends T>(endpoint: string, router: Router<Y>): void;
+    process(event: MinimumAPIGatewayEvent, handler?: Handler): Promise<APIGatewayResponse<any>>;
+}

package/dist/router.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("./path");
+const request_1 = require("./request");
+const response_1 = require("./response");
+const errors_1 = require("./errors");
+class Router {
+    basePath;
+    middleware;
+    constructor() {
+        this.basePath = new path_1.default(this);
+        this.middleware = [];
+    }
+    get(path, callback) {
+        this.route('GET', path, callback);
+    }
+    post(path, callback) {
+        this.route('POST', path, callback);
+    }
+    put(path, callback) {
+        this.route('PUT', path, callback);
+    }
+    delete(path, callback) {
+        this.route('DELETE', path, callback);
+    }
+    any(path, callback) {
+        this.route('ANY', path, callback);
+    }
+    route(method, endpoint, handler) {
+        const path = endpoint.split('/').filter(a => !!a);
+        const end = this.basePath.getEnd(path, 0);
+        end.methods[method] = { handler, middlewareIndex: this.middleware.length };
+    }
+    use(middleware) {
+        this.middleware.push(middleware);
+    }
+    subroute(endpoint, router) {
+        const path = endpoint.split('/').filter(a => !!a);
+        const end = this.basePath.getEnd(path, 0);
+        end.subroute = { handler: router, middlewareIndex: this.middleware.length };
+    }
+    async process(event, handler) {
+        const response = new response_1.default();
+        const request = new request_1.default(event, handler);
+        console.log(`${request.method.padEnd(6, ' ')} ${request.path}`);
+        const path = request.path.split('/').filter(a => !!a);
+        try {
+            const routerPath = [];
+            const foundEndpoint = this.basePath.find(request, path, 0, routerPath);
+            if (!foundEndpoint) {
+                throw new errors_1.NotFoundError();
+            }
+            routerPath.reverse();
+            for (const { router, index } of routerPath) {
+                const usedMiddleware = router.middleware.slice(0, index);
+                for (const middlware of usedMiddleware) {
+                    await middlware(request);
+                }
+            }
+            await foundEndpoint(request, response);
+        }
+        catch (exception) {
+            if (exception instanceof errors_1.PublicError) {
+                console.warn(`Request failed gracefully with code: ${exception.code} ${exception.message}`);
+                response.statusCode = exception.code;
+                response.json({ message: exception.message });
+            }
+            else {
+                console.error(`Request experienced a critical error`);
+                throw exception;
+            }
+        }
+        return response;
+    }
+}
+exports.default = Router;

package/dist/server.d.ts

@@ -0,0 +1,16 @@
+import * as https from 'https';
+import * as http from 'http';
+import { MinimumAPIGatewayEvent } from "./request";
+import APIGatewayResponse from "./response";
+import { MaybePromise } from ".";
+interface ServerProps {
+    port?: number;
+    protocol?: 'http' | 'https';
+}
+export default class Server {
+    private static normalizeProps;
+    private static convertIncomingMessage;
+    static processResponse(response: http.ServerResponse): (routerResponse: APIGatewayResponse) => Promise<void>;
+    static serve(handler: (request: MinimumAPIGatewayEvent, response: (response: APIGatewayResponse) => void) => MaybePromise<void>, props?: ServerProps): Promise<http.Server | https.Server>;
+}
+export {};

package/dist/server.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const https = require("https");
+const http = require("http");
+class Server {
+    static normalizeProps(props) {
+        const defaults = {
+            port: 8000,
+            protocol: 'http'
+        };
+        if (typeof props === 'undefined') {
+            return defaults;
+        }
+        return { ...defaults, ...props };
+    }
+    static async convertIncomingMessage(message) {
+        const headers = {};
+        //_mvHeaders: Record<string, string[]> = {};
+        Object.entries(message.headers).forEach(([k, v]) => {
+            if (!v) {
+                return;
+            }
+            if (Array.isArray(v)) {
+                //_mvHeaders[k] = v;
+            }
+            else {
+                const parts = k.split('-');
+                for (let i = 0; i < parts.length; i++) {
+                    if (parts[i]) {
+                        parts[i] = `${parts[i][0].toUpperCase()}${parts[i].slice(1)}`;
+                    }
+                }
+                headers[parts.join('-')] = v;
+            }
+        });
+        let body = null;
+        if (parseInt(message.headers["content-length"] ?? '0') !== 0) {
+            body = await (new Promise(resolve => {
+                const aggrigator = [];
+                message.on('data', (chunk) => {
+                    aggrigator.push(chunk.toString());
+                });
+                message.on('end', () => {
+                    resolve(aggrigator.join(''));
+                });
+            }));
+        }
+        const url = new URL(`http://localhost${message.url ?? '/'}`);
+        return {
+            body: body,
+            headers: headers,
+            httpMethod: message.method ?? "GET",
+            path: url.pathname,
+            queryStringParameters: Object.fromEntries(url.searchParams)
+        };
+    }
+    static processResponse(response) {
+        return async (routerResponse) => {
+            Object.entries(routerResponse.headers).forEach(([header, value]) => {
+                response.setHeader(header, value);
+            });
+            response.statusCode = routerResponse.statusCode;
+            if (routerResponse.body) {
+                await new Promise(resolve => {
+                    response.write(routerResponse.body, resolve);
+                });
+            }
+            response.end();
+        };
+    }
+    static serve(handler, props) {
+        return new Promise(resolve => {
+            const normalProps = this.normalizeProps(props);
+            const serverHandler = normalProps.protocol === 'https' ? https.createServer : http.createServer;
+            const server = serverHandler({}, async (request, response) => {
+                const GatewayLikeRequest = await this.convertIncomingMessage(request);
+                handler(GatewayLikeRequest, this.processResponse(response));
+            });
+            server.listen(normalProps?.port, () => {
+                console.log(`${normalProps?.protocol} server listening on port ${normalProps.port}`);
+                resolve(server);
+            });
+        });
+    }
+}
+exports.default = Server;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@contextualize/lambda-router",
+  "version": "0.0.4",
+  "description": "Allows for the creation of Express-like APIs within AWS Lambda",
+  "main": "dist/index.js",
+  "bin": {
+    "lambda-router": "./dist/cli.js"
+  },
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w",
+    "test": "jest"
+  },
+  "author": "Contextualize LLC",
+  "license": "ISC",
+  "files": [
+    "/dist"
+  ],
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.9.1",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.6.3"
+  },
+  "dependencies": {
+    "@types/aws-lambda": "^8.10.136",
+    "aws-lambda": "^1.0.7",
+    "aws-sdk": "^2.1581.0",
+    "commander": "^14.0.0"
+  },
+  "browser": {
+    "crypto": false
+  }
+}

package/readme.md

@@ -0,0 +1,65 @@
+# Lambda Router
+
+Allows for the creation of Express-like APIs within AWS Lambda.
+
+## Create Router
+
+```js
+import { Router, Handler } from '@contextualize/lambda-router';
+
+const router = new Router();
+
+router.get('/', (req, res)=>{
+    return res.status(200).json({
+        status: "ok"
+    });
+})
+
+export const lambdaHandler = Handler.handler(()=>router);
+
+```
+
+## Background Handler
+Some lambdas may require tasks to run in the background after a request has been handled. `Handler.backgroundHandler` allows you to defer promises for after the lambda has returned a response to the client.
+
+```js
+import { Router, Handler } from '@contextualize/lambda-router';
+
+const router = new Router();
+
+router.get('/', (req, res)=>{
+    req.handler.background(async ()=>{
+
+        // Assume this a request that is going to take a long time
+        await fetch('https://example.com')
+    })
+
+    return res.status(200).json({
+        status: "ok"
+    });
+})
+
+export const lambdaHandler = Handler.backgroundHandler(()=>router);
+```
+
+## Run as Dedicated Server
+You can run lambdas set up with lambda-router, and some that aren't using `lambda-router serve`. This will create a node native http server that converts HTTP requests into APIGateway-like requests, then converts the response from your router into an HTTP response.
+
+This can be used for either local testing, or converting your serverless application to a server-based app should the needs of your application no-longer be found with lambda.
+
+```
+lambda-router serve -h
+Usage: lambda-router serve [options] <main>
+
+Run lambda as a dedicated server
+
+Arguments:
+  main                  Main file for starting the lambda
+
+Options:
+  -p, --port <number>   server port (default: "8000")
+  -e, --entry <string>  entry point function (default: "lambdaHandler")
+  -h, --help            display help for command
+```
+
+