@aesop-fables/triginta 0.5.0 → 0.7.0

package/lib/Decorators.d.ts

@@ -1,4 +1,4 @@
-import { IConfiguredRoute } from './IConfiguredRoute';
+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;

package/lib/RouteRegistry.d.ts

@@ -1,4 +1,4 @@
-import { IConfiguredRoute } from './IConfiguredRoute';
+import { IConfiguredRoute } from './http/IConfiguredRoute';
 export interface IRouteRegistry {
     allRoutes(): IConfiguredRoute[];
     register(route: IConfiguredRoute): void;

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/{HttpLambda.js → http/HttpLambda.js}

@@ -30,8 +30,11 @@ exports.HttpLambda = exports.useTrigintaHttp = exports.HttpLambdaFactory = expor
 /* 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 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;
@@ -76,53 +79,57 @@ class HttpLambdaFactory {
         return this.createHandler(newable);
     }
     createHandler(newable) {
-        const handler = (event) => __awaiter(this, void 0, void 0, function* () {
-            const route = (0, Decorators_1.getRoute)(newable);
-            if (!route) {
-                throw new Error('No route found for the specified endpoint');
+        var _a;
+        const route = (0, Decorators_1.getRoute)(newable);
+        if (!route) {
+            throw new Error('No route found for the specified endpoint');
+        }
+        const handler = (event, context) => __awaiter(this, void 0, void 0, function* () {
+            const childContainer = context['container'];
+            if (!childContainer) {
+                throw new Error('No container found in the context');
             }
-            const injectConfiguredRoute = {
-                name: 'injectConfiguredRoute',
-                configureServices(services) {
-                    services.register(HttpLambdaServices_1.HttpLambdaServices.CurrentRoute, route);
-                },
-            };
-            const childContainer = this.container.createChildContainer('httpLambda', [injectConfiguredRoute]);
             const responseGenerator = childContainer.get(HttpLambdaServices_1.HttpLambdaServices.HttpResponseGenerator);
-            try {
-                const handler = this.container.resolve(newable);
-                const { body: request } = event;
-                let response;
-                if (route.method !== 'get') {
-                    const endpoint = handler;
-                    response = (yield endpoint.handle(request, event));
-                }
-                else {
-                    const eventHandler = handler;
-                    response = (yield eventHandler.handle(event));
-                }
-                return responseGenerator.generateResponse(response);
+            const handler = childContainer.resolve(newable);
+            const { body: request } = event;
+            let response;
+            if (route.method !== 'get') {
+                const endpoint = handler;
+                response = (yield endpoint.handle(request, event));
             }
-            finally {
-                if (childContainer) {
-                    try {
-                        childContainer.dispose();
-                    }
-                    catch (_a) {
-                        // no-op
-                    }
-                }
+            else {
+                const eventHandler = handler;
+                response = (yield eventHandler.handle(event));
             }
+            return responseGenerator.generateResponse(response);
         });
-        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;
+        const { container } = this;
+        const middlewareMetadata = (_a = (0, Decorators_1.getMiddleware)(newable)) !== null && _a !== void 0 ? _a : [];
+        let midHandler = (0, core_1.default)(handler).use({
+            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,
+                            };
+                        });
+                    });
+                    const childContainer = container.createChildContainer('httpLambda', [injectContextualServices]);
+                    request.context['container'] = childContainer;
+                });
+            },
+            after(request) {
+                var _a;
+                (_a = request.context['container']) === null || _a === void 0 ? void 0 : _a.dispose();
+            },
+        });
+        middlewareMetadata.forEach((midFunc) => {
+            midHandler = midHandler.use(midFunc());
+        });
+        return midHandler;
     }
 }
 exports.HttpLambdaFactory = HttpLambdaFactory;
@@ -133,7 +140,13 @@ exports.useTrigintaHttp = (0, containr_1.createServiceModule)('triginta/http', (
 let _currentContainer;
 class HttpLambda {
     static initialize(modules = []) {
-        const container = (0, containr_1.createContainer)([exports.useTrigintaHttp, ...modules]);
+        const container = (0, containr_1.createContainer)([
+            exports.useTrigintaHttp,
+            _1.useHttpServices,
+            localization_1.useLocalization,
+            validation_1.useHttpValidation,
+            ...modules,
+        ]);
         _currentContainer = container;
         return {
             createHttpEventLambda(newable) {

package/lib/{HttpLambdaServices.d.ts → http/HttpLambdaServices.d.ts}

@@ -1,5 +1,7 @@
 export declare const HttpLambdaServices: {
     CurrentRoute: string;
+    CurrentEvent: string;
     HttpLambdaFactory: string;
     HttpResponseGenerator: string;
+    RequestContext: string;
 };

package/lib/{HttpLambdaServices.js → http/HttpLambdaServices.js}

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpLambdaServices = void 0;
 exports.HttpLambdaServices = {
     CurrentRoute: 'currentRoute',
+    CurrentEvent: 'currentEvent',
     HttpLambdaFactory: 'HttpLambdaFactory',
     HttpResponseGenerator: 'HttpResponseGenerator',
+    RequestContext: 'requestContext',
 };

package/lib/{IHttpEndpoint.d.ts → http/IHttpEndpoint.d.ts}

@@ -1,5 +1,5 @@
 import { APIGatewayProxyEventV2 } from 'aws-lambda';
-import { IEventHandler, IMessageHandler } from './IHandler';
+import { IEventHandler, IMessageHandler } from '../IHandler';
 export interface IHttpEventHandler<Output = void> extends IEventHandler<APIGatewayProxyEventV2, Output> {
 }
 export interface IHttpEndpoint<Input, Output> extends IMessageHandler<Input, APIGatewayProxyEventV2, Output> {

package/lib/http/IRequestContext.d.ts

@@ -0,0 +1,4 @@
+import { IServiceContainer } from '@aesop-fables/containr';
+export interface IRequestContext {
+    container: IServiceContainer;
+}

package/lib/http/index.d.ts

@@ -0,0 +1 @@
+export declare const useHttpServices: import("@aesop-fables/containr").IServiceModule;

package/lib/http/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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,
+        };
+    });
+});

package/lib/index.d.ts

@@ -1,16 +1,20 @@
 export * from './IHandler';
-export * from './IHttpEndpoint';
+export * from './http/IHttpEndpoint';
 export * from './Decorators';
-export * from './HttpLambda';
-export * from './HttpLambdaServices';
+export * from './http/HttpLambda';
+export * from './http/HttpLambdaServices';
 export { default as RouteRegistry, IRouteRegistry } from './RouteRegistry';
-export * from './SqsLambda';
-export * from './SqsLambdaServices';
-export * from './ISqsMessageHandler';
-export * from './IConfiguredRoute';
+export * from './sqs/SqsLambda';
+export * from './sqs/SqsLambdaServices';
+export * from './sqs/ISqsMessageHandler';
+export * from './sqs/RecordMatchers';
+export * from './sqs/ISqsMessage';
+export * from './http/IConfiguredRoute';
 export * from './TrigintaConfig';
-import * as httpUtils from './invokeHttpHandler';
-import * as sqsUtils from './invokeSqsHandler';
+export * as Localization from './localization';
+export * as Validation from './validation';
+import * as httpUtils from './http/invokeHttpHandler';
+import * as sqsUtils from './sqs/invokeSqsHandler';
 /**
  * Provides helper functions for invoking lambdas in unit/integration tests.
  */

package/lib/index.js

@@ -29,21 +29,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestUtils = exports.RouteRegistry = void 0;
+exports.TestUtils = exports.Validation = exports.Localization = exports.RouteRegistry = void 0;
 __exportStar(require("./IHandler"), exports);
-__exportStar(require("./IHttpEndpoint"), exports);
+__exportStar(require("./http/IHttpEndpoint"), exports);
 __exportStar(require("./Decorators"), exports);
-__exportStar(require("./HttpLambda"), exports);
-__exportStar(require("./HttpLambdaServices"), exports);
+__exportStar(require("./http/HttpLambda"), exports);
+__exportStar(require("./http/HttpLambdaServices"), exports);
 var RouteRegistry_1 = require("./RouteRegistry");
 Object.defineProperty(exports, "RouteRegistry", { enumerable: true, get: function () { return __importDefault(RouteRegistry_1).default; } });
-__exportStar(require("./SqsLambda"), exports);
-__exportStar(require("./SqsLambdaServices"), exports);
-__exportStar(require("./ISqsMessageHandler"), exports);
-__exportStar(require("./IConfiguredRoute"), exports);
+__exportStar(require("./sqs/SqsLambda"), exports);
+__exportStar(require("./sqs/SqsLambdaServices"), exports);
+__exportStar(require("./sqs/ISqsMessageHandler"), exports);
+__exportStar(require("./sqs/RecordMatchers"), exports);
+__exportStar(require("./sqs/ISqsMessage"), exports);
+__exportStar(require("./http/IConfiguredRoute"), exports);
 __exportStar(require("./TrigintaConfig"), exports);
-const httpUtils = __importStar(require("./invokeHttpHandler"));
-const sqsUtils = __importStar(require("./invokeSqsHandler"));
+exports.Localization = __importStar(require("./localization"));
+exports.Validation = __importStar(require("./validation"));
+const httpUtils = __importStar(require("./http/invokeHttpHandler"));
+const sqsUtils = __importStar(require("./sqs/invokeSqsHandler"));
 /**
  * Provides helper functions for invoking lambdas in unit/integration tests.
  */

package/lib/localization/ICultureContext.d.ts

@@ -0,0 +1,3 @@
+export interface ICultureContext {
+    detectCulture(): string;
+}

package/lib/localization/ICultureContext.js

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

package/lib/localization/ILocalizationStorage.d.ts

@@ -0,0 +1,6 @@
+export interface ILocalizationStorage {
+    lookupCulture(cultureCode: string): ILocalizedStringStorage;
+}
+export interface ILocalizedStringStorage {
+    [key: string]: string;
+}

package/lib/localization/ILocalizationStorage.js

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

package/lib/localization/IStringLocalizer.d.ts

@@ -0,0 +1,4 @@
+import { LocalizedString } from './LocalizedString';
+export interface IStringLocalizer {
+    resolve(value: LocalizedString): string;
+}

package/lib/localization/IStringLocalizer.js

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

package/lib/localization/LocalizationServices.d.ts

@@ -0,0 +1,5 @@
+export declare const LocalizationServices: {
+    CultureContext: string;
+    LocalizationStorage: string;
+    StringLocalizer: string;
+};

package/lib/localization/LocalizationServices.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalizationServices = void 0;
+exports.LocalizationServices = {
+    CultureContext: 'cultureContext',
+    LocalizationStorage: 'localizationStorage',
+    StringLocalizer: 'stringLocalizer',
+};

package/lib/localization/LocalizationStorage.d.ts

@@ -0,0 +1,4 @@
+import { ILocalizationStorage, ILocalizedStringStorage } from './ILocalizationStorage';
+export declare class LocalizationStorage implements ILocalizationStorage {
+    lookupCulture(): ILocalizedStringStorage;
+}

package/lib/localization/LocalizationStorage.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalizationStorage = void 0;
+// TODO -- Build this out more
+class LocalizationStorage {
+    lookupCulture() {
+        return {};
+    }
+}
+exports.LocalizationStorage = LocalizationStorage;

package/lib/localization/LocalizedString.d.ts

@@ -0,0 +1,4 @@
+export interface LocalizedString {
+    key: string;
+    defaultValue?: string;
+}

package/lib/localization/LocalizedString.js

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

package/lib/localization/StringLocalizer.d.ts

@@ -0,0 +1,10 @@
+import { ICultureContext } from './ICultureContext';
+import { ILocalizationStorage } from './ILocalizationStorage';
+import { IStringLocalizer } from './IStringLocalizer';
+import { LocalizedString } from './LocalizedString';
+export declare class StringLocalizer implements IStringLocalizer {
+    private readonly storage;
+    private readonly cultureContext;
+    constructor(storage: ILocalizationStorage, cultureContext: ICultureContext);
+    resolve(value: LocalizedString): string;
+}

package/lib/localization/StringLocalizer.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringLocalizer = void 0;
+class StringLocalizer {
+    constructor(storage, cultureContext) {
+        this.storage = storage;
+        this.cultureContext = cultureContext;
+    }
+    resolve(value) {
+        var _a, _b;
+        const culture = this.cultureContext.detectCulture();
+        const store = this.storage.lookupCulture(culture);
+        return (_b = (_a = store[value.key]) !== null && _a !== void 0 ? _a : value.defaultValue) !== null && _b !== void 0 ? _b : value.key;
+    }
+}
+exports.StringLocalizer = StringLocalizer;

package/lib/localization/index.d.ts

@@ -0,0 +1,8 @@
+export * from './ICultureContext';
+export * from './ILocalizationStorage';
+export * from './IStringLocalizer';
+export * from './LocalizationServices';
+export * from './LocalizationStorage';
+export * from './LocalizedString';
+export * from './StringLocalizer';
+export declare const useLocalization: import("@aesop-fables/containr").IServiceModule;

package/lib/localization/index.js

@@ -0,0 +1,32 @@
+"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 });
+exports.useLocalization = void 0;
+const containr_1 = require("@aesop-fables/containr");
+const LocalizationServices_1 = require("./LocalizationServices");
+const LocalizationStorage_1 = require("./LocalizationStorage");
+const StringLocalizer_1 = require("./StringLocalizer");
+__exportStar(require("./ICultureContext"), exports);
+__exportStar(require("./ILocalizationStorage"), exports);
+__exportStar(require("./IStringLocalizer"), exports);
+__exportStar(require("./LocalizationServices"), exports);
+__exportStar(require("./LocalizationStorage"), exports);
+__exportStar(require("./LocalizedString"), exports);
+__exportStar(require("./StringLocalizer"), exports);
+exports.useLocalization = (0, containr_1.createServiceModule)('useLocalization', (services) => {
+    services.use(LocalizationServices_1.LocalizationServices.LocalizationStorage, LocalizationStorage_1.LocalizationStorage);
+    services.use(LocalizationServices_1.LocalizationServices.StringLocalizer, StringLocalizer_1.StringLocalizer);
+});

package/lib/sqs/ISqsMessage.d.ts

@@ -0,0 +1,16 @@
+import { SQSMessageAttributes } from 'aws-lambda';
+export interface ISqsMessage {
+    type: string;
+    getAttributes(): SQSMessageAttributes;
+    getBody(): string;
+}
+export declare const TrigintaMessageHeaders: {
+    MessageType: string;
+};
+export declare abstract class BaseSqsMessage implements ISqsMessage {
+    readonly type: string;
+    constructor(type: string);
+    getAttributes(): SQSMessageAttributes;
+    getData(): any;
+    getBody(): string;
+}

package/lib/sqs/ISqsMessage.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSqsMessage = exports.TrigintaMessageHeaders = void 0;
+exports.TrigintaMessageHeaders = {
+    MessageType: 'X-Message-Type',
+};
+class BaseSqsMessage {
+    constructor(type) {
+        this.type = type;
+    }
+    getAttributes() {
+        const attributes = {
+            [exports.TrigintaMessageHeaders.MessageType]: {
+                dataType: 'String',
+                stringValue: this.type,
+            },
+        };
+        return attributes;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getData() {
+        return undefined;
+    }
+    getBody() {
+        var _a;
+        const data = (_a = this.getData()) !== null && _a !== void 0 ? _a : {};
+        return JSON.stringify(data);
+    }
+}
+exports.BaseSqsMessage = BaseSqsMessage;

package/lib/{ISqsMessageHandler.d.ts → sqs/ISqsMessageHandler.d.ts}

@@ -1,5 +1,6 @@
 import { SQSBatchResponse, SQSEvent, SQSRecord } from 'aws-lambda';
+import { ISqsMessage } from './ISqsMessage';
 export declare type SqsOutput = SQSBatchResponse | void;
-export interface ISqsMessageHandler<Message, Output extends SqsOutput = void> {
+export interface ISqsMessageHandler<Message extends ISqsMessage, Output extends SqsOutput = void> {
     handle(message: Message, record: SQSRecord, event: SQSEvent): Promise<Output>;
 }

package/lib/sqs/ISqsMessageHandler.js

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

package/lib/sqs/RecordMatchers.d.ts

@@ -0,0 +1,31 @@
+import { SQSMessageAttributes, SQSRecord } from 'aws-lambda';
+import { ISqsMessage } from './ISqsMessage';
+export interface ISqsRecordMatcher {
+    matches(record: SQSRecord): boolean;
+    deserializeMessage<Message extends ISqsMessage>(record: SQSRecord): Promise<Message>;
+}
+export declare function retrieveMessageType(messageAttributes: SQSMessageAttributes): string;
+export declare class DefaultSqsRecordMatcher implements ISqsRecordMatcher {
+    matches(): boolean;
+    deserializeMessage<Message extends ISqsMessage>(record: SQSRecord): Promise<Message>;
+}
+export interface ISqsMessageDeserializer {
+    deserializeMessage<Message extends ISqsMessage>(record: SQSRecord): Promise<Message>;
+}
+export declare class SqsMessageDeserializer implements ISqsMessageDeserializer {
+    private readonly matchers;
+    private readonly defaultMatcher;
+    constructor(matchers: ISqsRecordMatcher[], defaultMatcher: ISqsRecordMatcher);
+    deserializeMessage<Message extends ISqsMessage>(record: SQSRecord): Promise<Message>;
+}
+export declare type MessageConfigAttributes<Message> = {
+    [Property in keyof Message]: string;
+};
+export declare type MessageFactory<Message, Body> = (attributes: Partial<MessageConfigAttributes<Message>>, body: Body) => Promise<Message>;
+export declare type MessageConfig<Message, Options> = {
+    type: string;
+    attributes: Partial<MessageConfigAttributes<Message>>;
+    constructUsing: MessageFactory<Message, Options>;
+};
+export declare type MessageExpression<Message extends ISqsMessage> = Omit<Message, 'getAttributes' | 'getBody' | 'getData'>;
+export declare function createMatcher<Message extends ISqsMessage, Options>(configuration: MessageConfig<MessageExpression<Message>, Options>): ISqsRecordMatcher;