@aesop-fables/triginta 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Aesop
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,47 @@
+# @aesop-fables/triginta
+
+`triginta` is a lightweight framework that wraps the basic infrastructure usages of AWS Lambda (SQS, Kinesis, etc.). For APIs, see our `API framework`. It aims
+to conventionalize logging, error handling, and X-Ray integration.
+
+## Installation
+```
+npm install @aesop-fables/triginta
+```
+```
+yarn add @aesop-fables/triginta
+```
+
+## Supported Lambdas
+The following can be created via the `ILambdaFactory` interface:
+
+1. SQS Lambdas (`createSqsLambda`)
+2. S3 Lambdas (`createS3Lambda`)
+3. Kinesis Lambdas (`createKinesisLambda`)
+
+## Known issues
+We're missing unit tests, logging, error handling, middleware support, and X-Ray integration. This will all come soon - I just wanted to get the basic structure published.
+
+## Example
+```typescript
+// index.ts
+interface MyQueuedMessage {
+  message: string;
+}
+
+class MyLambda implements IHandler<MyQueuedMessage> {
+  async handle(message: MyQueuedMessage): Promise<void> {
+    console.log('HELLO, WORLD!');
+    console.log(JSON.stringify(message, null, 2));
+  }
+}
+
+// obviously you need to register all of your stuff
+const container = bootstrap();
+// triginta doesn't depend on containr but it abstracts out the creation of your handler
+// so that you can easily plug it in (see the `factory` property)
+const lambdaFactory = container.get<ILambdaFactory>();
+
+export const handler = lambdaFactory.createSqsLambda<MyLambda>({
+  factory: () => container.get<MyLambda>('lambda'),
+});
+```

package/lib/Decorators.d.ts

@@ -0,0 +1,14 @@
+import { IConfiguredRoute } from './IConfiguredRoute';
+export declare const endpointMetadataKey: unique symbol;
+export declare function getRoute(target: Function): IConfiguredRoute | undefined;
+export declare function httpGet(route: string): (target: Object) => void;
+export declare function httpPut(route: string): (target: Object) => void;
+export declare function httpDelete(route: string): (target: Object) => void;
+export declare function httpPost(route: string): (target: Object) => void;
+/**
+ * This is exposed internally for testing.
+ * There shouldn't be a need to export this publicly
+ */
+export declare const middlewareMetadataKey: unique symbol;
+export declare function useMiddleware(...args: any[]): (target: Object) => void;
+export declare function getMiddleware(target: any): any[] | undefined;

package/lib/Decorators.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMiddleware = exports.useMiddleware = exports.middlewareMetadataKey = exports.httpPost = exports.httpDelete = exports.httpPut = exports.httpGet = exports.getRoute = exports.endpointMetadataKey = void 0;
+const RouteRegistry_1 = __importDefault(require("./RouteRegistry"));
+/* eslint-disable @typescript-eslint/ban-types */
+exports.endpointMetadataKey = Symbol('@endpointMetadataKey');
+function defineEndpointMetadata(method, route) {
+    return (target) => {
+        const params = { method, route, constructor: target };
+        Reflect.defineMetadata(exports.endpointMetadataKey, params, target);
+        RouteRegistry_1.default.register(params);
+    };
+}
+function getRoute(target) {
+    return Reflect.getMetadata(exports.endpointMetadataKey, target);
+}
+exports.getRoute = getRoute;
+function httpGet(route) {
+    return defineEndpointMetadata('get', route);
+}
+exports.httpGet = httpGet;
+function httpPut(route) {
+    return defineEndpointMetadata('put', route);
+}
+exports.httpPut = httpPut;
+function httpDelete(route) {
+    return defineEndpointMetadata('delete', route);
+}
+exports.httpDelete = httpDelete;
+function httpPost(route) {
+    return defineEndpointMetadata('post', route);
+}
+exports.httpPost = httpPost;
+/**
+ * This is exposed internally for testing.
+ * There shouldn't be a need to export this publicly
+ */
+exports.middlewareMetadataKey = Symbol('@middlewareMetadataKey');
+function useMiddleware(...args) {
+    return (target) => {
+        let params = Reflect.getMetadata(exports.middlewareMetadataKey, target) || [];
+        params = params.concat(args);
+        Reflect.defineMetadata(exports.middlewareMetadataKey, params, target);
+    };
+}
+exports.useMiddleware = useMiddleware;
+function getMiddleware(target) {
+    return Reflect.getMetadata(exports.middlewareMetadataKey, target);
+}
+exports.getMiddleware = getMiddleware;

package/lib/HttpLambda.d.ts

@@ -0,0 +1,20 @@
+import { IServiceContainer, IServiceModule, Newable } from '@aesop-fables/containr';
+import { APIGatewayProxyEventV2, Handler } from 'aws-lambda';
+import { IHttpEndpoint } from './IHttpEndpoint';
+export declare type NonNoisyEvent = Omit<APIGatewayProxyEventV2, 'requestContext'>;
+export interface BootstrappedHttpLambdaContext {
+    createHttpLambda<Input, Output>(newable: Newable<IHttpEndpoint<Input, Output>>): Handler<APIGatewayProxyEventV2, Output>;
+}
+export interface IHttpLambdaFactory {
+    createHandler<Input, Output>(newable: Newable<IHttpEndpoint<Input, Output>>): Handler<APIGatewayProxyEventV2, Output>;
+}
+export declare class HttpLambdaFactory implements IHttpLambdaFactory {
+    private readonly container;
+    constructor(container: IServiceContainer);
+    createHandler<Input, Output>(newable: Newable<IHttpEndpoint<Input, Output>>): Handler<APIGatewayProxyEventV2, Output>;
+}
+export declare const useTrigintaHttp: IServiceModule;
+export declare class HttpLambda {
+    static initialize(modules?: IServiceModule[]): BootstrappedHttpLambdaContext;
+    static getContainer(): IServiceContainer;
+}

package/lib/HttpLambda.js

@@ -0,0 +1,78 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpLambda = exports.useTrigintaHttp = exports.HttpLambdaFactory = void 0;
+/* eslint-disable @typescript-eslint/ban-types */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const containr_1 = require("@aesop-fables/containr");
+const core_1 = __importDefault(require("@middy/core"));
+const Decorators_1 = require("./Decorators");
+const HttpLambdaServices_1 = require("./HttpLambdaServices");
+class HttpLambdaFactory {
+    constructor(container) {
+        this.container = container;
+    }
+    createHandler(newable) {
+        const handler = (event) => __awaiter(this, void 0, void 0, function* () {
+            const childContainer = this.container.createChildContainer('httpLambda');
+            try {
+                const endpoint = this.container.resolve(newable);
+                const { body: request } = event;
+                const response = (yield endpoint.handle(request, event));
+                return response;
+            }
+            finally {
+                if (childContainer) {
+                    try {
+                        childContainer.dispose();
+                    }
+                    catch (_a) {
+                        // no-op
+                    }
+                }
+            }
+        });
+        const middlewareMetadata = (0, Decorators_1.getMiddleware)(newable);
+        if (middlewareMetadata) {
+            let midHandler = (0, core_1.default)(handler);
+            middlewareMetadata.forEach((midFunc) => {
+                midHandler = midHandler.use(midFunc());
+            });
+            return midHandler;
+        }
+        return handler;
+    }
+}
+exports.HttpLambdaFactory = HttpLambdaFactory;
+exports.useTrigintaHttp = (0, containr_1.createServiceModule)('triginta/http', (services) => {
+    services.register(HttpLambdaServices_1.HttpLambdaServices.HttpLambdaFactory, (container) => new HttpLambdaFactory(container));
+});
+let _currentContainer;
+class HttpLambda {
+    static initialize(modules = []) {
+        const container = (0, containr_1.createContainer)([exports.useTrigintaHttp, ...modules]);
+        _currentContainer = container;
+        return {
+            createHttpLambda(newable) {
+                const factory = container.get(HttpLambdaServices_1.HttpLambdaServices.HttpLambdaFactory);
+                return factory.createHandler(newable);
+            },
+        };
+    }
+    static getContainer() {
+        return _currentContainer;
+    }
+}
+exports.HttpLambda = HttpLambda;

package/lib/HttpLambdaServices.d.ts

@@ -0,0 +1,3 @@
+export declare const HttpLambdaServices: {
+    HttpLambdaFactory: string;
+};

package/lib/HttpLambdaServices.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpLambdaServices = void 0;
+exports.HttpLambdaServices = {
+    HttpLambdaFactory: 'HttpLambdaFactory',
+};

package/lib/IConfiguredRoute.d.ts

@@ -0,0 +1,5 @@
+export interface IConfiguredRoute {
+    constructor: Function;
+    method: string;
+    route: string;
+}

package/lib/IConfiguredRoute.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/IHandler.d.ts

@@ -0,0 +1,3 @@
+export interface IHandler<Message, Event = any, Return = void> {
+    handle(message: Message, event: Event): Promise<Return>;
+}

package/lib/IHandler.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/IHttpEndpoint.d.ts

@@ -0,0 +1,4 @@
+import { APIGatewayProxyEventV2 } from 'aws-lambda';
+import { IHandler } from './IHandler';
+export interface IHttpEndpoint<Input, Output> extends IHandler<Input, APIGatewayProxyEventV2, Output> {
+}

package/lib/IHttpEndpoint.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Middleware.d.ts

@@ -0,0 +1,10 @@
+import middy from '@middy/core';
+export declare const errorWrapper: () => {
+    onError: (handler: middy.HandlerLambda, next: middy.NextFunction) => void;
+};
+export declare const convertNullTo200: () => {
+    after: (handler: middy.HandlerLambda, next: middy.NextFunction) => void;
+};
+export declare const xssFilter: () => {
+    before: (handler: middy.HandlerLambda) => Promise<void>;
+};

package/lib/Middleware.js

@@ -0,0 +1,72 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xssFilter = exports.convertNullTo200 = exports.errorWrapper = void 0;
+const xss_1 = __importDefault(require("xss"));
+const errorWrapper = () => ({
+    onError: (handler, next) => {
+        if (handler.error) {
+            handler.response = {
+                statusCode: 400,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Headers': '*',
+                    'Access-Control-Allow-Methods': '*',
+                },
+                body: JSON.stringify({
+                    error: handler.error,
+                }),
+            };
+            return next();
+        }
+        return next(handler.error);
+    },
+});
+exports.errorWrapper = errorWrapper;
+const convertNullTo200 = () => ({
+    after: (handler, next) => {
+        if (handler.response === null) {
+            handler.response = {
+                statusCode: 200,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Headers': '*',
+                    'Access-Control-Allow-Methods': '*',
+                },
+                body: '',
+            };
+        }
+        return next();
+    },
+});
+exports.convertNullTo200 = convertNullTo200;
+const xssFilter = () => ({
+    before: (handler) => __awaiter(void 0, void 0, void 0, function* () {
+        const { event } = handler;
+        const { body } = event;
+        if (body) {
+            const keys = Object.keys(body);
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i];
+                const value = body[key];
+                if (value && typeof value === 'string') {
+                    body[key] = (0, xss_1.default)(value);
+                }
+            }
+        }
+    }),
+});
+exports.xssFilter = xssFilter;

package/lib/RouteRegistry.d.ts

@@ -0,0 +1,8 @@
+import { IConfiguredRoute } from './IConfiguredRoute';
+declare class RouteRegistry {
+    private readonly routes;
+    allRoutes(): IConfiguredRoute[];
+    register(route: IConfiguredRoute): void;
+}
+declare const _default: RouteRegistry;
+export default _default;

package/lib/RouteRegistry.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RouteRegistry {
+    constructor() {
+        this.routes = [];
+    }
+    allRoutes() {
+        return this.routes;
+    }
+    register(route) {
+        this.routes.push(route);
+    }
+}
+exports.default = new RouteRegistry();

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+import { IHandler } from './IHandler';
+import { IHttpEndpoint } from './IHttpEndpoint';
+export * from './Decorators';
+export * from './Middleware';
+export * from './HttpLambda';
+export * from './HttpLambdaServices';
+export * from './RouteRegistry';
+export * from './invokeHttpHandler';
+export { IHandler, IHttpEndpoint };

package/lib/index.js

@@ -0,0 +1,22 @@
+"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("./Decorators"), exports);
+__exportStar(require("./Middleware"), exports);
+__exportStar(require("./HttpLambda"), exports);
+__exportStar(require("./HttpLambdaServices"), exports);
+__exportStar(require("./RouteRegistry"), exports);
+__exportStar(require("./invokeHttpHandler"), exports);

package/lib/invokeHttpHandler.d.ts

@@ -0,0 +1,11 @@
+import { APIGatewayProxyEventPathParameters, APIGatewayProxyEventV2 } from 'aws-lambda';
+import { IConfiguredRoute } from './IConfiguredRoute';
+export interface InvocationContext {
+    configuredRoute: IConfiguredRoute;
+    body?: any;
+    path: string;
+}
+export declare function parseRouteParams(route: string, path: string): APIGatewayProxyEventPathParameters;
+export declare function parsePathParameters(context: InvocationContext): Partial<APIGatewayProxyEventV2>;
+export declare function createApiGatewayEvent(context: InvocationContext): Partial<APIGatewayProxyEventV2>;
+export declare function invokeHttpHandler<Output>(context: InvocationContext): Promise<Output>;

package/lib/invokeHttpHandler.js

@@ -0,0 +1,145 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeHttpHandler = exports.createApiGatewayEvent = exports.parsePathParameters = exports.parseRouteParams = void 0;
+const HttpLambda_1 = require("./HttpLambda");
+const node_querystring_1 = __importDefault(require("node:querystring"));
+const HttpLambdaServices_1 = require("./HttpLambdaServices");
+function normalizeAndParse(input) {
+    let valueToParse = input;
+    if (valueToParse.endsWith('/')) {
+        valueToParse = valueToParse.substring(0, valueToParse.length - 1);
+    }
+    if (!valueToParse.startsWith('/')) {
+        valueToParse = `/${valueToParse}`;
+    }
+    return valueToParse.split('/').filter((x) => x.trim() !== '');
+}
+function parseRouteParams(route, path) {
+    let routeToParse = route;
+    if (routeToParse.endsWith('/')) {
+        routeToParse = routeToParse.substring(0, routeToParse.length - 1);
+    }
+    if (!routeToParse.startsWith('/')) {
+        routeToParse = `/${routeToParse}`;
+    }
+    const routeParts = normalizeAndParse(route);
+    const pathParts = normalizeAndParse(path);
+    if (routeParts.length !== pathParts.length) {
+        throw new Error(`Missing route parameters`);
+    }
+    const params = {};
+    for (let i = 0; i < routeParts.length; i++) {
+        const part = routeParts[i];
+        const result = /\{([\w]*)\}/g.exec(part);
+        if (result) {
+            const paramKey = result[1];
+            const value = pathParts[i];
+            params[paramKey] = value;
+        }
+    }
+    return params;
+}
+exports.parseRouteParams = parseRouteParams;
+function parsePathParameters(context) {
+    const { path } = context;
+    let queryStringParameters = {};
+    if (path.indexOf('?') !== -1) {
+        const values = path.split('?');
+        if (values.length > 1) {
+            queryStringParameters = node_querystring_1.default.parse(values[1]);
+        }
+    }
+    return {
+        rawPath: path,
+        pathParameters: parseRouteParams(context.configuredRoute.route, context.path),
+        queryStringParameters,
+    };
+}
+exports.parsePathParameters = parsePathParameters;
+function createApiGatewayEvent(context) {
+    const { configuredRoute, path, body } = context;
+    const routeKey = `${configuredRoute.method} ${configuredRoute.route}`;
+    const event = {
+        version: '2.0',
+        routeKey,
+        headers: {
+            accept: '*/*',
+            'accept-encoding': 'gzip, deflate, br',
+            // 'content-length': '0',
+            // 'content-type': 'application/json',
+            host: '',
+            'user-agent': 'triginta/1.0',
+            'x-amzn-trace-id': 'Root=1-63e26f79-577a8db87d3b31fa4da65566',
+            'x-forwarded-for': '127.0.0.1',
+            'x-forwarded-port': '80',
+            'x-forwarded-proto': 'http',
+        },
+        requestContext: {
+            accountId: '888888888888',
+            apiId: 'trigintaLocal',
+            domainName: '',
+            domainPrefix: '',
+            http: {
+                method: configuredRoute.method,
+                path,
+                protocol: 'HTTP/1.1',
+                sourceIp: '127.0.0.1',
+                userAgent: 'triginta/1.0',
+            },
+            requestId: '1234',
+            routeKey,
+            stage: '$default',
+            time: '',
+            timeEpoch: Date.now(),
+        },
+        body: body ? JSON.stringify(body) : undefined,
+    };
+    return event;
+}
+exports.createApiGatewayEvent = createApiGatewayEvent;
+// TODO -- We need to rename this to make it clear that it's for testing ONLY
+function invokeHttpHandler(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const container = HttpLambda_1.HttpLambda.getContainer();
+        const factory = container.get(HttpLambdaServices_1.HttpLambdaServices.HttpLambdaFactory);
+        const configuredHandler = factory.createHandler(context.configuredRoute.constructor);
+        return configuredHandler(createApiGatewayEvent(context), {
+            callbackWaitsForEmptyEventLoop: false,
+            functionName: 'httpLambda',
+            functionVersion: '0.1',
+            invokedFunctionArn: 'arn::test',
+            memoryLimitInMB: '128',
+            awsRequestId: '1234',
+            logGroupName: 'test-group',
+            logStreamName: 'test-stream',
+            getRemainingTimeInMillis: function () {
+                throw new Error('Function not implemented.');
+            },
+            done: function (error, result) {
+                throw new Error('Function not implemented.');
+            },
+            fail: function (error) {
+                throw new Error('Function not implemented.');
+            },
+            succeed: function (messageOrObject) {
+                throw new Error('Function not implemented.');
+            },
+        }, () => {
+            // no-op
+            throw new Error('Not supported');
+        });
+    });
+}
+exports.invokeHttpHandler = invokeHttpHandler;

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@aesop-fables/triginta",
+  "version": "0.2.0",
+  "description": "A lightweight framework that wraps the basic infrastructure usages of AWS Lambda (SQS, Kinesis, etc.).",
+  "type": "commonjs",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    }
+  },
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "scripts": {
+    "build": "rimraf ./lib && tsc --p ./tsconfig.build.json",
+    "format": "prettier --write \"src/**/*.(js|ts)\"",
+    "lint": "eslint src --ext .js,.ts",
+    "lint:fix": "eslint src --fix --ext .js,.ts",
+    "test": "jest --config jest.config.js",
+    "test:watch": "jest --config jest.config.js --watch",
+    "prepublishOnly": "npm test && npm run lint",
+    "preversion": "npm run lint",
+    "version": "npm run format && git add -A src",
+    "postversion": "git push && git push --tags"
+  },
+  "devDependencies": {
+    "@aesop-fables/containr": "^0.1.5",
+    "@types/aws-lambda": "^8.10.109",
+    "@types/jest": "^29.2.4",
+    "@types/node": "^18.11.11",
+    "@typescript-eslint/eslint-plugin": "^5.45.1",
+    "@typescript-eslint/parser": "5.45.0",
+    "esbuild": "^0.16.2",
+    "eslint": "8.29.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-jest": "27.1.6",
+    "eslint-plugin-prettier": "^4.2.1",
+    "jest": "29.3.1",
+    "jest-mock-extended": "^3.0.1",
+    "prettier": "^2.8.1",
+    "ts-jest": "29.0.1",
+    "typescript": "4.9.3"
+  },
+  "files": [
+    "lib/**/*"
+  ],
+  "dependencies": {
+    "@middy/core": "^1.5.2",
+    "@middy/http-error-handler": "^1.5.2",
+    "@middy/http-json-body-parser": "^1.5.2",
+    "reflect-metadata": "^0.1.13",
+    "xss": "^1.0.9"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/aesop-fables/typescript-libraries.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}