@aesop-fables/triginta 0.1.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,24 @@
+# @aesop-fables/triginta
+
+`triginta` is a lightweight framework that wraps the basic infrastructure usages of AWS Lambda (SQS, Kinesis, etc.) and is entirely based on top of Middyjs. 
+
+## Installation
+```
+npm install @aesop-fables/triginta
+```
+```
+yarn add @aesop-fables/triginta
+```
+
+## Docs
+
+Docs are coming. In the meantime, we recommend you checkout the docs from middyjs and our example repo: 
+https://github.com/aesop-fables/triginta-example
+
+
+## Breaking Changes
+
+### v0.4.0
+
+The `path` property of the `InvocationContext` (used in `invokeHttpHandler`) was renamed to `rawPath` to properly match the 
+expected API Gateway Event.

package/lib/AwsServices.d.ts

@@ -0,0 +1,4 @@
+export declare const AwsServices: {
+    Context: string;
+    Event: string;
+};

package/lib/AwsServices.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsServices = void 0;
+const Utils_1 = require("./Utils");
+const keyFor = (0, Utils_1.createServiceNamespacer)('aws');
+exports.AwsServices = {
+    Context: keyFor('context'),
+    Event: keyFor('event'),
+};

package/lib/Bootstrapping.d.ts

@@ -0,0 +1,36 @@
+import { IServiceContainer, IServiceModule } from '@aesop-fables/containr';
+import { ISqsRecordMatcher } from './sqs/RecordMatchers';
+import { BootstrappedHttpLambdaContext } from './http/HttpLambda';
+import { BootstrappedSqsLambdaContext } from './sqs/SqsLambda';
+import { BootstrappedS3LambdaContext } from './s3/S3Lambda';
+declare type Placeholder = object;
+interface AwsServiceCollection {
+    http: Placeholder;
+    s3: Placeholder;
+    sqs: Placeholder;
+}
+declare type ConfiguredServices<T> = {
+    [Property in keyof AwsServiceCollection]: T;
+};
+interface BootstrappedTrigintaApp extends BootstrappedHttpLambdaContext, BootstrappedSqsLambdaContext, BootstrappedS3LambdaContext {
+    containers: ConfiguredServices<IServiceContainer>;
+}
+export interface AwsServiceOptions {
+    modules: IServiceModule[];
+}
+export interface TrigintaHttpOptions extends AwsServiceOptions {
+}
+export interface TrigintaS3Options extends AwsServiceOptions {
+}
+export interface TrigintaSqsOptions extends AwsServiceOptions {
+    matchers?: ISqsRecordMatcher[];
+}
+export interface TrigintaOptions {
+    http?: TrigintaHttpOptions;
+    s3?: TrigintaS3Options;
+    sqs?: TrigintaSqsOptions;
+}
+export declare const useTriginta: IServiceModule;
+export declare const useAwsServices: IServiceModule;
+export declare function createTrigintaApp(options: TrigintaOptions): BootstrappedTrigintaApp;
+export {};

package/lib/Bootstrapping.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTrigintaApp = exports.useAwsServices = exports.useTriginta = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const containr_1 = require("@aesop-fables/containr");
+const http_1 = require("./http");
+const HttpLambda_1 = require("./http/HttpLambda");
+const localization_1 = require("./localization");
+const validation_1 = require("./validation");
+const SqsLambda_1 = require("./sqs/SqsLambda");
+const S3Lambda_1 = require("./s3/S3Lambda");
+const TrigintaServices_1 = require("./TrigintaServices");
+const ITrigintaRuntimeFactory_1 = require("./ITrigintaRuntimeFactory");
+const AwsServices_1 = require("./AwsServices");
+exports.useTriginta = (0, containr_1.createServiceModule)((0, TrigintaServices_1.createCoreKey)('bootstrap'), (services) => {
+    services.autoResolve(TrigintaServices_1.TrigintaServices.RuntimeFactory, ITrigintaRuntimeFactory_1.TrigintaRuntimeFactory, containr_1.Scopes.Transient);
+});
+// The individual middlewares setup the runtime in the child container
+// We're registering this here so that the defaults are in place
+exports.useAwsServices = (0, containr_1.createServiceModule)((0, TrigintaServices_1.createCoreKey)('bootstrap'), (services) => {
+    services.factory(AwsServices_1.AwsServices.Context, (container) => {
+        const runtime = container.get(TrigintaServices_1.TrigintaServices.Runtime);
+        return runtime.context;
+    }, containr_1.Scopes.Transient);
+    services.factory(AwsServices_1.AwsServices.Event, (container) => {
+        const runtime = container.get(TrigintaServices_1.TrigintaServices.Runtime);
+        return runtime.event;
+    }, containr_1.Scopes.Transient);
+});
+function createTrigintaApp(options) {
+    const containers = {};
+    Object.keys(options).forEach((key) => {
+        var _a, _b;
+        const serviceKey = key;
+        const serviceOptions = (_a = options[key]) !== null && _a !== void 0 ? _a : {};
+        const { modules = [] } = (_b = options[key]) !== null && _b !== void 0 ? _b : {};
+        let container;
+        switch (serviceKey) {
+            case 'http':
+                container = (0, containr_1.createContainer)([
+                    exports.useTriginta,
+                    exports.useAwsServices,
+                    HttpLambda_1.useTrigintaHttp,
+                    http_1.useHttpServices,
+                    localization_1.useLocalization,
+                    validation_1.useHttpValidation,
+                    ...modules,
+                ]);
+                break;
+            case 's3':
+                container = (0, containr_1.createContainer)([exports.useTriginta, exports.useAwsServices, S3Lambda_1.useTrigintaS3, ...modules]);
+                break;
+            case 'sqs':
+                const { matchers = [] } = serviceOptions;
+                container = (0, containr_1.createContainer)([exports.useTriginta, exports.useAwsServices, (0, SqsLambda_1.useTrigintaSqs)({ matchers }), ...modules]);
+                break;
+        }
+        if (container) {
+            containers[serviceKey] = container;
+        }
+    });
+    return Object.assign(Object.assign(Object.assign(Object.assign({}, (0, HttpLambda_1.createBootstrappedHttpLambdaContext)(containers.http)), (0, SqsLambda_1.createBootstrappedSqsLambdaContext)(containers.sqs)), (0, S3Lambda_1.createBootstrappedS3LambdaContext)(containers.s3)), { containers });
+}
+exports.createTrigintaApp = createTrigintaApp;

package/lib/Decorators.d.ts

@@ -0,0 +1,14 @@
+import { IConfiguredRoute } from './http/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/EventSource.d.ts

@@ -0,0 +1 @@
+export declare type EventSource = 'sqs' | 's3' | 'http';

package/lib/EventSource.js

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

package/lib/IHandler.d.ts

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

package/lib/IHandler.js

@@ -0,0 +1,3 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/ITrigintaRuntime.d.ts

@@ -0,0 +1,12 @@
+import { Disposable, IServiceContainer } from '@aesop-fables/containr';
+import { EventSource } from './EventSource';
+import { APIGatewayEventRequestContextV2, APIGatewayProxyEventV2, Context, S3Event, SQSEvent } from 'aws-lambda';
+export interface ITrigintaRuntime<TEvent, TContext> extends Disposable {
+    container: IServiceContainer;
+    context: TContext;
+    event: TEvent;
+    source: EventSource;
+}
+export declare type ITrigintaHttpRuntime = ITrigintaRuntime<APIGatewayProxyEventV2, APIGatewayEventRequestContextV2>;
+export declare type ITrigintaS3Runtime = ITrigintaRuntime<S3Event, Context>;
+export declare type ITrigintaSqsRuntime = ITrigintaRuntime<SQSEvent, Context>;

package/lib/ITrigintaRuntime.js

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

package/lib/ITrigintaRuntimeFactory.d.ts

@@ -0,0 +1,17 @@
+import middy from '@middy/core';
+import { Context } from 'aws-lambda';
+import { ITrigintaRuntime } from './ITrigintaRuntime';
+import { IServiceContainer, IServiceModule } from '@aesop-fables/containr';
+import { EventSource } from './EventSource';
+export interface TrigintaRuntimeOptions {
+    overrides: IServiceModule[];
+    source: EventSource;
+}
+export interface ITrigintaRuntimeFactory {
+    createRuntime<TEvent, TContext extends Context>(request: middy.Request<TEvent, any, Error, TContext>, options: TrigintaRuntimeOptions): Promise<ITrigintaRuntime<TEvent, TContext>>;
+}
+export declare class TrigintaRuntimeFactory implements ITrigintaRuntimeFactory {
+    private readonly container;
+    constructor(container: IServiceContainer);
+    createRuntime<TEvent, TContext extends Context>(request: middy.Request<TEvent, any, Error, TContext>, options: TrigintaRuntimeOptions): Promise<ITrigintaRuntime<TEvent, TContext>>;
+}

package/lib/ITrigintaRuntimeFactory.js

@@ -0,0 +1,61 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrigintaRuntimeFactory = void 0;
+const containr_1 = require("@aesop-fables/containr");
+const Utils_1 = require("./Utils");
+const TrigintaServices_1 = require("./TrigintaServices");
+const namespacer = (0, Utils_1.createServiceNamespacer)('runtime');
+const factoryModule = namespacer('factory');
+function embedRuntime(runtime) {
+    return (0, containr_1.createServiceModule)(namespacer('embedRuntime'), (services) => {
+        services.singleton(TrigintaServices_1.TrigintaServices.Runtime, runtime);
+    });
+}
+let TrigintaRuntimeFactory = class TrigintaRuntimeFactory {
+    constructor(container) {
+        this.container = container;
+    }
+    createRuntime(request, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { context, event } = request;
+            const runtime = {
+                context,
+                event,
+                source: options.source,
+            };
+            const overrides = [embedRuntime(runtime), ...options.overrides];
+            const container = this.container.createChildContainer(factoryModule, overrides);
+            runtime.container = container;
+            runtime.dispose = () => {
+                container === null || container === void 0 ? void 0 : container.dispose();
+            };
+            return runtime;
+        });
+    }
+};
+TrigintaRuntimeFactory = __decorate([
+    __param(0, (0, containr_1.injectContainer)()),
+    __metadata("design:paramtypes", [Object])
+], TrigintaRuntimeFactory);
+exports.TrigintaRuntimeFactory = TrigintaRuntimeFactory;

package/lib/RouteRegistry.d.ts

@@ -0,0 +1,12 @@
+import { IConfiguredRoute } from './http/IConfiguredRoute';
+export interface IRouteRegistry {
+    allRoutes(): IConfiguredRoute[];
+    register(route: IConfiguredRoute): void;
+}
+declare class RouteRegistry implements IRouteRegistry {
+    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/TrigintaConfig.d.ts

@@ -0,0 +1,6 @@
+import { IServiceContainer } from '@aesop-fables/containr';
+import { IRouteRegistry } from './RouteRegistry';
+export declare type TrigintaConfig = {
+    container: IServiceContainer;
+    routes: IRouteRegistry;
+};

package/lib/TrigintaConfig.js

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

package/lib/TrigintaHeaders.d.ts

@@ -0,0 +1,3 @@
+export declare const TrigintaHeaders: {
+    LogLevel: string;
+};

package/lib/TrigintaHeaders.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrigintaHeaders = void 0;
+exports.TrigintaHeaders = {
+    LogLevel: 'X-Log-Level',
+};

package/lib/TrigintaMiddleware.d.ts

@@ -0,0 +1,20 @@
+import { IServiceContainer, IServiceModule } from '@aesop-fables/containr';
+import middy from '@middy/core';
+import { Context } from 'aws-lambda';
+import { ITrigintaRuntime } from './ITrigintaRuntime';
+import { EventSource } from './EventSource';
+export interface TrigintaMiddlewareOptions {
+    container: IServiceContainer;
+    overrides: IServiceModule[];
+    source: EventSource;
+}
+export declare function resolveTrigintaRuntime<TEvent, TContext extends Context = Context>(context: TContext): ITrigintaRuntime<TEvent, TContext>;
+export declare function trigintaMiddlware<TEvent, TContext extends Context = Context>(options: TrigintaMiddlewareOptions): {
+    after: middy.MiddlewareFn<TEvent, any, Error, TContext>;
+    before: middy.MiddlewareFn<TEvent, any, Error, TContext>;
+};
+interface MiddyHandler<TEvent, TContext extends Context = Context> {
+    (event: TEvent, context: TContext): Promise<any>;
+}
+export declare function trigintafy<TEvent, TContext extends Context = Context>(handler: MiddyHandler<TEvent, TContext>, middlewareMetadata: any[], options: TrigintaMiddlewareOptions): middy.MiddyfiedHandler<TEvent, any, Error, Context & TContext>;
+export {};

package/lib/TrigintaMiddleware.js

@@ -0,0 +1,49 @@
+"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.trigintafy = exports.trigintaMiddlware = exports.resolveTrigintaRuntime = void 0;
+const core_1 = __importDefault(require("@middy/core"));
+const Utils_1 = require("./Utils");
+const TrigintaServices_1 = require("./TrigintaServices");
+const runtimeContextKey = (0, Utils_1.createServiceNamespacer)('runtime')('context');
+function resolveTrigintaRuntime(context) {
+    return context[runtimeContextKey];
+}
+exports.resolveTrigintaRuntime = resolveTrigintaRuntime;
+function trigintaMiddlware(options) {
+    const before = (request) => __awaiter(this, void 0, void 0, function* () {
+        const factory = options.container.get(TrigintaServices_1.TrigintaServices.RuntimeFactory);
+        const runtime = yield factory.createRuntime(request, {
+            overrides: options.overrides,
+            source: options.source,
+        });
+        const context = request.context;
+        context[runtimeContextKey] = runtime;
+    });
+    const after = (request) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        (_a = resolveTrigintaRuntime(request.context)) === null || _a === void 0 ? void 0 : _a.dispose();
+    });
+    return { after, before };
+}
+exports.trigintaMiddlware = trigintaMiddlware;
+function trigintafy(handler, middlewareMetadata, options) {
+    let midHandler = (0, core_1.default)(handler).use(trigintaMiddlware(options));
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    middlewareMetadata.forEach((midFunc) => {
+        midHandler = midHandler.use(midFunc());
+    });
+    return midHandler;
+}
+exports.trigintafy = trigintafy;

package/lib/TrigintaServices.d.ts

@@ -0,0 +1,5 @@
+export declare const createCoreKey: (key: string) => string;
+export declare const TrigintaServices: {
+    Runtime: string;
+    RuntimeFactory: string;
+};

package/lib/TrigintaServices.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrigintaServices = exports.createCoreKey = void 0;
+const Utils_1 = require("./Utils");
+exports.createCoreKey = (0, Utils_1.createServiceNamespacer)('core');
+exports.TrigintaServices = {
+    Runtime: (0, exports.createCoreKey)('runtime'),
+    RuntimeFactory: (0, exports.createCoreKey)('runtimeFactory'),
+};

package/lib/Utils.d.ts

@@ -0,0 +1 @@
+export declare function createServiceNamespacer(prefix: string): (key: string) => string;

package/lib/Utils.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServiceNamespacer = void 0;
+function createServiceNamespacer(prefix) {
+    return (key) => {
+        return `@aesop-fables/triginta/${prefix}/${key}`;
+    };
+}
+exports.createServiceNamespacer = createServiceNamespacer;

package/lib/http/HttpCultureContext.d.ts

@@ -0,0 +1,7 @@
+import { APIGatewayProxyEventV2 } from 'aws-lambda';
+import { ICultureContext } from '../localization/ICultureContext';
+export declare class HttpCultureContext implements ICultureContext {
+    private readonly event;
+    constructor(event: APIGatewayProxyEventV2);
+    detectCulture(): string;
+}

package/lib/http/HttpCultureContext.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpCultureContext = void 0;
+class HttpCultureContext {
+    constructor(event) {
+        this.event = event;
+    }
+    detectCulture() {
+        var _a;
+        const defaultCulture = 'en-US';
+        if (this.event.headers) {
+            return (_a = this.event.headers['Accept-Language']) !== null && _a !== void 0 ? _a : defaultCulture;
+        }
+        return defaultCulture;
+    }
+}
+exports.HttpCultureContext = HttpCultureContext;

package/lib/http/HttpLambda.d.ts

@@ -0,0 +1,29 @@
+import { IServiceContainer, Newable } from '@aesop-fables/containr';
+import { APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2, Handler } from 'aws-lambda';
+import { IHttpEndpoint, IHttpEventHandler } from './IHttpEndpoint';
+import { IConfiguredRoute } from './IConfiguredRoute';
+export declare type NonNoisyEvent = Omit<APIGatewayProxyEventV2, 'requestContext'>;
+export interface BootstrappedHttpLambdaContext {
+    createHttpEventHandler<Output>(newable: Newable<IHttpEventHandler<Output>>): Handler<APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2>;
+    createHttpHandler<Input, Output>(newable: Newable<IHttpEndpoint<Input, Output>>): Handler<APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2>;
+}
+export interface IHttpLambdaFactory {
+    createHandler<Input, Output>(newable: Newable<IHttpEndpoint<Input, Output> | IHttpEventHandler<Output>>): Handler<APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2>;
+    createEventHandler<Output>(newable: Newable<IHttpEventHandler<Output>>): Handler<APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2>;
+}
+export interface IHttpResponseGenerator {
+    generateResponse(response?: any): Promise<APIGatewayProxyStructuredResultV2>;
+}
+export declare class HttpResponseGenerator implements IHttpResponseGenerator {
+    private readonly configuredRoute;
+    constructor(configuredRoute: IConfiguredRoute);
+    generateResponse(response?: any): Promise<APIGatewayProxyStructuredResultV2>;
+}
+export declare class HttpLambdaFactory implements IHttpLambdaFactory {
+    private readonly container;
+    constructor(container: IServiceContainer);
+    createEventHandler<Output>(newable: Newable<IHttpEventHandler<Output>>): Handler<APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2>;
+    createHandler<Input, Output>(newable: Newable<IHttpEndpoint<Input, Output> | IHttpEventHandler<Output>>): Handler<APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2>;
+}
+export declare const useTrigintaHttp: import("@aesop-fables/containr").IServiceModule;
+export declare function createBootstrappedHttpLambdaContext(container: IServiceContainer): BootstrappedHttpLambdaContext;