@aesop-fables/triginta 0.7.5 → 0.8.1

package/lib/Bootstrapping.d.ts

@@ -0,0 +1,34 @@
+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 AwsServices {
+    http: Placeholder;
+    s3: Placeholder;
+    sqs: Placeholder;
+}
+declare type ConfiguredServices<T> = {
+    [Property in keyof AwsServices]: 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 function createTrigintaApp(options: TrigintaOptions): BootstrappedTrigintaApp;
+export {};

package/lib/Bootstrapping.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTrigintaApp = void 0;
+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");
+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)([HttpLambda_1.useTrigintaHttp, http_1.useHttpServices, localization_1.useLocalization, validation_1.useHttpValidation, ...modules]);
+                break;
+            case 's3':
+                container = (0, containr_1.createContainer)([S3Lambda_1.useTrigintaS3, ...modules]);
+                break;
+            case 'sqs':
+                const { matchers = [] } = serviceOptions;
+                container = (0, containr_1.createContainer)([(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/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/HttpLambda.d.ts

@@ -1,4 +1,4 @@
-import { IServiceContainer, IServiceModule, Newable } from '@aesop-fables/containr';
+import { IServiceContainer, Newable } from '@aesop-fables/containr';
 import { APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2, Handler } from 'aws-lambda';
 import { IHttpEndpoint, IHttpEventHandler } from './IHttpEndpoint';
 import { IConfiguredRoute } from './IConfiguredRoute';
@@ -25,8 +25,8 @@ export declare class HttpLambdaFactory implements IHttpLambdaFactory {
     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: IServiceModule;
-export declare class HttpLambda {
-    static initialize(modules?: IServiceModule[]): BootstrappedHttpLambdaContext;
-    static getContainer(): IServiceContainer;
-}
+export declare const useTrigintaHttp: import("@aesop-fables/containr").IServiceModule;
+export declare function createBootstrappedHttpLambdaContext(container: IServiceContainer): {
+    createHttpEventLambda<Output>(newable: Newable<IHttpEventHandler<Output>>): Handler<APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2>;
+    createHttpLambda<Input, Output_1>(newable: Newable<IHttpEndpoint<Input, Output_1> | IHttpEventHandler<Output_1>>): Handler<APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2>;
+};

package/lib/http/HttpLambda.js

@@ -24,7 +24,7 @@ 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 = exports.HttpResponseGenerator = void 0;
+exports.createBootstrappedHttpLambdaContext = exports.useTrigintaHttp = exports.HttpLambdaFactory = exports.HttpResponseGenerator = void 0;
 /* eslint-disable @typescript-eslint/ban-types */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unused-vars */
@@ -32,9 +32,6 @@ const containr_1 = require("@aesop-fables/containr");
 const core_1 = __importDefault(require("@middy/core"));
 const Decorators_1 = require("../Decorators");
 const HttpLambdaServices_1 = require("./HttpLambdaServices");
-const _1 = require(".");
-const localization_1 = require("../localization");
-const validation_1 = require("../validation");
 let HttpResponseGenerator = class HttpResponseGenerator {
     constructor(configuredRoute) {
         this.configuredRoute = configuredRoute;
@@ -71,7 +68,7 @@ HttpResponseGenerator = __decorate([
     __metadata("design:paramtypes", [Object])
 ], HttpResponseGenerator);
 exports.HttpResponseGenerator = HttpResponseGenerator;
-class HttpLambdaFactory {
+let HttpLambdaFactory = class HttpLambdaFactory {
     constructor(container) {
         this.container = container;
     }
@@ -109,13 +106,8 @@ class HttpLambdaFactory {
             before(request) {
                 return __awaiter(this, void 0, void 0, function* () {
                     const injectContextualServices = (0, containr_1.createServiceModule)('injectContextualServices', (services) => {
-                        services.register(HttpLambdaServices_1.HttpLambdaServices.CurrentRoute, route);
-                        services.register(HttpLambdaServices_1.HttpLambdaServices.CurrentEvent, request.event);
-                        services.register(HttpLambdaServices_1.HttpLambdaServices.RequestContext, (current) => {
-                            return {
-                                container: current,
-                            };
-                        });
+                        services.singleton(HttpLambdaServices_1.HttpLambdaServices.CurrentRoute, route);
+                        services.singleton(HttpLambdaServices_1.HttpLambdaServices.CurrentEvent, request.event);
                     });
                     const childContainer = container.createChildContainer('httpLambda', [injectContextualServices]);
                     request.context['container'] = childContainer;
@@ -131,36 +123,33 @@ class HttpLambdaFactory {
         });
         return midHandler;
     }
-}
+};
+HttpLambdaFactory = __decorate([
+    __param(0, (0, containr_1.injectContainer)()),
+    __metadata("design:paramtypes", [Object])
+], HttpLambdaFactory);
 exports.HttpLambdaFactory = HttpLambdaFactory;
 exports.useTrigintaHttp = (0, containr_1.createServiceModule)('triginta/http', (services) => {
-    services.use(HttpLambdaServices_1.HttpLambdaServices.HttpResponseGenerator, HttpResponseGenerator);
-    services.register(HttpLambdaServices_1.HttpLambdaServices.HttpLambdaFactory, (container) => new HttpLambdaFactory(container));
+    services.autoResolve(HttpLambdaServices_1.HttpLambdaServices.HttpResponseGenerator, HttpResponseGenerator, containr_1.Scopes.Transient);
+    services.autoResolve(HttpLambdaServices_1.HttpLambdaServices.HttpLambdaFactory, HttpLambdaFactory, containr_1.Scopes.Transient);
 });
-let _currentContainer;
-class HttpLambda {
-    static initialize(modules = []) {
-        const container = (0, containr_1.createContainer)([
-            exports.useTrigintaHttp,
-            _1.useHttpServices,
-            localization_1.useLocalization,
-            validation_1.useHttpValidation,
-            ...modules,
-        ]);
-        _currentContainer = container;
-        return {
-            createHttpEventLambda(newable) {
-                const factory = container.get(HttpLambdaServices_1.HttpLambdaServices.HttpLambdaFactory);
-                return factory.createEventHandler(newable);
-            },
-            createHttpLambda(newable) {
-                const factory = container.get(HttpLambdaServices_1.HttpLambdaServices.HttpLambdaFactory);
-                return factory.createHandler(newable);
-            },
-        };
-    }
-    static getContainer() {
-        return _currentContainer;
+function validateContainer(container) {
+    if (typeof container === 'undefined') {
+        throw new Error(`HTTP container not initialized`);
     }
 }
-exports.HttpLambda = HttpLambda;
+function createBootstrappedHttpLambdaContext(container) {
+    return {
+        createHttpEventLambda(newable) {
+            validateContainer(container);
+            const factory = container.get(HttpLambdaServices_1.HttpLambdaServices.HttpLambdaFactory);
+            return factory.createEventHandler(newable);
+        },
+        createHttpLambda(newable) {
+            validateContainer(container);
+            const factory = container.get(HttpLambdaServices_1.HttpLambdaServices.HttpLambdaFactory);
+            return factory.createHandler(newable);
+        },
+    };
+}
+exports.createBootstrappedHttpLambdaContext = createBootstrappedHttpLambdaContext;

package/lib/http/index.js

@@ -4,12 +4,6 @@ exports.useHttpServices = void 0;
 const containr_1 = require("@aesop-fables/containr");
 const localization_1 = require("../localization");
 const HttpCultureContext_1 = require("./HttpCultureContext");
-const HttpLambdaServices_1 = require("./HttpLambdaServices");
 exports.useHttpServices = (0, containr_1.createServiceModule)('useHttpServices', (services) => {
-    services.use(localization_1.LocalizationServices.CultureContext, HttpCultureContext_1.HttpCultureContext);
-    services.register(HttpLambdaServices_1.HttpLambdaServices.RequestContext, (container) => {
-        return {
-            container,
-        };
-    });
+    services.autoResolve(localization_1.LocalizationServices.CultureContext, HttpCultureContext_1.HttpCultureContext, containr_1.Scopes.Transient);
 });

package/lib/index.d.ts

@@ -1,3 +1,4 @@
+export * from './Bootstrapping';
 export * from './IHandler';
 export * from './http/IHttpEndpoint';
 export * from './Decorators';
@@ -16,14 +17,19 @@ export * from './sqs/SqsPublisher';
 export * from './http/IConfiguredRoute';
 export * from './TrigintaConfig';
 export * from './resolveEnvironmentSettings';
+export * from './s3/IS3RecordHandler';
+export * from './s3/S3Lambda';
+export * from './s3/S3LambdaServices';
 export * as Localization from './localization';
 export * as Validation from './validation';
 import * as httpUtils from './http/invokeHttpHandler';
 import * as sqsUtils from './sqs/invokeSqsHandler';
+import * as s3Utils from './s3/invokeS3Handler';
 /**
  * Provides helper functions for invoking lambdas in unit/integration tests.
  */
 export declare const TestUtils: {
+    invokeS3Handler(context: s3Utils.S3InvocationContext): Promise<void>;
     invokeSqsHandler(context: sqsUtils.SqsInvocationContext): Promise<void>;
     parseRouteParams(route: string, path: string): import("aws-lambda").APIGatewayProxyEventPathParameters;
     parsePathParameters(context: httpUtils.EventGenerationContext): Partial<import("aws-lambda").APIGatewayProxyEventV2>;

package/lib/index.js

@@ -30,6 +30,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestUtils = exports.Validation = exports.Localization = exports.RouteRegistry = void 0;
+__exportStar(require("./Bootstrapping"), exports);
 __exportStar(require("./IHandler"), exports);
 __exportStar(require("./http/IHttpEndpoint"), exports);
 __exportStar(require("./Decorators"), exports);
@@ -49,11 +50,15 @@ __exportStar(require("./sqs/SqsPublisher"), exports);
 __exportStar(require("./http/IConfiguredRoute"), exports);
 __exportStar(require("./TrigintaConfig"), exports);
 __exportStar(require("./resolveEnvironmentSettings"), exports);
+__exportStar(require("./s3/IS3RecordHandler"), exports);
+__exportStar(require("./s3/S3Lambda"), exports);
+__exportStar(require("./s3/S3LambdaServices"), exports);
 exports.Localization = __importStar(require("./localization"));
 exports.Validation = __importStar(require("./validation"));
 const httpUtils = __importStar(require("./http/invokeHttpHandler"));
 const sqsUtils = __importStar(require("./sqs/invokeSqsHandler"));
+const s3Utils = __importStar(require("./s3/invokeS3Handler"));
 /**
  * Provides helper functions for invoking lambdas in unit/integration tests.
  */
-exports.TestUtils = Object.assign(Object.assign({}, httpUtils), sqsUtils);
+exports.TestUtils = Object.assign(Object.assign(Object.assign({}, httpUtils), sqsUtils), s3Utils);

package/lib/s3/IS3RecordHandler.d.ts

@@ -0,0 +1,4 @@
+import { S3Event, S3EventRecord } from 'aws-lambda';
+export interface IS3RecordHandler {
+    handle(record: S3EventRecord, event: S3Event): Promise<void>;
+}

package/lib/s3/IS3RecordHandler.js

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

package/lib/s3/S3Lambda.d.ts

@@ -0,0 +1,16 @@
+import { IServiceContainer, IServiceModule, Newable } from '@aesop-fables/containr';
+import { IS3RecordHandler } from './IS3RecordHandler';
+import { S3Handler } from 'aws-lambda';
+export interface BootstrappedS3LambdaContext {
+    createS3Handler(newable: Newable<IS3RecordHandler>): S3Handler;
+}
+export interface IS3LambdaFactory {
+    createHandler(newable: Newable<IS3RecordHandler>): S3Handler;
+}
+export declare const useTrigintaS3: IServiceModule;
+export declare class S3LambdaFactory implements IS3LambdaFactory {
+    private readonly container;
+    constructor(container: IServiceContainer);
+    createHandler(newable: Newable<IS3RecordHandler>): S3Handler;
+}
+export declare function createBootstrappedS3LambdaContext(container: IServiceContainer): BootstrappedS3LambdaContext;

package/lib/s3/S3Lambda.js

@@ -0,0 +1,103 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBootstrappedS3LambdaContext = exports.S3LambdaFactory = exports.useTrigintaS3 = 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 S3LambdaServices_1 = require("./S3LambdaServices");
+function embedS3Event(event) {
+    return (0, containr_1.createServiceModule)('@aesop-fables/triginta/s3/event', (services) => {
+        services.singleton(S3LambdaServices_1.S3LambdaServices.CurrentEvent, event);
+    });
+}
+function embedS3Record(record) {
+    return (0, containr_1.createServiceModule)('@aesop-fables/triginta/s3/record', (services) => {
+        services.singleton(S3LambdaServices_1.S3LambdaServices.CurrentRecord, record);
+    });
+}
+exports.useTrigintaS3 = (0, containr_1.createServiceModule)('triginta/s3', (services) => {
+    services.autoResolve(S3LambdaServices_1.S3LambdaServices.S3LambdaFactory, S3LambdaFactory, containr_1.Scopes.Transient);
+});
+let S3LambdaFactory = class S3LambdaFactory {
+    constructor(container) {
+        this.container = container;
+    }
+    createHandler(newable) {
+        const handler = (event) => __awaiter(this, void 0, void 0, function* () {
+            for (let i = 0; i < event.Records.length; i++) {
+                const record = event.Records[i];
+                const childContainer = this.container.createChildContainer('s3Lambda', [
+                    embedS3Event(event),
+                    embedS3Record(record),
+                ]);
+                try {
+                    const handler = childContainer.resolve(newable);
+                    yield handler.handle(record, event);
+                }
+                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;
+    }
+};
+S3LambdaFactory = __decorate([
+    __param(0, (0, containr_1.injectContainer)()),
+    __metadata("design:paramtypes", [Object])
+], S3LambdaFactory);
+exports.S3LambdaFactory = S3LambdaFactory;
+function createBootstrappedS3LambdaContext(container) {
+    return {
+        createS3Handler(newable) {
+            if (typeof container === 'undefined') {
+                throw new Error(`S3 container not initialized`);
+            }
+            const factory = container.get(S3LambdaServices_1.S3LambdaServices.S3LambdaFactory);
+            return factory.createHandler(newable);
+        },
+    };
+}
+exports.createBootstrappedS3LambdaContext = createBootstrappedS3LambdaContext;

package/lib/s3/S3LambdaServices.d.ts

@@ -0,0 +1,5 @@
+export declare const S3LambdaServices: {
+    S3LambdaFactory: string;
+    CurrentEvent: string;
+    CurrentRecord: string;
+};

package/lib/s3/S3LambdaServices.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3LambdaServices = void 0;
+const Utils_1 = require("../Utils");
+const namedService = (0, Utils_1.createServiceNamespacer)('s3');
+exports.S3LambdaServices = {
+    S3LambdaFactory: namedService('factory'),
+    CurrentEvent: namedService('event'),
+    CurrentRecord: namedService('record'),
+};

package/lib/s3/invokeS3Handler.d.ts

@@ -0,0 +1,12 @@
+import { S3Event } from 'aws-lambda';
+import { IServiceContainer } from '@aesop-fables/containr';
+export interface S3InvocationContext extends Partial<S3Event> {
+    handler: Function;
+    container: IServiceContainer;
+}
+/**
+ * Invokes a lambda by constructing it from the specified container
+ * @param context
+ * @returns
+ */
+export declare function invokeS3Handler(context: S3InvocationContext): Promise<void>;

package/lib/s3/invokeS3Handler.js

@@ -0,0 +1,57 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeS3Handler = void 0;
+const S3LambdaServices_1 = require("./S3LambdaServices");
+/**
+ * Invokes a lambda by constructing it from the specified container
+ * @param context
+ * @returns
+ */
+function invokeS3Handler(context) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const { container } = context;
+        const factory = container.get(S3LambdaServices_1.S3LambdaServices.S3LambdaFactory);
+        const configuredHandler = factory.createHandler(context.handler);
+        (_a = context.Records) === null || _a === void 0 ? void 0 : _a.forEach((record) => {
+            if (!record.eventSource) {
+                record.eventSource = 'aws:s3';
+            }
+        });
+        const event = Object.assign(Object.assign({}, context), { handler: undefined, container: undefined });
+        const handlerContext = {
+            callbackWaitsForEmptyEventLoop: false,
+            functionName: 's3Lambda',
+            functionVersion: '0.1',
+            invokedFunctionArn: 'arn::test',
+            memoryLimitInMB: '128',
+            awsRequestId: '1234',
+            logGroupName: 'test-group',
+            logStreamName: 'test-stream',
+            getRemainingTimeInMillis: function () {
+                return 1000;
+            },
+            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.');
+            },
+        };
+        const response = yield configuredHandler(event, handlerContext);
+        return response;
+    });
+}
+exports.invokeS3Handler = invokeS3Handler;

package/lib/sqs/RecordMatchers.js

@@ -77,7 +77,7 @@ let SqsMessageDeserializer = class SqsMessageDeserializer {
     }
 };
 SqsMessageDeserializer = __decorate([
-    __param(0, (0, containr_1.inject)(SqsLambdaServices_1.SqsLambdaServices.RecordMatchers)),
+    __param(0, (0, containr_1.injectArray)(SqsLambdaServices_1.SqsLambdaServices.RecordMatchers)),
     __param(1, (0, containr_1.inject)(SqsLambdaServices_1.SqsLambdaServices.DefaultRecordMatcher)),
     __metadata("design:paramtypes", [Array, Object])
 ], SqsMessageDeserializer);

package/lib/sqs/SqsLambda.d.ts

@@ -4,8 +4,7 @@ import { ISqsMessageHandler, SqsOutput } from './ISqsMessageHandler';
 import { ISqsMessage } from './ISqsMessage';
 import { ISqsRecordMatcher } from './RecordMatchers';
 export interface BootstrappedSqsLambdaContext {
-    container: IServiceContainer;
-    createHandler<Message extends ISqsMessage, Output extends SqsOutput = void>(newable: Newable<ISqsMessageHandler<Message, Output>>): SQSHandler;
+    createSqsHandler<Message extends ISqsMessage, Output extends SqsOutput = void>(newable: Newable<ISqsMessageHandler<Message, Output>>): SQSHandler;
 }
 export interface ISqsLambdaFactory {
     createHandler<Message extends ISqsMessage, Output extends SqsOutput = void>(newable: Newable<ISqsMessageHandler<Message, Output>>): SQSHandler;
@@ -15,15 +14,12 @@ export declare class SqsLambdaFactory implements ISqsLambdaFactory {
     constructor(container: IServiceContainer);
     createHandler<Message extends ISqsMessage, Output extends SqsOutput = void>(newable: Newable<ISqsMessageHandler<Message, Output>>): SQSHandler;
 }
-export interface TrigintaSqsOptions {
+export interface TrigintaLegacySqsOptions {
     matchers?: ISqsRecordMatcher[];
 }
-export declare const useTrigintaSqs: import("@aesop-fables/containr").ServiceModuleMiddlewareWithOptionsFactory<TrigintaSqsOptions>;
+export declare const useTrigintaSqs: import("@aesop-fables/containr").ServiceModuleMiddlewareWithOptionsFactory<TrigintaLegacySqsOptions>;
 export interface SqsLambdaBootstrapExpression {
     matchers?: ISqsRecordMatcher[];
     modules?: IServiceModule[];
 }
-export declare class SqsLambda {
-    static initialize(expression: SqsLambdaBootstrapExpression): BootstrappedSqsLambdaContext;
-    static getContainer(): IServiceContainer;
-}
+export declare function createBootstrappedSqsLambdaContext(container: IServiceContainer): BootstrappedSqsLambdaContext;

package/lib/sqs/SqsLambda.js

@@ -1,4 +1,16 @@
 "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) {
@@ -12,7 +24,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqsLambda = exports.useTrigintaSqs = exports.SqsLambdaFactory = void 0;
+exports.createBootstrappedSqsLambdaContext = exports.useTrigintaSqs = exports.SqsLambdaFactory = void 0;
 /* eslint-disable @typescript-eslint/ban-types */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unused-vars */
@@ -25,15 +37,15 @@ const SqsPublisher_1 = require("./SqsPublisher");
 const MessagePublisher_1 = require("./MessagePublisher");
 function embedSqsEvent(event) {
     return (0, containr_1.createServiceModule)('@aesop-fables/triginta/sqs/event', (services) => {
-        services.register(SqsLambdaServices_1.SqsLambdaServices.CurrentEvent, event);
+        services.singleton(SqsLambdaServices_1.SqsLambdaServices.CurrentEvent, event);
     });
 }
 function embedSqsRecord(record) {
     return (0, containr_1.createServiceModule)('@aesop-fables/triginta/sqs/record', (services) => {
-        services.register(SqsLambdaServices_1.SqsLambdaServices.CurrentRecord, record);
+        services.singleton(SqsLambdaServices_1.SqsLambdaServices.CurrentRecord, record);
     });
 }
-class SqsLambdaFactory {
+let SqsLambdaFactory = class SqsLambdaFactory {
     constructor(container) {
         this.container = container;
     }
@@ -73,49 +85,33 @@ class SqsLambdaFactory {
         }
         return handler;
     }
-}
+};
+SqsLambdaFactory = __decorate([
+    __param(0, (0, containr_1.injectContainer)()),
+    __metadata("design:paramtypes", [Object])
+], SqsLambdaFactory);
 exports.SqsLambdaFactory = SqsLambdaFactory;
-// Here until we fix containr's array stuff
-// I think we might want to just use a different inject call for arrays
-class NoOpMatcher {
-    matches() {
-        return false;
-    }
-    deserializeMessage() {
-        throw new Error('Method not implemented.');
-    }
-}
 exports.useTrigintaSqs = (0, containr_1.createServiceModuleWithOptions)('triginta/sqs', (services, options) => {
-    services.register(SqsLambdaServices_1.SqsLambdaServices.SqsLambdaFactory, (container) => new SqsLambdaFactory(container));
+    services.autoResolve(SqsLambdaServices_1.SqsLambdaServices.SqsLambdaFactory, SqsLambdaFactory, containr_1.Scopes.Transient);
     const { matchers = [] } = options;
-    if (matchers.length === 0) {
-        matchers.push(new NoOpMatcher());
-    }
     matchers.forEach((matcher) => {
-        services.addDependency(SqsLambdaServices_1.SqsLambdaServices.RecordMatchers, matcher);
+        services.array(SqsLambdaServices_1.SqsLambdaServices.RecordMatchers, matcher);
     });
-    services.register(SqsLambdaServices_1.SqsLambdaServices.SqsSettings, {});
-    services.use(SqsLambdaServices_1.SqsLambdaServices.DefaultRecordMatcher, RecordMatchers_1.DefaultSqsRecordMatcher);
-    services.use(SqsLambdaServices_1.SqsLambdaServices.MessageDeserializer, RecordMatchers_1.SqsMessageDeserializer);
-    services.use(SqsLambdaServices_1.SqsLambdaServices.SqsPublisher, SqsPublisher_1.SqsPublisher);
-    services.use(SqsLambdaServices_1.SqsLambdaServices.MessagePublisher, MessagePublisher_1.MessagePublisher);
+    services.singleton(SqsLambdaServices_1.SqsLambdaServices.SqsSettings, {});
+    services.autoResolve(SqsLambdaServices_1.SqsLambdaServices.DefaultRecordMatcher, RecordMatchers_1.DefaultSqsRecordMatcher, containr_1.Scopes.Transient);
+    services.autoResolve(SqsLambdaServices_1.SqsLambdaServices.MessageDeserializer, RecordMatchers_1.SqsMessageDeserializer, containr_1.Scopes.Transient);
+    services.autoResolve(SqsLambdaServices_1.SqsLambdaServices.SqsPublisher, SqsPublisher_1.SqsPublisher, containr_1.Scopes.Transient);
+    services.autoResolve(SqsLambdaServices_1.SqsLambdaServices.MessagePublisher, MessagePublisher_1.MessagePublisher, containr_1.Scopes.Transient);
 });
-let _currentContainer;
-class SqsLambda {
-    static initialize(expression) {
-        const { matchers, modules = [] } = expression;
-        const container = (0, containr_1.createContainer)([(0, exports.useTrigintaSqs)({ matchers }), ...modules]);
-        _currentContainer = container;
-        return {
-            container,
-            createHandler(newable) {
-                const factory = container.get(SqsLambdaServices_1.SqsLambdaServices.SqsLambdaFactory);
-                return factory.createHandler(newable);
-            },
-        };
-    }
-    static getContainer() {
-        return _currentContainer;
-    }
+function createBootstrappedSqsLambdaContext(container) {
+    return {
+        createSqsHandler(newable) {
+            if (typeof container === 'undefined') {
+                throw new Error(`SQS container not initialized`);
+            }
+            const factory = container.get(SqsLambdaServices_1.SqsLambdaServices.SqsLambdaFactory);
+            return factory.createHandler(newable);
+        },
+    };
 }
-exports.SqsLambda = SqsLambda;
+exports.createBootstrappedSqsLambdaContext = createBootstrappedSqsLambdaContext;

package/lib/sqs/SqsLambdaServices.js

@@ -1,14 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqsLambdaServices = void 0;
+const Utils_1 = require("../Utils");
+const namedService = (0, Utils_1.createServiceNamespacer)('sqs');
 exports.SqsLambdaServices = {
-    SqsLambdaFactory: 'SqsLambdaFactory',
-    DefaultRecordMatcher: 'DefaultRecordMatcher',
-    MessageDeserializer: 'MessageDeserializer',
-    RecordMatchers: 'RecordMatchers',
-    MessagePublisher: 'MessagePublisher',
-    SqsPublisher: 'SqsPublisher',
-    SqsSettings: 'SqsSettings',
-    CurrentEvent: 'SqsCurrentEvent',
-    CurrentRecord: 'SqsCurrentRecord',
+    SqsLambdaFactory: namedService('SqsLambdaFactory'),
+    DefaultRecordMatcher: namedService('DefaultRecordMatcher'),
+    MessageDeserializer: namedService('MessageDeserializer'),
+    RecordMatchers: namedService('RecordMatchers'),
+    MessagePublisher: namedService('MessagePublisher'),
+    SqsPublisher: namedService('SqsPublisher'),
+    SqsSettings: namedService('SqsSettings'),
+    CurrentEvent: namedService('SqsCurrentEvent'),
+    CurrentRecord: namedService('SqsCurrentRecord'),
 };

package/lib/validation/ValidationContext.js

@@ -23,13 +23,13 @@ class ValidationContext {
     }
     isEmpty() {
         const value = this.value();
-        if (typeof value === 'undefined' || !value) {
+        if (typeof value === 'undefined' || value === null) {
             return true;
         }
         if (typeof value === 'string') {
             return value.length === 0 || value.trim().length === 0;
         }
-        return value === 0;
+        return false;
     }
 }
 exports.ValidationContext = ValidationContext;

package/lib/validation/ValidatorFactory.d.ts

@@ -1,9 +1,9 @@
-import { IRequestContext } from '../http/IRequestContext';
+import { IServiceContainer } from '@aesop-fables/containr';
 import { IConfiguredValidationRule } from './IConfiguredValidationRule';
 import { IValidator } from './IValidator';
 import { IValidatorFactory } from './IValidatorFactory';
 export declare class ValidatorFactory implements IValidatorFactory {
-    private readonly context;
-    constructor(context: IRequestContext);
+    private readonly container;
+    constructor(container: IServiceContainer);
     create(rules: IConfiguredValidationRule[]): IValidator;
 }

package/lib/validation/ValidatorFactory.js

@@ -14,18 +14,17 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValidatorFactory = void 0;
 const containr_1 = require("@aesop-fables/containr");
-const HttpLambdaServices_1 = require("../http/HttpLambdaServices");
 const Validator_1 = require("./Validator");
 let ValidatorFactory = class ValidatorFactory {
-    constructor(context) {
-        this.context = context;
+    constructor(container) {
+        this.container = container;
     }
     create(rules) {
-        return new Validator_1.Validator(this.context.container, rules);
+        return new Validator_1.Validator(this.container, rules);
     }
 };
 ValidatorFactory = __decorate([
-    __param(0, (0, containr_1.inject)(HttpLambdaServices_1.HttpLambdaServices.RequestContext)),
+    __param(0, (0, containr_1.injectContainer)()),
     __metadata("design:paramtypes", [Object])
 ], ValidatorFactory);
 exports.ValidatorFactory = ValidatorFactory;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aesop-fables/triginta",
-  "version": "0.7.5",
+  "version": "0.8.1",
   "description": "A lightweight framework that wraps the basic infrastructure usages of AWS Lambda (SQS, Kinesis, etc.).",
   "type": "commonjs",
   "exports": {
@@ -24,18 +24,18 @@
     "postversion": "git push && git push --tags"
   },
   "devDependencies": {
-    "@aesop-fables/containr": "^0.2.5",
-    "@aesop-fables/containr-testing": "^0.2.3",
+    "@aesop-fables/containr": "^0.3.4",
+    "@aesop-fables/containr-testing": "^0.3.0",
     "@middy/core": "^4.2.7",
-    "@middy/http-error-handler": "^4.2.3",
+    "@middy/http-error-handler": "^4.4.3",
     "@middy/http-json-body-parser": "^4.2.3",
     "@middy/util": "^4.3.1",
     "@types/aws-lambda": "^8.10.109",
     "@types/jest": "^29.5.0",
-    "@types/node": "^18.11.11",
-    "@typescript-eslint/eslint-plugin": "^5.45.1",
-    "@typescript-eslint/parser": "5.59.2",
-    "aws-sdk": "^2.1363.0",
+    "@types/node": "^18.16.16",
+    "@typescript-eslint/eslint-plugin": "^5.59.8",
+    "@typescript-eslint/parser": "5.59.8",
+    "aws-sdk": "^2.1386.0",
     "esbuild": "^0.17.8",
     "eslint": "8.40.0",
     "eslint-config-prettier": "^8.5.0",