idea-aws 4.3.3 → 4.3.5

package/dist/src/genericController.d.ts

@@ -14,13 +14,17 @@ export declare abstract class GenericController {
      */
     constructor(event: any, callback: any);
     /**
-     * The main function, that handle the request and should terminate with an invokation of the method `done`.
+     * The main function (to override), that handles the request and must terminate invoking the method `done`.
      */
-    abstract handleRequest(): void;
+    handleRequest(): Promise<void>;
     /**
      * Default callback for the Lambda.
      */
-    protected done(error: Error | any, res?: any): void;
+    protected done(error?: Error | any, res?: any): void;
+    /**
+     * Remap an error to manage the logging and make sure no unhandled error is returned to the requester.
+     */
+    protected handleControllerError(err: Error | HandledError | any, interceptedInContext: string, replaceWithMessage: string): HandledError | UnhandledError;
     /**
      * Get the current log level for the current Lambda function's `logger`.
      * Note: "FATAL" means that no log will be printed.
@@ -35,3 +39,22 @@ export declare abstract class GenericController {
      */
     silentLambdaLogs(): void;
 }
+/**
+ * A specific type of error in the context of the Controller, to distinguish from "unhandled" errors.
+ */
+export declare class HandledError extends Error {
+    constructor(message: string);
+}
+/**
+ * An unhandled error thrown inside the controller (i.e. `!(error instanceof HandledError)`) .
+ */
+export declare class UnhandledError extends Error {
+    /**
+     * The context where the unhandled error was intercepted.
+     */
+    unhandled: string;
+    /**
+     * The original error message before it was replaced by a public-facing message.
+     */
+    internalMessage: string;
+}

package/dist/src/genericController.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GenericController = void 0;
+exports.UnhandledError = exports.HandledError = exports.GenericController = void 0;
 require("source-map-support/register");
 const lambdaLogger_1 = require("./lambdaLogger");
 /**
@@ -17,16 +17,39 @@ class GenericController {
         this.event = event;
         this.callback = callback;
     }
+    /**
+     * The main function (to override), that handles the request and must terminate invoking the method `done`.
+     */
+    async handleRequest() {
+        this.logger.info('START');
+        this.done();
+    }
     /**
      * Default callback for the Lambda.
      */
-    done(error, res) {
-        if (error)
-            this.logger.error('END-FAILED', error);
+    done(error = null, res) {
+        if (error) {
+            if (error.unhandled)
+                this.logger.error('END-FAILED', error);
+            else
+                this.logger.warn('END-FAILED', error);
+        }
         else
             this.logger.info('END-SUCCESS');
         this.callback(error, res);
     }
+    /**
+     * Remap an error to manage the logging and make sure no unhandled error is returned to the requester.
+     */
+    handleControllerError(err, interceptedInContext, replaceWithMessage) {
+        if (err instanceof HandledError)
+            return err;
+        const error = err;
+        error.unhandled = interceptedInContext;
+        error.internalMessage = error.message;
+        error.message = replaceWithMessage;
+        return error;
+    }
     /**
      * Get the current log level for the current Lambda function's `logger`.
      * Note: "FATAL" means that no log will be printed.
@@ -48,3 +71,19 @@ class GenericController {
     }
 }
 exports.GenericController = GenericController;
+/**
+ * A specific type of error in the context of the Controller, to distinguish from "unhandled" errors.
+ */
+class HandledError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, HandledError.prototype);
+    }
+}
+exports.HandledError = HandledError;
+/**
+ * An unhandled error thrown inside the controller (i.e. `!(error instanceof HandledError)`) .
+ */
+class UnhandledError extends Error {
+}
+exports.UnhandledError = UnhandledError;

package/dist/src/resourceController.d.ts

@@ -43,7 +43,6 @@ export declare abstract class ResourceController extends GenericController {
      */
     protected getQueryParamAsArray(paramName: string): string[];
     handleRequest: () => Promise<void>;
-    private remapHandlerError;
     protected done(error?: Error | any, rawResult?: any, statusCode?: number): void;
     /**
      * To @override
@@ -225,9 +224,3 @@ export interface InternalAPIRequestParams {
      */
     body?: any;
 }
-/**
- * Explicitly define a specific type of error to use in the RC's handler, to distinguish it from the normal errors.
- */
-export declare class RCError extends Error {
-    constructor(message: string);
-}

package/dist/src/resourceController.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RCError = exports.ResourceController = void 0;
+exports.ResourceController = void 0;
 const fs_1 = require("fs");
 const Lambda = __importStar(require("@aws-sdk/client-lambda"));
 const EventBridge = __importStar(require("@aws-sdk/client-eventbridge"));
@@ -49,6 +49,7 @@ class ResourceController extends genericController_1.GenericController {
         /// REQUEST HANDLERS
         ///
         this.handleRequest = async () => {
+            this.logger.info('START', { event: this.getEventSummary() });
             if (this.initError)
                 return;
             try {
@@ -77,7 +78,7 @@ class ResourceController extends genericController_1.GenericController {
                                 response = await this.headResource();
                                 break;
                             default:
-                                this.done(new RCError('Unsupported method'));
+                                this.done(new genericController_1.HandledError('Unsupported method'));
                         }
                     }
                     else {
@@ -102,17 +103,17 @@ class ResourceController extends genericController_1.GenericController {
                                 response = await this.headResources();
                                 break;
                             default:
-                                this.done(new RCError('Unsupported method'));
+                                this.done(new genericController_1.HandledError('Unsupported method'));
                         }
                     }
                     this.done(null, response);
                 }
                 catch (err) {
-                    this.done(this.remapHandlerError(err, 'HANDLER-ERROR', 'Operation failed'));
+                    this.done(this.handleControllerError(err, 'HANDLER-ERROR', 'Operation failed'));
                 }
             }
             catch (err) {
-                this.done(this.remapHandlerError(err, 'AUTH-CHECK-ERROR', 'Forbidden'));
+                this.done(this.handleControllerError(err, 'AUTH-CHECK-ERROR', 'Forbidden'));
             }
         };
         this.event = event;
@@ -138,11 +139,10 @@ class ResourceController extends genericController_1.GenericController {
             }
             if (options.useMetrics)
                 this.prepareMetrics();
-            this.logger.info('START', { event: this.getEventSummary() });
         }
         catch (err) {
             this.initError = true;
-            this.done(this.remapHandlerError(err, 'INIT-ERROR', 'Malformed request'));
+            this.done(this.handleControllerError(err, 'INIT-ERROR', 'Malformed request'));
         }
     }
     initFromEventV2(event, options) {
@@ -165,7 +165,7 @@ class ResourceController extends genericController_1.GenericController {
             this.body = (event.body ? JSON.parse(event.body) : {}) || {};
         }
         catch (error) {
-            throw new RCError('Malformed body');
+            throw new genericController_1.HandledError('Malformed body');
         }
     }
     initFromEventV1(event, options) {
@@ -187,7 +187,7 @@ class ResourceController extends genericController_1.GenericController {
             this.body = (event.body ? JSON.parse(event.body) : {}) || {};
         }
         catch (error) {
-            throw new RCError('Malformed body');
+            throw new genericController_1.HandledError('Malformed body');
         }
     }
     getEventSummary() {
@@ -213,17 +213,9 @@ class ResourceController extends genericController_1.GenericController {
         else
             return String(this.queryParams[paramName]).split(',');
     }
-    remapHandlerError(err, interceptedInContext, replaceWithMessage) {
-        if (err instanceof RCError)
-            return err;
-        const error = err;
-        error.unhandled = interceptedInContext;
-        error.internalMessage = error.message;
-        error.message = replaceWithMessage;
-        return error;
-    }
     done(error, rawResult, statusCode = this.returnStatusCode ?? (error ? 400 : 200)) {
         const result = error ? { message: error.message } : rawResult ?? {};
+        this.logger.debug('END-DETAIL', { result: Array.isArray(result) ? { array: result.length } : result });
         const finalLogContent = { statusCode, event: this.getEventSummary() };
         if (error) {
             if (error.unhandled)
@@ -233,7 +225,6 @@ class ResourceController extends genericController_1.GenericController {
         }
         else
             this.logger.info('END-SUCCESS', finalLogContent);
-        this.logger.debug('END-DETAIL', { result: Array.isArray(result) ? { array: result.length } : result });
         if (this.logRequestsWithKey)
             this.storeLog(!error);
         if (this.metrics)
@@ -254,73 +245,73 @@ class ResourceController extends genericController_1.GenericController {
      * To @override
      */
     async getResource() {
-        throw new RCError('Unsupported method');
+        throw new genericController_1.HandledError('Unsupported method');
     }
     /**
      * To @override
      */
     async postResource() {
-        throw new RCError('Unsupported method');
+        throw new genericController_1.HandledError('Unsupported method');
     }
     /**
      * To @override
      */
     async putResource() {
-        throw new RCError('Unsupported method');
+        throw new genericController_1.HandledError('Unsupported method');
     }
     /**
      * To @override
      */
     async deleteResource() {
-        throw new RCError('Unsupported method');
+        throw new genericController_1.HandledError('Unsupported method');
     }
     /**
      * To @override
      */
     async headResource() {
-        throw new RCError('Unsupported method');
+        throw new genericController_1.HandledError('Unsupported method');
     }
     /**
      * To @override
      */
     async getResources() {
-        throw new RCError('Unsupported method');
+        throw new genericController_1.HandledError('Unsupported method');
     }
     /**
      * To @override
      */
     async postResources() {
-        throw new RCError('Unsupported method');
+        throw new genericController_1.HandledError('Unsupported method');
     }
     /**
      * To @override
      */
     async putResources() {
-        throw new RCError('Unsupported method');
+        throw new genericController_1.HandledError('Unsupported method');
     }
     /**
      * To @override
      */
     async patchResource() {
-        throw new RCError('Unsupported method');
+        throw new genericController_1.HandledError('Unsupported method');
     }
     /**
      * To @override
      */
     async patchResources() {
-        throw new RCError('Unsupported method');
+        throw new genericController_1.HandledError('Unsupported method');
     }
     /**
      * To @override
      */
     async deleteResources() {
-        throw new RCError('Unsupported method');
+        throw new genericController_1.HandledError('Unsupported method');
     }
     /**
      * To @override
      */
     async headResources() {
-        throw new RCError('Unsupported method');
+        throw new genericController_1.HandledError('Unsupported method');
     }
     ///
     /// HELPERS
@@ -542,18 +533,3 @@ class ResourceController extends genericController_1.GenericController {
     }
 }
 exports.ResourceController = ResourceController;
-/**
- * Explicitly define a specific type of error to use in the RC's handler, to distinguish it from the normal errors.
- */
-class RCError extends Error {
-    constructor(message) {
-        super(message);
-        Object.setPrototypeOf(this, RCError.prototype);
-    }
-}
-exports.RCError = RCError;
-/**
- * An unhandled error thrown inside the RC (i.e. `!(error instanceof RCError)`) .
- */
-class RCUnhandledError extends Error {
-}

package/dist/src/streamController.d.ts

@@ -1,3 +1,4 @@
+import { DynamoDBRecord } from 'aws-lambda';
 import { GenericController } from './genericController';
 /**
  * An abstract class to inherit to manage AWS DDB streams in an AWS Lambda function.
@@ -5,4 +6,6 @@ import { GenericController } from './genericController';
 export declare abstract class StreamController extends GenericController {
     records: any[];
     constructor(event: any, callback: any);
+    protected abstract handleRecord(record: DynamoDBRecord): Promise<void>;
+    handleRequest(): Promise<void>;
 }

package/dist/src/streamController.js

@@ -9,7 +9,12 @@ class StreamController extends genericController_1.GenericController {
     constructor(event, callback) {
         super(event, callback);
         this.records = event.Records ?? [];
-        this.logger.info('START STREAM', { records: this.records.length ?? 0 });
+    }
+    async handleRequest() {
+        this.logger.info('START', { streamOfRecords: this.records.length ?? 0 });
+        await Promise.all(this.records.map(record => this.handleRecord(record)))
+            .then(() => this.done())
+            .catch((err) => this.done(this.handleControllerError(err, 'STREAM-ERROR', 'Operation failed')));
     }
 }
 exports.StreamController = StreamController;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "idea-aws",
-  "version": "4.3.3",
+  "version": "4.3.5",
   "description": "AWS wrappers to use in IDEA's back-ends",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -38,7 +38,7 @@
   "homepage": "https://iter-idea.github.io/IDEA-AWS",
   "dependencies": {
     "@aws-lambda-powertools/metrics": "^1.17.0",
-    "idea-toolbox": "^7.0.1",
+    "idea-toolbox": "^7.0.2",
     "nanoid": "^3.3.7",
     "nodemailer": "^6.9.8",
     "source-map-support": "^0.5.21"