idea-aws 4.4.21 → 4.5.0

package/dist/src/genericController.d.ts

@@ -5,22 +5,20 @@ import { LambdaLogger } from './lambdaLogger';
  */
 export declare abstract class GenericController {
     protected event: any;
-    protected callback: any;
     protected logger: LambdaLogger;
     /**
      * Initialize a new GenericController helper object.
      * @param event the event that invoked the AWS lambda function
-     * @param callback the callback to resolve or reject the execution
      */
-    constructor(event: any, callback: any);
+    constructor(event: any);
     /**
      * The main function (to override), that handles the request and must terminate invoking the method `done`.
      */
-    handleRequest(): Promise<void>;
+    handleRequest(): Promise<any>;
     /**
-     * Default callback for the Lambda.
+     * Default ending function for the Lambda.
      */
-    protected done(error?: Error | any, res?: any): void;
+    protected done(error?: Error | any, res?: any): any;
     /**
      * Remap an error to manage the logging and make sure no unhandled error is returned to the requester.
      */

package/dist/src/genericController.js

@@ -10,22 +10,20 @@ class GenericController {
     /**
      * Initialize a new GenericController helper object.
      * @param event the event that invoked the AWS lambda function
-     * @param callback the callback to resolve or reject the execution
      */
-    constructor(event, callback) {
+    constructor(event) {
         this.logger = new lambdaLogger_1.LambdaLogger();
         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();
+        return this.done();
     }
     /**
-     * Default callback for the Lambda.
+     * Default ending function for the Lambda.
      */
     done(error = null, res) {
         if (error) {
@@ -33,10 +31,12 @@ class GenericController {
                 this.logger.error('END-FAILED', error);
             else
                 this.logger.warn('END-FAILED', error);
+            throw error;
         }
-        else
+        else {
             this.logger.info('END-SUCCESS');
-        this.callback(error, res);
+            return res;
+        }
     }
     /**
      * Remap an error to manage the logging and make sure no unhandled error is returned to the requester.

package/dist/src/resourceController.d.ts

@@ -1,5 +1,5 @@
 import { Tracer } from '@aws-lambda-powertools/tracer';
-import { APIGatewayProxyEventV2, APIGatewayProxyEvent, Callback } from 'aws-lambda';
+import { APIGatewayProxyEventV2, APIGatewayProxyEvent } from 'aws-lambda';
 import { CognitoUser, Auth0User } from 'idea-toolbox';
 import { CloudWatchMetrics } from './metrics';
 import { GenericController } from './genericController';
@@ -8,8 +8,7 @@ import { GenericController } from './genericController';
  */
 export declare abstract class ResourceController extends GenericController {
     protected event: APIGatewayProxyEventV2 | APIGatewayProxyEvent;
-    protected callback: Callback;
-    protected initError: boolean;
+    protected initError?: Error;
     protected authorization: string;
     protected claims: any;
     protected principalId: string;
@@ -28,6 +27,7 @@ export declare abstract class ResourceController extends GenericController {
     protected clientVersion: string;
     protected clientPlatform: string;
     protected clientBundle: string;
+    protected returnHeaders: Record<string, string>;
     protected returnStatusCode?: number;
     protected logRequestsWithKey: string;
     protected metrics: CloudWatchMetrics;
@@ -38,7 +38,7 @@ export declare abstract class ResourceController extends GenericController {
     protected defaultLang: string;
     protected translations: any;
     protected templateMatcher: RegExp;
-    constructor(event: APIGatewayProxyEventV2 | APIGatewayProxyEvent, callback: Callback, options?: ResourceControllerOptions);
+    constructor(event: APIGatewayProxyEventV2 | APIGatewayProxyEvent, options?: ResourceControllerOptions);
     private initFromEventV2;
     private initFromEventV1;
     protected getEventSummary(limitBodyArrayDisplay?: boolean): Record<string, any>;
@@ -50,8 +50,8 @@ export declare abstract class ResourceController extends GenericController {
      * Force the parsing of a query parameter as a boolean.
      */
     protected getQueryParamAsBoolean(paramName: string): boolean;
-    handleRequest: () => Promise<void>;
-    protected done(error?: Error | any, rawResult?: any, statusCode?: number): void;
+    handleRequest: () => Promise<ResourceControllerResult>;
+    protected done(error?: Error | any, rawResult?: any, statusCode?: number, headers?: Record<string, string>): ResourceControllerResult;
     /**
      * To @override
      */
@@ -185,6 +185,14 @@ export interface ResourceControllerOptions {
      */
     tracer?: Tracer;
 }
+/**
+ * The result of a Resource Controller's execution.
+ */
+export interface ResourceControllerResult {
+    statusCode: number;
+    body: string;
+    headers: Record<string, string>;
+}
 /**
  * The parameters needed to invoke an internal API request.
  * @deprecated don't run a Lambda from another Lambda (bad practice).

package/dist/src/resourceController.js

@@ -48,22 +48,25 @@ ENV.POWERTOOLS_SERVICE_NAME = [PROJECT, STAGE, RESOURCE].filter(x => x).join('_'
  * An abstract class to inherit to manage API requests (AWS API Gateway) in an AWS Lambda function.
  */
 class ResourceController extends genericController_1.GenericController {
-    constructor(event, callback, options = {}) {
-        super(event, callback);
-        this.initError = false;
+    constructor(event, options = {}) {
+        super(event);
         this.project = PROJECT;
         this.stage = STAGE;
         this.resource = RESOURCE;
         this.clientVersion = '?';
         this.clientPlatform = '?';
         this.clientBundle = null;
+        this.returnHeaders = {
+            'Content-Type': 'application/json',
+            'Access-Control-Allow-Origin': '*'
+        };
         this.templateMatcher = /{{\s?([^{}\s]*)\s?}}/g;
         ///
         /// REQUEST HANDLERS
         ///
         this.handleRequest = async () => {
             if (this.initError)
-                return;
+                return this.done(this.handleControllerError(this.initError, 'INIT-ERROR', 'Malformed request'));
             this.logger.info('START', { event: this.getEventSummary() });
             if (this.tracer) {
                 this.tracerLambdaSegment = this.tracer.getSegment();
@@ -101,7 +104,7 @@ class ResourceController extends genericController_1.GenericController {
                                 response = await this.headResource();
                                 break;
                             default:
-                                this.done(new genericController_1.HandledError('Unsupported method'));
+                                return this.done(new genericController_1.HandledError('Unsupported method'));
                         }
                     }
                     else {
@@ -126,21 +129,20 @@ class ResourceController extends genericController_1.GenericController {
                                 response = await this.headResources();
                                 break;
                             default:
-                                this.done(new genericController_1.HandledError('Unsupported method'));
+                                return this.done(new genericController_1.HandledError('Unsupported method'));
                         }
                     }
-                    this.done(null, response);
+                    return this.done(null, response);
                 }
                 catch (err) {
-                    this.done(this.handleControllerError(err, 'HANDLER-ERROR', 'Operation failed'));
+                    return this.done(this.handleControllerError(err, 'HANDLER-ERROR', 'Operation failed'));
                 }
             }
             catch (err) {
-                this.done(this.handleControllerError(err, 'AUTH-CHECK-ERROR', 'Forbidden'));
+                return this.done(this.handleControllerError(err, 'AUTH-CHECK-ERROR', 'Forbidden'));
             }
         };
         this.event = event;
-        this.callback = callback;
         try {
             if (event.version === '2.0')
                 this.initFromEventV2(event, options);
@@ -164,9 +166,8 @@ class ResourceController extends genericController_1.GenericController {
             if (options.useMetrics)
                 this.prepareMetrics();
         }
-        catch (err) {
-            this.initError = true;
-            this.done(this.handleControllerError(err, 'INIT-ERROR', 'Malformed request'));
+        catch (error) {
+            this.initError = error;
         }
     }
     initFromEventV2(event, options) {
@@ -243,7 +244,7 @@ class ResourceController extends genericController_1.GenericController {
     getQueryParamAsBoolean(paramName) {
         return this.queryParams[paramName] && this.queryParams[paramName].toLowerCase() !== 'false';
     }
-    done(error, rawResult, statusCode = this.returnStatusCode ?? (error ? 400 : 200)) {
+    done(error, rawResult, statusCode = this.returnStatusCode ?? (error ? 400 : 200), headers = this.returnHeaders) {
         const result = error ? { message: error.message } : rawResult ?? {};
         const responseTrace = { result: Array.isArray(result) ? { array: result.length } : result };
         this.logger.debug('END-DETAIL', responseTrace);
@@ -270,11 +271,7 @@ class ResourceController extends genericController_1.GenericController {
             this.storeLog(!error);
         if (this.metrics)
             this.publishMetrics(statusCode, error);
-        this.callback(null, {
-            statusCode: String(statusCode),
-            body: JSON.stringify(result),
-            headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' }
-        });
+        return { statusCode, body: JSON.stringify(result), headers };
     }
     /**
      * To @override

package/dist/src/streamController.d.ts

@@ -5,7 +5,7 @@ import { GenericController } from './genericController';
  */
 export declare abstract class StreamController extends GenericController {
     records: any[];
-    constructor(event: any, callback: any);
+    constructor(event: any);
     protected abstract handleRecord(record: DynamoDBRecord): Promise<void>;
     handleRequest(): Promise<void>;
 }

package/dist/src/streamController.js

@@ -6,15 +6,19 @@ const genericController_1 = require("./genericController");
  * An abstract class to inherit to manage AWS DDB streams in an AWS Lambda function.
  */
 class StreamController extends genericController_1.GenericController {
-    constructor(event, callback) {
-        super(event, callback);
+    constructor(event) {
+        super(event);
         this.records = event.Records ?? [];
     }
     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')));
+        try {
+            await Promise.all(this.records.map(record => this.handleRecord(record)));
+            return this.done();
+        }
+        catch (err) {
+            return this.done(this.handleControllerError(err, 'STREAM-ERROR', 'Operation failed'));
+        }
     }
 }
 exports.StreamController = StreamController;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "idea-aws",
-  "version": "4.4.21",
+  "version": "4.5.0",
   "description": "AWS wrappers to use in IDEA's back-ends",
   "license": "MPL-2.0",
   "main": "dist/index.js",