idea-aws 3.9.2 → 3.10.3

package/dist/index.d.ts

@@ -10,3 +10,4 @@ export * from './src/ses';
 export * from './src/sns';
 export * from './src/translate';
 export * from './src/attachments';
+export * from './src/logger';

package/dist/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./src/ses"), exports);
 __exportStar(require("./src/sns"), exports);
 __exportStar(require("./src/translate"), exports);
 __exportStar(require("./src/attachments"), exports);
+__exportStar(require("./src/logger"), exports);

package/dist/src/attachments.js

@@ -3,9 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Attachments = void 0;
 const dynamoDB_1 = require("./dynamoDB");
 const s3_1 = require("./s3");
-// declare libs as global vars to be reused in warm starts by the Lambda function
-let ideaWarmStart_ddb = null;
-let ideaWarmStart_s3 = null;
 /**
  * A custom class that takes advantage of DynamoDB and S3 to easily manage attachments.
  */
@@ -16,12 +13,8 @@ class Attachments {
          */
         this.S3_ATTACHMENTS_BUCKET = process.env['S3_ATTACHMENTS_BUCKET'] || 'idea-attachments';
         this.IUID_ATTACHMENTS_PREFIX = process.env['IUID_ATTACHMENTS_PREFIX'] || 'ATT';
-        if (!ideaWarmStart_ddb)
-            ideaWarmStart_ddb = new dynamoDB_1.DynamoDB();
-        this.dynamo = ideaWarmStart_ddb;
-        if (!ideaWarmStart_s3)
-            ideaWarmStart_s3 = new s3_1.S3();
-        this.s3 = ideaWarmStart_s3;
+        this.dynamo = new dynamoDB_1.DynamoDB();
+        this.s3 = new s3_1.S3();
     }
     /**
      * Get a signedURL to put an attachment.

package/dist/src/cognito.d.ts

@@ -5,7 +5,9 @@ import { CognitoUser } from 'idea-toolbox';
  */
 export declare class Cognito {
     protected cognito: CognitoIdentityServiceProvider;
-    constructor();
+    constructor(params?: {
+        region?: string;
+    });
     /**
      * Change the region in which to find the user pool.
      * Default: the runner's (e.g. Lambda function) region.

package/dist/src/cognito.js

@@ -3,16 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cognito = void 0;
 const aws_sdk_1 = require("aws-sdk");
 const idea_toolbox_1 = require("idea-toolbox");
-// declare libs as global vars to be reused in warm starts by the Lambda function
-let ideaWarmStart_cognito = null;
 /**
  * A wrapper for AWS Cognito.
  */
 class Cognito {
-    constructor() {
-        if (!ideaWarmStart_cognito)
-            ideaWarmStart_cognito = new aws_sdk_1.CognitoIdentityServiceProvider({ apiVersion: '2016-04-18' });
-        this.cognito = ideaWarmStart_cognito;
+    constructor(params = {}) {
+        this.cognito = new aws_sdk_1.CognitoIdentityServiceProvider({ apiVersion: '2016-04-18', region: params.region });
     }
     /**
      * Change the region in which to find the user pool.
@@ -20,8 +16,7 @@ class Cognito {
      */
     setRegion(region) {
         // there is no quick way to change the region without re-creating the object
-        ideaWarmStart_cognito = new aws_sdk_1.CognitoIdentityServiceProvider({ apiVersion: this.cognito.config.apiVersion, region });
-        this.cognito = ideaWarmStart_cognito;
+        this.cognito = new aws_sdk_1.CognitoIdentityServiceProvider({ apiVersion: this.cognito.config.apiVersion, region });
     }
     /**
      * Get the attributes of the user, from the authorizer claims.

package/dist/src/comprehend.js

@@ -2,16 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Comprehend = void 0;
 const aws_sdk_1 = require("aws-sdk");
-// declare libs as global vars to be reused in warm starts by the Lambda function
-let ideaWarmStart_comprehend = null;
 /**
  * A wrapper for Amazon Comprehend.
  */
 class Comprehend {
     constructor() {
-        if (!ideaWarmStart_comprehend)
-            ideaWarmStart_comprehend = new aws_sdk_1.Comprehend({ apiVersion: '2017-11-27' });
-        this.comprehend = ideaWarmStart_comprehend;
+        this.comprehend = new aws_sdk_1.Comprehend({ apiVersion: '2017-11-27' });
     }
     /**
      * Inspects text and returns an inference of the prevailing sentiment (POSITIVE, NEUTRAL, MIXED, or NEGATIVE).

package/dist/src/dynamoDB.js

@@ -6,17 +6,14 @@ const uuid_1 = require("uuid");
 const nanoid_1 = require("nanoid");
 const NanoID = (0, nanoid_1.customAlphabet)('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz', 25);
 const shortid_1 = require("shortid");
-const idea_toolbox_1 = require("idea-toolbox");
-// declare libs as global vars to be reused in warm starts by the Lambda function
-let ideaWarmStart_ddb = null;
+const logger_1 = require("./logger");
+const logger = new logger_1.Logger();
 /**
  * A wrapper for AWS DynamoDB.
  */
 class DynamoDB {
     constructor() {
-        if (!ideaWarmStart_ddb)
-            ideaWarmStart_ddb = new aws_sdk_1.DynamoDB.DocumentClient();
-        this.dynamo = ideaWarmStart_ddb;
+        this.dynamo = new aws_sdk_1.DynamoDB.DocumentClient();
     }
     /**
      * Convert a JSON object from dynamoDB format to simple JSON.
@@ -104,7 +101,7 @@ class DynamoDB {
      * @param key the key of the counter
      */
     async getAtomicCounterByKey(key) {
-        (0, idea_toolbox_1.logger)(`GET ATOMIC COUNTER FOR ${key}`);
+        logger.debug(`Get atomic counter for ${key}`);
         const result = await this.update({
             TableName: 'idea_atomicCounters',
             Key: { key },
@@ -121,7 +118,7 @@ class DynamoDB {
      * Get an item of a DynamoDB table.
      */
     async get(params) {
-        (0, idea_toolbox_1.logger)(`GET ${params.TableName}`);
+        logger.debug(`Get ${params.TableName}`);
         const result = await this.dynamo.get(params).promise();
         if (!result?.Item)
             throw new Error('Not found');
@@ -131,21 +128,21 @@ class DynamoDB {
      * Put an item in a DynamoDB table.
      */
     async put(params) {
-        (0, idea_toolbox_1.logger)(`PUT ${params.TableName}`);
+        logger.debug(`Put ${params.TableName}`);
         return await this.dynamo.put(params).promise();
     }
     /**
      * Update an item of a DynamoDB table.
      */
     async update(params) {
-        (0, idea_toolbox_1.logger)(`UPDATE ${params.TableName}`);
+        logger.debug(`Update ${params.TableName}`);
         return await this.dynamo.update(params).promise();
     }
     /**
      * Delete an item of a DynamoDB table.
      */
     async delete(params) {
-        (0, idea_toolbox_1.logger)(`DELETE ${params.TableName}`);
+        logger.debug(`Delete ${params.TableName}`);
         return await this.dynamo.delete(params).promise();
     }
     /**
@@ -154,7 +151,7 @@ class DynamoDB {
      */
     async batchGet(table, keys, ignoreErr) {
         if (!keys.length) {
-            (0, idea_toolbox_1.logger)(`BATCH GET ${table}`, null, 'No elements to get');
+            logger.debug(`Batch get ${table}: no elements to get`);
             return [];
         }
         return await this.batchGetHelper(table, keys, [], Boolean(ignoreErr));
@@ -165,7 +162,7 @@ class DynamoDB {
                 [table]: { Keys: keys.slice(currentChunk, currentChunk + chunkSize) }
             }
         };
-        (0, idea_toolbox_1.logger)(`BATCH GET ${table}`, null, `${currentChunk} of ${keys.length}`);
+        logger.debug(`Batch get ${table}: ${currentChunk} of ${keys.length}`);
         let result;
         try {
             result = await this.dynamo.batchGet(batch).promise();
@@ -190,7 +187,7 @@ class DynamoDB {
      */
     async batchPut(table, items) {
         if (!items.length)
-            return (0, idea_toolbox_1.logger)(`BATCH WRITE (PUT) ${table}`, null, 'No elements to write');
+            return logger.debug(`Batch write (put) ${table}: no elements to write`);
         await this.batchWriteHelper(table, items, true);
     }
     /**
@@ -200,11 +197,11 @@ class DynamoDB {
      */
     async batchDelete(table, keys) {
         if (!keys.length)
-            return (0, idea_toolbox_1.logger)(`BATCH WRITE (DELETE) ${table}`, null, 'No elements to write');
+            return logger.debug(`Batch write (delete) ${table}: no elements to write`);
         await this.batchWriteHelper(table, keys, false);
     }
     async batchWriteHelper(table, itemsOrKeys, isPut, currentChunk = 0, chunkSize = 25) {
-        (0, idea_toolbox_1.logger)(`BATCH WRITE (${isPut ? 'PUT' : 'DELETE'}) ${table}`, null, `${currentChunk} of ${itemsOrKeys.length}`);
+        logger.debug(`Batch write (${isPut ? 'put' : 'delete'}) ${table}: ${currentChunk} of ${itemsOrKeys.length}`);
         let requests;
         if (isPut)
             requests = itemsOrKeys.slice(currentChunk, currentChunk + chunkSize).map(i => ({ PutRequest: { Item: i } }));
@@ -229,7 +226,7 @@ class DynamoDB {
                 params.RequestItems = response.UnprocessedItems;
                 attempts++;
                 const waitSeconds = getRandomInt(attempts * 5);
-                (0, idea_toolbox_1.logger)('BATCH WRITE THROTTLED', null, `Waiting ${waitSeconds} seconds to retry`);
+                logger.debug(`Batch write throttled: waiting ${waitSeconds} seconds to retry`);
                 await wait(waitSeconds);
             }
             else {
@@ -242,9 +239,9 @@ class DynamoDB {
      * @param params the params to apply to DynamoDB's function
      */
     async query(params) {
-        (0, idea_toolbox_1.logger)(`Query ${params.TableName}`);
+        logger.debug(`Query ${params.TableName}`);
         const result = await this.queryScanHelper(params, [], true);
-        (0, idea_toolbox_1.logger)(`\tResults query ${params.TableName}`, null, result?.length || 0);
+        logger.debug(`Results query ${params.TableName}: ${result?.length || 0}`);
         return result;
     }
     /**
@@ -252,9 +249,9 @@ class DynamoDB {
      * @param params the params to apply to DynamoDB's function
      */
     async scan(params) {
-        (0, idea_toolbox_1.logger)(`Scan ${params.TableName}`);
+        logger.debug(`Scan ${params.TableName}`);
         const result = await this.queryScanHelper(params, [], false);
-        (0, idea_toolbox_1.logger)(`\tResults scan ${params.TableName}`, null, result?.length || 0);
+        logger.debug(`Results scan ${params.TableName}: ${result?.length || 0}`);
         return result;
     }
     async queryScanHelper(params, items, isQuery) {
@@ -276,9 +273,9 @@ class DynamoDB {
      * @param params the params to apply to DynamoDB's function
      */
     async queryClassic(params) {
-        (0, idea_toolbox_1.logger)(`Query classic ${params.TableName}`);
+        logger.debug(`Query classic ${params.TableName}`);
         const result = await this.dynamo.query(params).promise();
-        (0, idea_toolbox_1.logger)(`\tResults query classic ${params.TableName}`, null, result?.Items?.length || 0);
+        logger.debug(`Results query classic ${params.TableName}: ${result?.Items?.length || 0}`);
         return result;
     }
     /**
@@ -286,9 +283,9 @@ class DynamoDB {
      * @param params the params to apply to DynamoDB's function
      */
     async scanClassic(params) {
-        (0, idea_toolbox_1.logger)(`Scan classic ${params.TableName}`);
+        logger.debug(`Scan classic ${params.TableName}`);
         const result = await this.dynamo.scan(params).promise();
-        (0, idea_toolbox_1.logger)(`\tResults scan classic ${params.TableName}`, null, result?.Items?.length || 0);
+        logger.debug(`Results scan classic ${params.TableName}: ${result?.Items?.length || 0}`);
         return result;
     }
     /**
@@ -297,8 +294,8 @@ class DynamoDB {
      */
     async transactWrites(ops) {
         if (!ops.length)
-            return (0, idea_toolbox_1.logger)('TRANSACTION WRITES', null, 'No elements to write');
-        (0, idea_toolbox_1.logger)('TRANSACTION WRITES');
+            return logger.debug('Transaction writes: no elements to write');
+        logger.debug('Transaction writes');
         await this.dynamo.transactWrite({ TransactItems: ops.slice(0, 10) }).promise();
     }
     /**

package/dist/src/genericController.d.ts

@@ -7,6 +7,7 @@ import { Translate } from './translate';
 import { Comprehend } from './comprehend';
 import { SecretsManager } from './secretsManager';
 import { Attachments } from './attachments';
+import { Logger } from './logger';
 /**
  * An abstract class to inherit to manage some resources with an AWS Lambda function.
  */
@@ -23,6 +24,7 @@ export declare abstract class GenericController {
     protected _secrets: SecretsManager;
     protected _attachments: Attachments;
     tables: any;
+    protected logger: Logger;
     protected logRequestsWithKey: string;
     /**
      * Initialize a new GenericController helper object.
@@ -37,31 +39,57 @@ export declare abstract class GenericController {
     /**
      * Default callback for the Lambda.
      */
-    protected done(err: Error | null, res?: any): void;
+    protected done(err: any, res?: any): void;
+    /**
+     * @deprecated use external object to improve cold starts. See most recent projects for reference.
+     */
     protected get dynamoDB(): DynamoDB;
     protected set dynamoDB(dynamoDB: DynamoDB);
+    /**
+     * @deprecated use external object to improve cold starts. See most recent projects for reference.
+     */
     protected get cognito(): Cognito;
     protected set cognito(cognito: Cognito);
+    /**
+     * @deprecated use external object to improve cold starts. See most recent projects for reference.
+     */
     protected get s3(): S3;
     protected set s3(s3: S3);
+    /**
+     * @deprecated use external object to improve cold starts. See most recent projects for reference.
+     */
     protected get ses(): SES;
     protected set ses(ses: SES);
+    /**
+     * @deprecated use external object to improve cold starts. See most recent projects for reference.
+     */
     protected get sns(): SNS;
     protected set sns(sns: SNS);
+    /**
+     * @deprecated use external object to improve cold starts. See most recent projects for reference.
+     */
     protected get translate(): Translate;
     protected set translate(translate: Translate);
+    /**
+     * @deprecated use external object to improve cold starts. See most recent projects for reference.
+     */
     protected get comprehend(): Comprehend;
     protected set comprehend(comprehend: Comprehend);
+    /**
+     * @deprecated use external object to improve cold starts. See most recent projects for reference.
+     */
     protected get secrets(): SecretsManager;
     protected set secrets(secrets: SecretsManager);
     /**
      * Manage attachments (through SignedURLs).
+     * @deprecated use external object to improve cold starts. See most recent projects for reference.
      */
     get attachments(): Attachments;
     set attachments(attachments: Attachments);
 }
 /**
  * The initial options for a constructor of class GenericController.
+ * @deprecated following new IAC standards.
  */
 export interface GenericControllerOptions {
     /**

package/dist/src/genericController.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenericController = void 0;
-const idea_toolbox_1 = require("idea-toolbox");
 const dynamoDB_1 = require("./dynamoDB");
 const cognito_1 = require("./cognito");
 const s3_1 = require("./s3");
@@ -11,6 +10,7 @@ const translate_1 = require("./translate");
 const comprehend_1 = require("./comprehend");
 const secretsManager_1 = require("./secretsManager");
 const attachments_1 = require("./attachments");
+const logger_1 = require("./logger");
 /**
  * An abstract class to inherit to manage some resources with an AWS Lambda function.
  */
@@ -21,23 +21,27 @@ class GenericController {
      * @param callback the callback to resolve or reject the execution
      */
     constructor(event, callback, options = {}) {
+        this.logger = new logger_1.Logger();
         this.event = event;
         this.callback = callback;
         this.tables = options.tables || {};
-        // set the logs to print objects deeper
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        require('util').inspect.defaultOptions.depth = null;
     }
     /**
      * Default callback for the Lambda.
      */
     done(err, res) {
-        (0, idea_toolbox_1.logger)(err ? 'DONE WITH ERRORS' : 'DONE', err, res, true);
+        if (err)
+            this.logger.info('END-FAILED', { error: err.message || err.errorMessage });
+        else
+            this.logger.info('END-SUCCESS');
         this.callback(err, res);
     }
     ///
     /// AWS SERVICES
     ///
+    /**
+     * @deprecated use external object to improve cold starts. See most recent projects for reference.
+     */
     get dynamoDB() {
         if (!this._dynamoDB)
             this._dynamoDB = new dynamoDB_1.DynamoDB();
@@ -46,6 +50,9 @@ class GenericController {
     set dynamoDB(dynamoDB) {
         this._dynamoDB = dynamoDB;
     }
+    /**
+     * @deprecated use external object to improve cold starts. See most recent projects for reference.
+     */
     get cognito() {
         if (!this._cognito)
             this._cognito = new cognito_1.Cognito();
@@ -54,6 +61,9 @@ class GenericController {
     set cognito(cognito) {
         this._cognito = cognito;
     }
+    /**
+     * @deprecated use external object to improve cold starts. See most recent projects for reference.
+     */
     get s3() {
         if (!this._s3)
             this._s3 = new s3_1.S3();
@@ -62,6 +72,9 @@ class GenericController {
     set s3(s3) {
         this._s3 = s3;
     }
+    /**
+     * @deprecated use external object to improve cold starts. See most recent projects for reference.
+     */
     get ses() {
         if (!this._ses)
             this._ses = new ses_1.SES();
@@ -70,6 +83,9 @@ class GenericController {
     set ses(ses) {
         this._ses = ses;
     }
+    /**
+     * @deprecated use external object to improve cold starts. See most recent projects for reference.
+     */
     get sns() {
         if (!this._sns)
             this._sns = new sns_1.SNS();
@@ -78,6 +94,9 @@ class GenericController {
     set sns(sns) {
         this._sns = sns;
     }
+    /**
+     * @deprecated use external object to improve cold starts. See most recent projects for reference.
+     */
     get translate() {
         if (!this._translate)
             this._translate = new translate_1.Translate();
@@ -86,6 +105,9 @@ class GenericController {
     set translate(translate) {
         this._translate = translate;
     }
+    /**
+     * @deprecated use external object to improve cold starts. See most recent projects for reference.
+     */
     get comprehend() {
         if (!this._comprehend)
             this._comprehend = new comprehend_1.Comprehend();
@@ -94,6 +116,9 @@ class GenericController {
     set comprehend(comprehend) {
         this._comprehend = comprehend;
     }
+    /**
+     * @deprecated use external object to improve cold starts. See most recent projects for reference.
+     */
     get secrets() {
         if (!this._secrets)
             this._secrets = new secretsManager_1.SecretsManager();
@@ -107,6 +132,7 @@ class GenericController {
     ///
     /**
      * Manage attachments (through SignedURLs).
+     * @deprecated use external object to improve cold starts. See most recent projects for reference.
      */
     get attachments() {
         if (!this._attachments)

package/dist/src/logger.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Manage structured logging.
+ */
+export declare class Logger {
+    level: string;
+    private originalLevel;
+    constructor({ level }?: {
+        level?: string;
+    });
+    isEnabled(level: number): boolean;
+    appendError(params: any, err: Error): any;
+    log(levelName: string, message: string, params: any): void;
+    debug(msg: string, params?: any): void;
+    info(msg: string, params?: any): void;
+    warn(msg: string, err: Error | any, params?: any): void;
+    error(msg: string, err: Error | any, params?: any): void;
+    enableDebug(): () => void;
+    resetLevel(): void;
+}

package/dist/src/logger.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+/**
+ * Manage structured logging.
+ */
+class Logger {
+    constructor({ level = process.env.LOG_LEVEL } = {}) {
+        this.level = (level || 'DEBUG').toUpperCase();
+        this.originalLevel = this.level;
+    }
+    isEnabled(level) {
+        return level >= (LogLevels[this.level] || LogLevels.DEBUG);
+    }
+    appendError(params, err) {
+        if (!err)
+            return params;
+        return { ...(params || {}), errorName: err.name, errorMessage: err.message, stackTrace: err.stack };
+    }
+    log(levelName, message, params) {
+        const level = LogLevels[levelName];
+        if (!this.isEnabled(level))
+            return;
+        const logMsg = { ...params, level, sLevel: levelName, message };
+        const consoleMethods = { DEBUG: console.debug, INFO: console.info, WARN: console.warn, ERROR: console.error };
+        // re-order message and params to appear earlier in the log row
+        consoleMethods[levelName](JSON.stringify({ message, ...params, ...logMsg }, (_, value) => typeof value === 'bigint' ? value.toString() : value));
+    }
+    debug(msg, params = {}) {
+        this.log('DEBUG', msg, params);
+    }
+    info(msg, params = {}) {
+        this.log('INFO', msg, params);
+    }
+    warn(msg, err, params = {}) {
+        const parameters = this.appendError(params, err);
+        this.log('WARN', msg, parameters);
+    }
+    error(msg, err, params = {}) {
+        const parameters = this.appendError(params, err);
+        this.log('ERROR', msg, parameters);
+    }
+    enableDebug() {
+        this.level = 'DEBUG';
+        return () => this.resetLevel();
+    }
+    resetLevel() {
+        this.level = this.originalLevel;
+    }
+}
+exports.Logger = Logger;
+// levels here are identical to bunyan practices (https://github.com/trentm/node-bunyan#levels)
+const LogLevels = { DEBUG: 20, INFO: 30, WARN: 40, ERROR: 50 };

package/dist/src/resourceController.d.ts

@@ -1,28 +1,39 @@
+import 'source-map-support/register';
+import { APIGatewayProxyEventV2, APIGatewayProxyEvent, Callback } from 'aws-lambda';
 import { CognitoUser } from 'idea-toolbox';
+import { Logger } from './logger';
 import { GenericController, GenericControllerOptions } from './genericController';
 /**
  * An abstract class to inherit to manage API requests (AWS API Gateway) in an AWS Lambda function.
  */
 export declare abstract class ResourceController extends GenericController {
+    protected event: APIGatewayProxyEventV2 | APIGatewayProxyEvent;
+    protected callback: Callback;
     protected authorization: string;
     protected claims: any;
     protected principalId: string;
-    protected user: CognitoUser;
+    protected cognitoUser: CognitoUser;
     protected stage: string;
     protected httpMethod: string;
-    body: any;
-    queryParams: any;
+    protected body: any;
+    protected queryParams: any;
     protected resource: string;
     protected path: string;
+    protected pathParameters: any;
     protected resourceId: string;
+    protected returnStatusCode?: number;
+    protected logger: Logger;
     protected logRequestsWithKey: string;
     protected currentLang: string;
     protected defaultLang: string;
     protected translations: any;
     protected templateMatcher: RegExp;
-    constructor(event: any, callback: any, options?: ResourceControllerOptions);
+    constructor(event: APIGatewayProxyEventV2 | APIGatewayProxyEvent, callback: Callback, options?: ResourceControllerOptions);
+    private initFromEventV2;
+    private initFromEventV1;
     handleRequest: () => Promise<void>;
-    protected done(err: Error | null, res?: any, statusCode?: number): void;
+    private controlHandlerError;
+    protected done(err: any, res?: any, statusCode?: number): void;
     /**
      * To @override
      */
@@ -95,6 +106,9 @@ export declare abstract class ResourceController extends GenericController {
      * @deprecated don't run a Lambda from another Lambda (bad practice)
      */
     invokeInternalAPIRequest(params: InternalAPIRequestParams): Promise<any>;
+    private invokeInternalAPIRequestWithLambda;
+    private invokeInternalAPIRequestWithEventBridge;
+    private mapEventForInternalApiRequest;
     /**
      * Whether the current request comes from an internal API request, i.e. it was invoked by another controller.
      * @deprecated don't run a Lambda from another Lambda (bad practice)
@@ -139,13 +153,26 @@ export interface ResourceControllerOptions extends GenericControllerOptions {
 }
 /**
  * The parameters needed to invoke an internal API request.
- * @deprecated don't run a Lambda from another Lambda (bad practice)
+ * @deprecated don't run a Lambda from another Lambda (bad practice).
  */
 export interface InternalAPIRequestParams {
     /**
-     * The name of the lambda function receiving the request; e.g. `project_memberships`.
+     * The name of the Lambda function receiving the request; e.g. `project_memberships`.
+     * Note: the invocation is always syncronous.
+     * Either this attribute or `eventBus` must be set.
      */
-    lambda: string;
+    lambda?: string;
+    /**
+     * The EventBridge destination of the request.
+     * If the bus name or ARN isn't specified, the default one is used.
+     * The `target` maps into the `DetailType` of the event.
+     * Note: the invocation is always asyncronous.
+     * Either this attribute or `lambda` must be set.
+     */
+    eventBridge?: {
+        bus?: string;
+        target?: string;
+    };
     /**
      * The alias of the lambda function to invoke. Default: the value of the current API stage.
      */
@@ -175,3 +202,9 @@ 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

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResourceController = void 0;
-/* eslint-disable no-invalid-this */
+exports.RCError = exports.ResourceController = void 0;
+require("source-map-support/register");
 const fs_1 = require("fs");
 const aws_sdk_1 = require("aws-sdk");
 const idea_toolbox_1 = require("idea-toolbox");
+const logger_1 = require("./logger");
 const genericController_1 = require("./genericController");
 /**
  * An abstract class to inherit to manage API requests (AWS API Gateway) in an AWS Lambda function.
@@ -12,6 +13,7 @@ const genericController_1 = require("./genericController");
 class ResourceController extends genericController_1.GenericController {
     constructor(event, callback, options = {}) {
         super(event, callback, options);
+        this.logger = new logger_1.Logger();
         this.templateMatcher = /{{\s?([^{}\s]*)\s?}}/g;
         ///
         /// REQUEST HANDLERS
@@ -43,7 +45,7 @@ class ResourceController extends genericController_1.GenericController {
                                 response = await this.headResource();
                                 break;
                             default:
-                                this.done(new Error('Unsupported method'));
+                                this.done(new RCError('Unsupported method'));
                         }
                     }
                     else {
@@ -68,35 +70,25 @@ class ResourceController extends genericController_1.GenericController {
                                 response = await this.headResources();
                                 break;
                             default:
-                                this.done(new Error('Unsupported method'));
+                                this.done(new RCError('Unsupported method'));
                         }
                     }
                     this.done(null, response);
                 }
                 catch (err) {
-                    const errorMessage = err?.message || err?.errorMessage || 'Operation failed';
-                    this.done(new Error(errorMessage));
+                    this.done(this.controlHandlerError(err, 'HANDLER-ERROR', 'Operation failed'));
                 }
             }
             catch (err) {
-                const errorMessage = err?.message || err?.errorMessage || 'Forbidden';
-                this.done(new Error(errorMessage));
+                this.done(this.controlHandlerError(err, 'AUTH-CHECK-ERROR', 'Forbidden'));
             }
         };
-        this.authorization = event.headers?.Authorization;
-        this.claims = event.requestContext?.authorizer?.claims;
-        this.principalId = this.claims?.sub;
-        this.user = this.principalId ? new idea_toolbox_1.CognitoUser(this.claims) : null;
-        this.stage = event.requestContext?.stage;
-        this.httpMethod = event.httpMethod;
-        this.resource = (event.resource || '').replace('+', ''); // {proxy+} -> {proxy}
-        this.path = event.path || '';
-        this.resourceId =
-            event.pathParameters && event.pathParameters[options.resourceId || 'proxy']
-                ? decodeURIComponent(event.pathParameters[options.resourceId || 'proxy'])
-                : '';
-        this.queryParams = event.queryStringParameters || {};
-        this.body = (event.body ? JSON.parse(event.body) : {}) || {};
+        this.event = event;
+        this.callback = callback;
+        if (event.version === '2.0')
+            this.initFromEventV2(event, options);
+        else
+            this.initFromEventV1(event, options);
         this.logRequestsWithKey = options.logRequestsWithKey;
         // acquire some info about the client, if available
         let version = '?', platform = '?';
@@ -110,15 +102,55 @@ class ResourceController extends genericController_1.GenericController {
         }
         // print the initial log
         const info = { principalId: this.principalId, queryParams: this.queryParams, body: this.body, version, platform };
-        (0, idea_toolbox_1.logger)(`START: ${this.httpMethod} ${this.stage} ${this.path}`, null, info, true);
+        this.logger.info(`START: ${this.httpMethod} ${this.path}`, info);
+    }
+    initFromEventV2(event, options) {
+        this.authorization = event.headers.authorization;
+        const contextFromAuthorizer = event.requestContext?.authorizer?.lambda || {};
+        this.principalId = contextFromAuthorizer.principalId;
+        this.stage = event.requestContext.stage;
+        this.httpMethod = event.requestContext.http.method;
+        this.resource = event.routeKey.replace('+', ''); // {proxy+} -> {proxy}
+        this.path = event.rawPath;
+        this.pathParameters = {};
+        for (const param in event.pathParameters)
+            this.pathParameters[param] = event.pathParameters[param] ? decodeURIComponent(event.pathParameters[param]) : null;
+        this.resourceId = this.pathParameters[options.resourceId || 'proxy'];
+        this.queryParams = event.queryStringParameters || {};
+        this.body = (event.body ? JSON.parse(event.body) : {}) || {};
+    }
+    initFromEventV1(event, options) {
+        this.authorization = event.headers.Authorization;
+        this.claims = event.requestContext.authorizer?.claims || {};
+        this.principalId = this.claims.sub;
+        this.cognitoUser = this.principalId ? new idea_toolbox_1.CognitoUser(this.claims) : null;
+        this.stage = event.requestContext.stage;
+        this.httpMethod = event.httpMethod;
+        this.resource = event.resource.replace('+', ''); // {proxy+} -> {proxy}
+        this.path = event.path;
+        this.pathParameters = {};
+        for (const param in event.pathParameters)
+            this.pathParameters[param] = event.pathParameters[param] ? decodeURIComponent(event.pathParameters[param]) : null;
+        this.resourceId = this.pathParameters[options.resourceId || 'proxy'];
+        this.queryParams = event.queryStringParameters || {};
+        this.body = (event.body ? JSON.parse(event.body) : {}) || {};
+    }
+    controlHandlerError(err = {}, context, replaceWithErrorMessage) {
+        if (err instanceof RCError)
+            return new Error(err.message);
+        this.logger.error(context, err);
+        return new Error(replaceWithErrorMessage);
     }
-    done(err, res, statusCode) {
-        (0, idea_toolbox_1.logger)(err ? 'DONE WITH ERRORS' : 'DONE', err, res, true);
+    done(err, res, statusCode = this.returnStatusCode || (err ? 400 : 200)) {
+        if (err)
+            this.logger.info('END-FAILED', { statusCode, error: err.message || err.errorMessage });
+        else
+            this.logger.info('END-SUCCESS', { statusCode });
         // if configured, store the log of the request
         if (this.logRequestsWithKey)
             this.storeLog(!err);
         this.callback(null, {
-            statusCode: statusCode ?? (err ? '400' : '200'),
+            statusCode: String(statusCode),
             body: err ? JSON.stringify({ message: err.message }) : JSON.stringify(res || {}),
             headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' }
         });
@@ -133,73 +165,73 @@ class ResourceController extends genericController_1.GenericController {
      * To @override
      */
     async getResource() {
-        throw new Error('Unsupported method');
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
     async postResource() {
-        throw new Error('Unsupported method');
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
     async putResource() {
-        throw new Error('Unsupported method');
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
     async deleteResource() {
-        throw new Error('Unsupported method');
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
     async headResource() {
-        throw new Error('Unsupported method');
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
     async getResources() {
-        throw new Error('Unsupported method');
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
     async postResources() {
-        throw new Error('Unsupported method');
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
     async putResources() {
-        throw new Error('Unsupported method');
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
     async patchResource() {
-        throw new Error('Unsupported method');
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
     async patchResources() {
-        throw new Error('Unsupported method');
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
     async deleteResources() {
-        throw new Error('Unsupported method');
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
     async headResources() {
-        throw new Error('Unsupported method');
+        throw new RCError('Unsupported method');
     }
     ///
     /// HELPERS
@@ -251,47 +283,56 @@ class ResourceController extends genericController_1.GenericController {
      * @return the body of the response
      * @deprecated don't run a Lambda from another Lambda (bad practice)
      */
-    invokeInternalAPIRequest(params) {
-        return new Promise((resolve, reject) => {
-            // create a copy of the event
-            const event = JSON.parse(JSON.stringify(this.event));
-            // change only the event attributes we need; e.g. the authorization is unchanged
-            event.stage = params.stage || this.stage;
-            event.httpMethod = params.httpMethod;
-            event.resource = params.resource;
-            event.pathParameters = params.pathParams || {};
-            event.queryStringParameters = params.queryParams || {};
-            event.body = JSON.stringify(params.body || {});
-            // parse the path
-            event.path = event.resource;
-            for (const p in event.pathParameters)
-                if (event.pathParameters[p])
-                    event.resource = event.resource.replace(`{${p}}`, event.pathParameters[p]);
-            // set a flag to make the invoked to recognise that is an internal request
-            event.internalAPIRequest = true;
-            // invoke the lambda with the event prepaired, simulating an API request
-            new aws_sdk_1.Lambda().invoke({
-                FunctionName: params.lambda,
-                Qualifier: event.stage,
-                InvocationType: 'RequestResponse',
-                Payload: JSON.stringify(event)
-            }, (err, res) => {
-                // reject in case of internal error
-                if (err)
-                    reject(err);
-                else {
-                    // parse the payload and the body
-                    const payload = JSON.parse(res.Payload);
-                    const body = JSON.parse(payload.body);
-                    // if the response is successfull, return the body
-                    if (Number(payload.statusCode) === 200)
-                        resolve(body);
-                    // otherwise, reject the controlled error
-                    else
-                        reject(new Error(body.message));
-                }
-            });
-        });
+    async invokeInternalAPIRequest(params) {
+        if (params.lambda)
+            return await this.invokeInternalAPIRequestWithLambda(params);
+        if (params.eventBridge)
+            return await this.invokeInternalAPIRequestWithEventBridge(params);
+        throw new Error('Either "lambda" or "eventBus" parameters must be set.');
+    }
+    async invokeInternalAPIRequestWithLambda(params) {
+        const lambdaInvokeParams = {
+            FunctionName: params.lambda,
+            InvocationType: 'RequestResponse',
+            Payload: this.mapEventForInternalApiRequest(params),
+            Qualifier: params.stage || this.stage
+        };
+        const res = await new aws_sdk_1.Lambda().invoke(lambdaInvokeParams).promise();
+        const payload = JSON.parse(res.Payload);
+        const body = JSON.parse(payload.body);
+        if (Number(payload.statusCode) !== 200)
+            throw new Error(body.message);
+        return body;
+    }
+    async invokeInternalAPIRequestWithEventBridge(params) {
+        const request = {
+            EventBusName: params.eventBridge.bus,
+            Source: this.constructor.name,
+            DetailType: params.eventBridge.target,
+            Detail: this.mapEventForInternalApiRequest(params)
+        };
+        return await new aws_sdk_1.EventBridge().putEvents({ Entries: [request] }).promise();
+    }
+    mapEventForInternalApiRequest(params) {
+        const event = JSON.parse(JSON.stringify(this.event));
+        // change only the event attributes we need; e.g. the authorization is unchanged
+        if (!event.requestContext)
+            event.requestContext = {};
+        event.requestContext.stage = params.stage || this.stage;
+        if (!event.requestContext.http)
+            event.requestContext.http;
+        event.requestContext.http.method = event.httpMethod = params.httpMethod;
+        event.routeKey = event.resource = params.resource;
+        event.pathParameters = params.pathParams || {};
+        event.queryStringParameters = params.queryParams || {};
+        event.body = JSON.stringify(params.body || {});
+        event.rawPath = event.path = params.resource;
+        for (const p in event.pathParameters)
+            if (event.pathParameters[p])
+                event.rawPath = event.path = event.path.replace(`{${p}}`, event.pathParameters[p]);
+        // set a flag to make the invoked to recognise that is an internal request
+        event.internalAPIRequest = true;
+        return JSON.stringify(event);
     }
     /**
      * Whether the current request comes from an internal API request, i.e. it was invoked by another controller.
@@ -374,3 +415,13 @@ 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;

package/dist/src/s3.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetObjectTypes = exports.S3 = void 0;
 const aws_sdk_1 = require("aws-sdk");
 const idea_toolbox_1 = require("idea-toolbox");
-// declare libs as global vars to be reused in warm starts by the Lambda function
-let ideaWarmStart_s3 = null;
+const logger_1 = require("./logger");
+const logger = new logger_1.Logger();
 /**
  * A wrapper for AWS Simple Storage Service.
  */
@@ -17,9 +17,7 @@ class S3 {
         this.DEFAULT_DOWNLOAD_BUCKET = 'idea-downloads';
         this.DEFAULT_DOWNLOAD_BUCKET_SEC_TO_EXP = 180;
         this.DEFAULT_UPLOAD_BUCKET_SEC_TO_EXP = 300;
-        if (!ideaWarmStart_s3)
-            ideaWarmStart_s3 = new aws_sdk_1.S3({ apiVersion: '2006-03-01', signatureVersion: 'v4' });
-        this.s3 = ideaWarmStart_s3;
+        this.s3 = new aws_sdk_1.S3({ apiVersion: '2006-03-01', signatureVersion: 'v4' });
     }
     /**
      * Create a download link of a piece of data (through S3).
@@ -67,14 +65,14 @@ class S3 {
      * Make a copy of an object of the bucket.
      */
     async copyObject(options) {
-        (0, idea_toolbox_1.logger)('S3 COPY OBJECT', null, options.key);
+        logger.debug(`S3 copy object: ${options.key}`);
         await this.s3.copyObject({ CopySource: options.copySource, Bucket: options.bucket, Key: options.key }).promise();
     }
     /**
      * Get an object from a S3 bucket.
      */
     async getObject(options) {
-        (0, idea_toolbox_1.logger)('S3 GET OBJECT', null, options.type);
+        logger.debug(`S3 get object: ${options.type}`);
         const result = await this.s3.getObject({ Bucket: options.bucket, Key: options.key }).promise();
         switch (options.type) {
             case GetObjectTypes.JSON:
@@ -96,21 +94,21 @@ class S3 {
             params.ACL = options.acl;
         if (options.metadata)
             params.Metadata = options.metadata;
-        (0, idea_toolbox_1.logger)('S3 PUT OBJECT', null, options.key);
+        logger.debug(`S3 put object: ${options.key}`);
         return await this.s3.putObject(params).promise();
     }
     /**
      * Delete an object from an S3 bucket.
      */
     async deleteObject(options) {
-        (0, idea_toolbox_1.logger)('S3 DELETE OBJECT', null, options.key);
+        logger.debug(`S3 delete object: ${options.key}`);
         return await this.s3.deleteObject({ Bucket: options.bucket, Key: options.key }).promise();
     }
     /**
      * List the objects of an S3 bucket.
      */
     async listObjects(options) {
-        (0, idea_toolbox_1.logger)('S3 LIST OBJECTS', null, options.prefix);
+        logger.debug(`S3 list object: ${options.prefix}`);
         return await this.s3.listObjects({ Bucket: options.bucket, Prefix: options.prefix }).promise();
     }
     /**

package/dist/src/secretsManager.js

@@ -2,30 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SecretsManager = void 0;
 const aws_sdk_1 = require("aws-sdk");
-const idea_toolbox_1 = require("idea-toolbox");
-// declare libs as global vars to be reused in warm starts by the Lambda function
-let ideaWarmStart_secretsManager = null;
 /**
  * A wrapper for AWS Secrets manager.
  */
 class SecretsManager {
     constructor() {
-        if (!ideaWarmStart_secretsManager)
-            ideaWarmStart_secretsManager = new aws_sdk_1.SecretsManager();
-        this.sm = ideaWarmStart_secretsManager;
+        this.sm = new aws_sdk_1.SecretsManager();
     }
     /**
      * Get a secret string from the Secret Manager by its id.
      */
     async getStringById(secretId) {
-        try {
-            const result = await this.sm.getSecretValue({ SecretId: secretId }).promise();
-            return result.SecretString;
-        }
-        catch (err) {
-            (0, idea_toolbox_1.logger)('SECRET NOT FOUND', err, secretId);
-            throw new Error('Not found');
-        }
+        const result = await this.sm.getSecretValue({ SecretId: secretId }).promise();
+        return result.SecretString;
     }
 }
 exports.SecretsManager = SecretsManager;

package/dist/src/ses.js

@@ -3,10 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SES = void 0;
 const aws_sdk_1 = require("aws-sdk");
 const nodemailer_1 = require("nodemailer");
-const idea_toolbox_1 = require("idea-toolbox");
 const dynamoDB_1 = require("./dynamoDB");
-// declare libs as global vars to be reused in warm starts by the Lambda function
-let ideaWarmStart_ses = null;
+const logger_1 = require("./logger");
+const logger = new logger_1.Logger();
 /**
  * A wrapper for AWS Simple Email Service.
  */
@@ -24,10 +23,8 @@ class SES {
             Source: sesParams.sourceName ? `${sesParams.sourceName} <${sesParams.source}>` : sesParams.source,
             SourceArn: sesParams.sourceArn
         };
-        (0, idea_toolbox_1.logger)('SES SEND TEMPLATED EMAIL');
-        if (!ideaWarmStart_ses)
-            ideaWarmStart_ses = new aws_sdk_1.SES({ region: sesParams.region });
-        return await ideaWarmStart_ses.sendTemplatedEmail(request).promise();
+        logger.debug('SES send templated email');
+        return await new aws_sdk_1.SES({ region: sesParams.region }).sendTemplatedEmail(request).promise();
     }
     /**
      * Send an email through AWS Simple Email Service.
@@ -61,10 +58,8 @@ class SES {
             Source: sesParams.sourceName ? `${sesParams.sourceName} <${sesParams.source}>` : sesParams.source,
             SourceArn: sesParams.sourceArn
         };
-        (0, idea_toolbox_1.logger)('SES SEND EMAIL');
-        if (!ideaWarmStart_ses)
-            ideaWarmStart_ses = new aws_sdk_1.SES({ region: sesParams.region });
-        return await ideaWarmStart_ses.sendEmail(request).promise();
+        logger.debug('SES send email');
+        return await new aws_sdk_1.SES({ region: sesParams.region }).sendEmail(request).promise();
     }
     async sendEmailWithNodemailer(emailData, sesParams) {
         const mailOptions = {};
@@ -82,10 +77,8 @@ class SES {
         if (emailData.text)
             mailOptions.text = emailData.text;
         mailOptions.attachments = emailData.attachments;
-        (0, idea_toolbox_1.logger)('SES SEND EMAIL (NODEMAILER)');
-        if (!ideaWarmStart_ses)
-            ideaWarmStart_ses = new aws_sdk_1.SES({ region: sesParams.region });
-        return await (0, nodemailer_1.createTransport)({ SES: ideaWarmStart_ses }).sendMail(mailOptions);
+        logger.debug('SES send email (Nodemailer)');
+        return await (0, nodemailer_1.createTransport)({ SES: new aws_sdk_1.SES({ region: sesParams.region }) }).sendMail(mailOptions);
     }
     prepareEmailDestination(emailData) {
         return {

package/dist/src/sns.js

@@ -3,8 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SNS = void 0;
 const aws_sdk_1 = require("aws-sdk");
 const idea_toolbox_1 = require("idea-toolbox");
-// declare libs as global vars to be reused in warm starts by the Lambda function
-let ideaWarmStart_sns = null;
 /**
  * A wrapper for AWS Simple Notification Service.
  */
@@ -29,9 +27,7 @@ class SNS {
                 throw new Error('Unsupported platform');
         }
         (0, idea_toolbox_1.logger)('SNS ADD PLATFORM ENDPOINT');
-        if (!ideaWarmStart_sns)
-            ideaWarmStart_sns = new aws_sdk_1.SNS({ apiVersion: '2010-03-31', region: snsParams.region });
-        const result = await ideaWarmStart_sns
+        const result = await new aws_sdk_1.SNS({ apiVersion: '2010-03-31', region: snsParams.region })
             .createPlatformEndpoint({ PlatformApplicationArn: platformARN, Token: token })
             .promise();
         return result.EndpointArn;
@@ -60,9 +56,7 @@ class SNS {
                     throw new Error('Unsupported platform');
             }
         (0, idea_toolbox_1.logger)('SNS PUBLISH IN TOPIC');
-        if (!ideaWarmStart_sns)
-            ideaWarmStart_sns = new aws_sdk_1.SNS({ apiVersion: '2010-03-31', region: snsParams.region });
-        return await ideaWarmStart_sns
+        return await new aws_sdk_1.SNS({ apiVersion: '2010-03-31', region: snsParams.region })
             .publish({ MessageStructure: 'json', Message: JSON.stringify(structuredMessage), TargetArn: snsParams.endpoint })
             .promise();
     }

package/dist/src/streamController.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamController = void 0;
-const idea_toolbox_1 = require("idea-toolbox");
 const genericController_1 = require("./genericController");
+const logger_1 = require("./logger");
+const logger = new logger_1.Logger();
 /**
  * An abstract class to inherit to manage AWS DDB streams in an AWS Lambda function.
  */
@@ -10,7 +11,7 @@ class StreamController extends genericController_1.GenericController {
     constructor(event, callback, options = {}) {
         super(event, callback, options);
         this.records = event.Records || [];
-        (0, idea_toolbox_1.logger)(`START STREAM: ${this.records.length || 0} records`, null, null, true);
+        logger.info(`START STREAM: ${this.records.length || 0} records`);
     }
 }
 exports.StreamController = StreamController;

package/dist/src/translate.js

@@ -3,8 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Translate = void 0;
 const aws_sdk_1 = require("aws-sdk");
 const idea_toolbox_1 = require("idea-toolbox");
-// declare libs as global vars to be reused in warm starts by the Lambda function
-let ideaWarmStart_translate = null;
 /**
  * A wrapper for Amazon Translate.
  */
@@ -13,9 +11,7 @@ class Translate {
      * Initialize a new Translate helper object.
      */
     constructor() {
-        if (!ideaWarmStart_translate)
-            ideaWarmStart_translate = new aws_sdk_1.Translate({ apiVersion: '2017-07-01' });
-        this.translate = ideaWarmStart_translate;
+        this.translate = new aws_sdk_1.Translate({ apiVersion: '2017-07-01' });
         this.sourceLanguageCode = 'en';
         this.targetLanguageCode = 'en';
         this.terminologyNames = new Array();

package/index.ts

@@ -11,3 +11,5 @@ export * from './src/ses';
 export * from './src/sns';
 export * from './src/translate';
 export * from './src/attachments';
+
+export * from './src/logger';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "idea-aws",
-  "version": "3.9.2",
+  "version": "3.10.3",
   "description": "AWS wrappers to use in IDEA's back-ends",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -35,19 +35,20 @@
   },
   "homepage": "https://uatisdeproblem.github.io/IDEA-AWS",
   "dependencies": {
-    "idea-toolbox": "^6.5.4",
-    "nanoid": "^3.1.25",
-    "nodemailer": "^6.6.3",
+    "idea-toolbox": "^6.5.9",
+    "nanoid": "^3.2.0",
+    "nodemailer": "^6.7.2",
     "shortid": "^2.2.16",
+    "source-map-support": "^0.5.21",
     "uuid": "^8.3.2"
   },
   "devDependencies": {
     "@tsconfig/node14": "^1.0.0",
-    "@types/aws-lambda": "^8.10.72",
+    "@types/aws-lambda": "^8.10.91",
     "@types/node": "^14.14.26",
     "@types/nodemailer": "^6.4.4",
-    "@types/shortid": "0.0.29",
-    "@types/uuid": "^8.3.1",
+    "@types/shortid": "^0.0.29",
+    "@types/uuid": "^8.3.4",
     "@typescript-eslint/eslint-plugin": "^4.31.1",
     "@typescript-eslint/parser": "^4.31.1",
     "aws-sdk": "^2.991.0",