@aesop-fables/triginta 0.9.1 → 0.9.3

package/lib/sqs/SqsLambda.js

@@ -77,6 +77,15 @@ let SqsLambdaFactory = class SqsLambdaFactory {
                         const message = yield deserializer.deserializeMessage(record);
                         yield innerHandler.handle(message, record, event);
                     }
+                    catch (e) {
+                        const failureHandler = childContainer.get(SqsLambdaServices_1.SqsLambdaServices.FailureHandler);
+                        const shouldReport = yield failureHandler.onError(record, e);
+                        if (shouldReport) {
+                            response.batchItemFailures.push({
+                                itemIdentifier: record.messageId,
+                            });
+                        }
+                    }
                     finally {
                         if (childContainer) {
                             try {
@@ -89,13 +98,9 @@ let SqsLambdaFactory = class SqsLambdaFactory {
                     }
                 }
                 catch (e) {
-                    const failureHandler = this.container.get(SqsLambdaServices_1.SqsLambdaServices.FailureHandler);
-                    const shouldReport = yield failureHandler.onError(record, e);
-                    if (shouldReport) {
-                        response.batchItemFailures.push({
-                            itemIdentifier: record.messageId,
-                        });
-                    }
+                    // We need to revisit this
+                    // https://github.com/aesop-fables/triginta/issues/199
+                    throw e;
                 }
             }
             return response;

package/lib/validation/ArrayContinuationRule.d.ts

@@ -0,0 +1,9 @@
+import { IConfiguredValidationRule } from './IConfiguredValidationRule';
+import { IValidationRule } from './IValidationRule';
+import { ValidationContext } from './ValidationContext';
+export declare class ArrayContinuationRule implements IValidationRule {
+    private readonly field;
+    private readonly schema;
+    constructor(field: string, schema: IConfiguredValidationRule[]);
+    validate(context: ValidationContext): Promise<void>;
+}

package/lib/validation/ArrayContinuationRule.js

@@ -0,0 +1,38 @@
+"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.ArrayContinuationRule = void 0;
+const ValidationServices_1 = require("./ValidationServices");
+class ArrayContinuationRule {
+    constructor(field, schema) {
+        this.field = field;
+        this.schema = schema;
+    }
+    validate(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const array = context.value();
+            if (!array || !Array.isArray(array) || !array.length) {
+                return;
+            }
+            const factory = context.container.get(ValidationServices_1.ValidationServices.ValidatorFactory);
+            const validator = factory.create(this.schema);
+            const arrayNotification = context.notification.forArray(this.field);
+            for (let i = 0; i < array.length; i++) {
+                const child = arrayNotification.forIndex(i);
+                yield validator.validate(array[i], child);
+                arrayNotification.importAll(child);
+            }
+            context.notification.importAll(arrayNotification);
+        });
+    }
+}
+exports.ArrayContinuationRule = ArrayContinuationRule;

package/lib/validation/IValidator.d.ts

@@ -1,4 +1,4 @@
 import { ValidationNotification } from './ValidationNotification';
 export interface IValidator {
-    validate<Model extends object>(model: Model): Promise<ValidationNotification>;
+    validate<Model extends object>(model: Model, notification?: ValidationNotification): Promise<ValidationNotification>;
 }

package/lib/validation/RuleParser.d.ts

@@ -3,6 +3,7 @@ import { IValidationRule } from './IValidationRule';
 export declare type ValidationExpression<T> = {
     required?: boolean;
     custom?: IValidationRule[];
+    array?: IConfiguredValidationRule[];
 };
 export declare type ValidationSchema<Model> = {
     [Property in keyof Model]: ValidationExpression<Model[Property]>;

package/lib/validation/RuleParser.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseRules = void 0;
+const ArrayContinuationRule_1 = require("./ArrayContinuationRule");
 const RequiredRule_1 = require("./RequiredRule");
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function parseRules(schema) {
     const rules = [];
     Object.keys(schema).forEach((field) => {
-        var _a;
+        var _a, _b;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const fieldSchema = schema[field];
         if (typeof fieldSchema !== 'object') {
@@ -23,6 +24,12 @@ function parseRules(schema) {
             field,
             rule,
         }));
+        if (typeof fieldSchema.array !== 'undefined') {
+            rules.push({
+                field,
+                rule: new ArrayContinuationRule_1.ArrayContinuationRule(field, (_b = fieldSchema.array) !== null && _b !== void 0 ? _b : []),
+            });
+        }
     });
     return rules;
 }

package/lib/validation/ValidationNotification.d.ts

@@ -2,10 +2,21 @@ import { LocalizedString } from '../localization';
 import { ValidationMessage } from './ValidationMessage';
 export declare class ValidationNotification {
     private readonly messages;
+    _getOrCreateMessages(field: string): ValidationMessage[];
     messagesFor(field: string): ValidationMessage[];
     registerMessage(field: string, localizedString: LocalizedString): ValidationMessage;
     allMessages(): ValidationMessage[];
     eachMessage(action: (message: ValidationMessage) => void): void;
     isValid(): boolean;
     importForField(field: string, notification: ValidationNotification): void;
+    forArray(field: string): PrefixedValidationNotification;
+    importAll(notification: ValidationNotification): void;
+}
+export declare class PrefixedValidationNotification extends ValidationNotification {
+    protected readonly prefix: string;
+    private readonly prefixRegistration;
+    constructor(prefix: string, prefixRegistration?: boolean);
+    resolveFieldName(field: string): string;
+    registerMessage(field: string, localizedString: LocalizedString): ValidationMessage;
+    forIndex(index: number): PrefixedValidationNotification;
 }

package/lib/validation/ValidationNotification.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValidationNotification = void 0;
+exports.PrefixedValidationNotification = exports.ValidationNotification = void 0;
 const ValidationMessage_1 = require("./ValidationMessage");
 class ValidationNotification {
     constructor() {
         this.messages = {};
     }
-    messagesFor(field) {
+    _getOrCreateMessages(field) {
         let messages = this.messages[field];
         if (typeof messages === 'undefined') {
             messages = [];
@@ -14,6 +14,9 @@ class ValidationNotification {
         }
         return messages;
     }
+    messagesFor(field) {
+        return this._getOrCreateMessages(field);
+    }
     registerMessage(field, localizedString) {
         const message = new ValidationMessage_1.ValidationMessage(field, localizedString);
         let existing = null;
@@ -24,7 +27,7 @@ class ValidationNotification {
         });
         if (existing != null)
             return existing;
-        const messages = this.messagesFor(field);
+        const messages = this._getOrCreateMessages(field);
         messages.push(message);
         return message;
     }
@@ -39,7 +42,7 @@ class ValidationNotification {
         const keys = Object.keys(this.messages);
         for (let i = 0; i < keys.length; i++) {
             const key = keys[i];
-            const values = this.messagesFor(key);
+            const values = this._getOrCreateMessages(key);
             values.forEach((value) => {
                 action(value);
             });
@@ -52,5 +55,32 @@ class ValidationNotification {
         const current = this.messagesFor(field);
         notification.messagesFor(field).forEach((_) => current.push(_));
     }
+    forArray(field) {
+        return new PrefixedValidationNotification(field, false);
+    }
+    importAll(notification) {
+        notification.eachMessage((msg) => {
+            this.registerMessage(msg.field, msg.localizedString);
+        });
+    }
 }
 exports.ValidationNotification = ValidationNotification;
+class PrefixedValidationNotification extends ValidationNotification {
+    constructor(prefix, prefixRegistration = true) {
+        super();
+        this.prefix = prefix;
+        this.prefixRegistration = prefixRegistration;
+    }
+    resolveFieldName(field) {
+        var _a;
+        return `${(_a = this.prefix) !== null && _a !== void 0 ? _a : ''}${field}`;
+    }
+    registerMessage(field, localizedString) {
+        const resolvedField = this.prefixRegistration ? this.resolveFieldName(field) : field;
+        return super.registerMessage(resolvedField, localizedString);
+    }
+    forIndex(index) {
+        return new PrefixedValidationNotification(this.resolveFieldName(`[${index}].`));
+    }
+}
+exports.PrefixedValidationNotification = PrefixedValidationNotification;

package/lib/validation/Validator.d.ts

@@ -7,6 +7,6 @@ export declare class Validator implements IValidator {
     private readonly rules;
     private readonly keys;
     constructor(container: IServiceContainer, rules: IConfiguredValidationRule[]);
-    validate<Model extends object>(model: Model): Promise<ValidationNotification>;
+    validate<Model extends object>(model: Model, notification?: ValidationNotification): Promise<ValidationNotification>;
     private validateField;
 }

package/lib/validation/Validator.js

@@ -24,20 +24,18 @@ class Validator {
         });
     }
     // not worrying about defensive coding on the model right now
-    validate(model) {
+    validate(model, notification = new ValidationNotification_1.ValidationNotification()) {
         return __awaiter(this, void 0, void 0, function* () {
-            const notification = new ValidationNotification_1.ValidationNotification();
             const promises = this.keys.map((field) => __awaiter(this, void 0, void 0, function* () {
-                const child = yield this.validateField(field, model);
-                notification.importForField(field, child);
+                yield this.validateField(field, model, notification);
+                // notification.importForField(field, child);
             }));
             yield Promise.all(promises);
             return notification;
         });
     }
-    validateField(field, model) {
+    validateField(field, model, child) {
         return __awaiter(this, void 0, void 0, function* () {
-            const child = new ValidationNotification_1.ValidationNotification();
             const context = new ValidationContext_1.ValidationContext(field, model, child, this.container);
             const fieldRules = this.rules.filter((_) => _.field === field);
             yield Promise.all(fieldRules.map(({ rule }) => rule.validate(context)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aesop-fables/triginta",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "A lightweight framework that wraps the basic infrastructure usages of AWS Lambda (SQS, Kinesis, etc.).",
   "type": "commonjs",
   "exports": {