idea-aws 4.2.1 → 4.3.0

package/dist/src/dynamoDB.js

@@ -27,24 +27,16 @@ exports.DynamoDB = void 0;
 const DDB = __importStar(require("@aws-sdk/lib-dynamodb"));
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
 const DDBUtils = __importStar(require("@aws-sdk/util-dynamodb"));
-const uuid_1 = require("uuid");
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
 const nanoid_1 = require("nanoid");
 const NanoID = (0, nanoid_1.customAlphabet)('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz', 25);
-const shortid_1 = require("shortid");
-const logger_1 = require("./logger");
 /**
  * A wrapper for AWS DynamoDB.
  */
 class DynamoDB {
-    constructor(params) {
-        this.logger = new logger_1.Logger();
-        const options = Object.assign({}, params, { debug: true });
+    constructor() {
         this.dynamo = DDB.DynamoDBDocument.from(new client_dynamodb_1.DynamoDB(), {
             marshallOptions: { convertEmptyValues: true, removeUndefinedValues: true, convertClassInstanceToMap: true }
         });
-        this.logger.level = options.debug ? 'DEBUG' : 'INFO';
     }
     /**
      * Convert a JSON object from DynamoDB format to simple JSON.
@@ -54,19 +46,6 @@ class DynamoDB {
     unmarshall(data, options) {
         return DDBUtils.unmarshall(data, options);
     }
-    /**
-     * Returns an IUID: IDEA's Unique IDentifier, which is an id unique through an IDEA's AWS account and region.
-     * Note: no need of an auth check for external uses: the permissions depend from the context in which it's executed.
-     * @deprecated use IUNID instead (nano version)
-     * @param project project code
-     * @return the IUID
-     */
-    async IUID(project) {
-        const MAX_ATTEMPTS = 3;
-        if (!project)
-            throw new Error('Missing project');
-        return await this.identifiersGeneratorHelper(project, 'IUID', 0, MAX_ATTEMPTS);
-    }
     /**
      * Returns an IUNID: IDEA's Unique Nano IDentifier, which is an id unique through an IDEA's AWS account and region.
      * Note: no need of an auth check for external uses: the permissions depend from the context in which it's executed.
@@ -77,43 +56,16 @@ class DynamoDB {
         const MAX_ATTEMPTS = 3;
         if (!project)
             throw new Error('Missing project');
-        return await this.identifiersGeneratorHelper(project, 'IUNID', 0, MAX_ATTEMPTS);
-    }
-    /**
-     * Returns an ISID: IDEA's Short IDentifier, which is a short, unique id intended to be used in small namespaces.
-     * Note: no need of an auth check for external uses: the permissions depend from the context in which it's executed.
-     * @param project project code
-     * @return the ISID
-     */
-    async ISID(project) {
-        const MAX_ATTEMPTS = 3;
-        if (!project)
-            throw new Error('Missing project');
-        return await this.identifiersGeneratorHelper(project, 'ISID', 0, MAX_ATTEMPTS);
+        return await this.IUNIDHelper(project, 0, MAX_ATTEMPTS);
     }
-    async identifiersGeneratorHelper(project, type, attempt, maxAttempts) {
+    async IUNIDHelper(project, attempt, maxAttempts) {
         if (attempt > maxAttempts)
             throw new Error('Operation failed');
-        let id, result;
-        switch (type) {
-            case 'IUNID':
-                id = NanoID();
-                result = `${project}_${id}`;
-                break;
-            case 'IUID':
-                id = (0, uuid_1.v4)();
-                result = `${project}_${id}`;
-                break;
-            case 'ISID':
-                // avoid _ characters (to avoid concatenation problems with ids) -- it must be anyway 64 chars-long
-                (0, shortid_1.characters)('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-@');
-                id = (0, shortid_1.generate)();
-                result = id;
-                break;
-        }
+        const id = NanoID();
+        const result = `${project}_${id}`;
         try {
             await this.put({
-                TableName: 'idea_'.concat(type),
+                TableName: 'idea_IUNID',
                 Item: { project, id },
                 ConditionExpression: 'NOT (#p = :project AND #id = :id)',
                 ExpressionAttributeNames: { '#p': 'project', '#id': 'id' },
@@ -123,7 +75,7 @@ class DynamoDB {
         }
         catch (err) {
             // ID exists, try again
-            await this.identifiersGeneratorHelper(project, type, attempt + 1, maxAttempts);
+            await this.IUNIDHelper(project, attempt + 1, maxAttempts);
         }
     }
     /**
@@ -132,36 +84,35 @@ class DynamoDB {
      * @param key the key of the counter
      */
     async getAtomicCounterByKey(key) {
-        this.logger.debug(`Get atomic counter for ${key}`);
-        const result = await this.update({
+        console.debug(`Get atomic counter for ${key}`);
+        const { Attributes } = await this.update({
             TableName: 'idea_atomicCounters',
             Key: { key },
             UpdateExpression: 'ADD atomicCounter :increment',
             ExpressionAttributeValues: { ':increment': 1 },
             ReturnValues: 'UPDATED_NEW'
         });
-        if (!result?.Attributes?.atomicCounter)
+        if (!Attributes.atomicCounter)
             throw new Error('Operation failed');
-        else
-            return result.Attributes.atomicCounter;
+        return Attributes.atomicCounter;
     }
     /**
      * Get an item of a DynamoDB table.
      * @param params the params to apply to DynamoDB's function
      */
     async get(params) {
-        this.logger.debug(`Get ${params.TableName}`);
-        const result = await this.dynamo.get(params);
-        if (!result?.Item)
+        console.debug(`Get ${params.TableName}`);
+        const { Item } = await this.dynamo.get(params);
+        if (!Item)
             throw new Error('Not found');
-        return result.Item;
+        return Item;
     }
     /**
      * Put an item in a DynamoDB table.
      * @param params the params to apply to DynamoDB's function
      */
     async put(params) {
-        this.logger.debug(`Put ${params.TableName}`);
+        console.debug(`Put ${params.TableName}`);
         return await this.dynamo.put(params);
     }
     /**
@@ -169,7 +120,7 @@ class DynamoDB {
      * @param params the params to apply to DynamoDB's function
      */
     async update(params) {
-        this.logger.debug(`Update ${params.TableName}`);
+        console.debug(`Update ${params.TableName}`);
         return await this.dynamo.update(params);
     }
     /**
@@ -177,7 +128,7 @@ class DynamoDB {
      * @param params the params to apply to DynamoDB's function
      */
     async delete(params) {
-        this.logger.debug(`Delete ${params.TableName}`);
+        console.debug(`Delete ${params.TableName}`);
         return await this.dynamo.delete(params);
     }
     /**
@@ -188,7 +139,7 @@ class DynamoDB {
      */
     async batchGet(table, keys, ignoreErr) {
         if (!keys.length) {
-            this.logger.debug(`Batch get ${table}: no elements to get`);
+            console.debug(`Batch get ${table}: no elements to get`);
             return [];
         }
         return await this.batchGetHelper(table, keys, [], Boolean(ignoreErr));
@@ -199,7 +150,7 @@ class DynamoDB {
                 [table]: { Keys: keys.slice(currentChunk, currentChunk + chunkSize) }
             }
         };
-        this.logger.debug(`Batch get ${table}: ${currentChunk} of ${keys.length}`);
+        console.debug(`Batch get ${table}: ${currentChunk} of ${keys.length}`);
         let result;
         try {
             result = await this.dynamo.batchGet(batch);
@@ -226,7 +177,7 @@ class DynamoDB {
      */
     async batchPut(table, items) {
         if (!items.length)
-            return this.logger.debug(`Batch write (put) ${table}: no elements to write`);
+            return console.debug(`Batch write (put) ${table}: no elements to write`);
         await this.batchWriteHelper(table, items, true);
     }
     /**
@@ -238,11 +189,11 @@ class DynamoDB {
      */
     async batchDelete(table, keys) {
         if (!keys.length)
-            return this.logger.debug(`Batch write (delete) ${table}: no elements to write`);
+            return console.debug(`Batch write (delete) ${table}: no elements to write`);
         await this.batchWriteHelper(table, keys, false);
     }
     async batchWriteHelper(table, itemsOrKeys, isPut, currentChunk = 0, chunkSize = 25) {
-        this.logger.debug(`Batch write (${isPut ? 'put' : 'delete'}) ${table}: ${currentChunk} of ${itemsOrKeys.length}`);
+        console.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 } }));
@@ -267,7 +218,7 @@ class DynamoDB {
                 params.RequestItems = response.UnprocessedItems;
                 attempts++;
                 const waitSeconds = getRandomInt(attempts * 5);
-                this.logger.debug(`Batch write throttled: waiting ${waitSeconds} seconds to retry`);
+                console.debug(`Batch write throttled: waiting ${waitSeconds} seconds to retry`);
                 await wait(waitSeconds);
             }
             else {
@@ -280,9 +231,9 @@ class DynamoDB {
      * @param params the params to apply to DynamoDB's function
      */
     async query(params) {
-        this.logger.debug(`Query ${params.TableName}`);
+        console.debug(`Query ${params.TableName}`);
         const result = await this.queryScanHelper(params, [], true);
-        this.logger.debug(`Results query ${params.TableName}: ${result?.length || 0}`);
+        console.debug(`Results query ${params.TableName}: ${result.length ?? 0}`);
         return result;
     }
     /**
@@ -290,9 +241,9 @@ class DynamoDB {
      * @param params the params to apply to DynamoDB's function
      */
     async scan(params) {
-        this.logger.debug(`Scan ${params.TableName}`);
+        console.debug(`Scan ${params.TableName}`);
         const result = await this.queryScanHelper(params, [], false);
-        this.logger.debug(`Results scan ${params.TableName}: ${result?.length || 0}`);
+        console.debug(`Results scan ${params.TableName}: ${result.length ?? 0}`);
         return result;
     }
     async queryScanHelper(params, items, isQuery) {
@@ -314,9 +265,9 @@ class DynamoDB {
      * @param params the params to apply to DynamoDB's function
      */
     async queryClassic(params) {
-        this.logger.debug(`Query classic ${params.TableName}`);
+        console.debug(`Query classic ${params.TableName}`);
         const result = await this.dynamo.query(params);
-        this.logger.debug(`Results query classic ${params.TableName}: ${result?.Items?.length || 0}`);
+        console.debug(`Results query classic ${params.TableName}: ${result.Items.length ?? 0}`);
         return result;
     }
     /**
@@ -324,20 +275,20 @@ class DynamoDB {
      * @param params the params to apply to DynamoDB's function
      */
     async scanClassic(params) {
-        this.logger.debug(`Scan classic ${params.TableName}`);
+        console.debug(`Scan classic ${params.TableName}`);
         const result = await this.dynamo.scan(params);
-        this.logger.debug(`Results scan classic ${params.TableName}: ${result?.Items?.length || 0}`);
+        console.debug(`Results scan classic ${params.TableName}: ${result.Items.length ?? 0}`);
         return result;
     }
     /**
-     * Execute a series of max 10 write operations in a single transaction.
+     * Execute a series of write operations in a single transaction.
      * @param ops the operations to execute in the transaction
      */
     async transactWrites(ops) {
         if (!ops.length)
-            return this.logger.debug('Transaction writes: no elements to write');
-        this.logger.debug('Transaction writes');
-        await this.dynamo.transactWrite({ TransactItems: ops.slice(0, 10) });
+            return console.debug('Transaction writes: no elements to write');
+        console.debug('Transaction writes');
+        await this.dynamo.transactWrite({ TransactItems: ops });
     }
 }
 exports.DynamoDB = DynamoDB;

package/dist/src/genericController.d.ts

@@ -20,5 +20,5 @@ export declare abstract class GenericController {
     /**
      * Default callback for the Lambda.
      */
-    protected done(err: any, res?: any): void;
+    protected done(error: Error | any, res?: any): void;
 }

package/dist/src/genericController.js

@@ -20,12 +20,12 @@ class GenericController {
     /**
      * Default callback for the Lambda.
      */
-    done(err, res) {
-        if (err)
-            this.logger.info('END-FAILED', { error: err.message || err.errorMessage });
+    done(error, res) {
+        if (error)
+            this.logger.error('END-FAILED', error);
         else
             this.logger.info('END-SUCCESS');
-        this.callback(err, res);
+        this.callback(error, res);
     }
 }
 exports.GenericController = GenericController;

package/dist/src/logger.d.ts

@@ -1,19 +1,10 @@
 /**
- * Manage structured logging.
+ * Manage structured logging in the context of a Lambda function.
+ * Note: the log level is controlled by each Lambda function's configuration.
  */
 export declare class Logger {
-    level: string;
-    private originalLevel;
-    constructor(params?: {
-        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;
+    debug: (_: string, params?: any) => void;
+    info: (_: string, params?: any) => void;
+    warn: (_: string, err: Error | any, params?: any) => void;
+    error: (_: string, err: Error | any, params?: any) => void;
 }

package/dist/src/logger.js

@@ -2,53 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
 /**
- * Manage structured logging.
+ * Manage structured logging in the context of a Lambda function.
+ * Note: the log level is controlled by each Lambda function's configuration.
  */
 class Logger {
-    constructor(params) {
-        const options = Object.assign({}, params, { level: process.env.LOG_LEVEL });
-        this.level = (options.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;
+    constructor() {
+        this.debug = (_, params = {}) => console.debug({ _, ...params });
+        this.info = (_, params = {}) => console.info({ _, ...params });
+        this.warn = (_, err, params = {}) => console.warn({ _, ...params, errorType: err.name, errorMessage: err.message, stackTrace: err.stack });
+        this.error = (_, err, params = {}) => console.error({ _, ...params, errorType: err.name, errorMessage: err.message, stackTrace: err.stack });
     }
 }
 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/metrics.d.ts

@@ -4,7 +4,7 @@ import { Metrics, MetricUnits } from '@aws-lambda-powertools/metrics';
  */
 export declare class CloudWatchMetrics {
     private metrics;
-    constructor(params?: {
+    constructor(options?: {
         project?: string;
     });
     /**

package/dist/src/metrics.js

@@ -6,9 +6,9 @@ const metrics_1 = require("@aws-lambda-powertools/metrics");
  * A wrapper for simple uses of CloudWatch Metrics.
  */
 class CloudWatchMetrics {
-    constructor(params) {
-        const options = Object.assign({}, params, { project: 'unknownProject' });
-        this.metrics = new metrics_1.Metrics({ namespace: options.project });
+    constructor(options = {}) {
+        const namespace = options.project ?? 'unknownProject';
+        this.metrics = new metrics_1.Metrics({ namespace });
     }
     /**
      * Get the raw Metrics object. To use for custom purposes.

package/dist/src/resourceController.d.ts

@@ -37,13 +37,14 @@ export declare abstract class ResourceController extends GenericController {
     constructor(event: APIGatewayProxyEventV2 | APIGatewayProxyEvent, callback: Callback, options?: ResourceControllerOptions);
     private initFromEventV2;
     private initFromEventV1;
+    protected getEventInfo(): Record<string, any>;
     /**
      * Force the parsing of a query parameter as an array of strings.
      */
     protected getQueryParamAsArray(paramName: string): string[];
     handleRequest: () => Promise<void>;
-    private controlHandlerError;
-    protected done(err: any, res?: any, statusCode?: number): void;
+    private remapHandlerError;
+    protected done(error?: Error | any, result?: any, statusCode?: number): void;
     /**
      * To @override
      */

package/dist/src/resourceController.js

@@ -108,11 +108,11 @@ class ResourceController extends genericController_1.GenericController {
                     this.done(null, response);
                 }
                 catch (err) {
-                    this.done(this.controlHandlerError(err, 'HANDLER-ERROR', 'Operation failed'));
+                    this.done(this.remapHandlerError(err, 'HANDLER-ERROR', 'Operation failed'));
                 }
             }
             catch (err) {
-                this.done(this.controlHandlerError(err, 'AUTH-CHECK-ERROR', 'Forbidden'));
+                this.done(this.remapHandlerError(err, 'AUTH-CHECK-ERROR', 'Forbidden'));
             }
         };
         this.event = event;
@@ -138,20 +138,11 @@ class ResourceController extends genericController_1.GenericController {
             }
             if (options.useMetrics)
                 this.prepareMetrics();
-            // print the initial log
-            const info = {
-                principalId: this.principalId,
-                queryParams: this.queryParams,
-                body: this.body,
-                version: this.clientVersion,
-                platform: this.clientPlatform,
-                bundle: this.clientBundle
-            };
-            this.logger.info(`START: ${this.httpMethod} ${this.path}`, info);
+            this.logger.info(`START: ${this.httpMethod} ${this.path}`, this.getEventInfo());
         }
         catch (err) {
             this.initError = true;
-            this.done(this.controlHandlerError(err, 'INIT-ERROR', 'Malformed request'));
+            this.done(this.remapHandlerError(err, 'INIT-ERROR', 'Malformed request'));
         }
     }
     initFromEventV2(event, options) {
@@ -199,6 +190,16 @@ class ResourceController extends genericController_1.GenericController {
             throw new RCError('Malformed body');
         }
     }
+    getEventInfo() {
+        return {
+            principalId: this.principalId,
+            queryParams: this.queryParams,
+            body: this.body,
+            version: this.clientVersion,
+            platform: this.clientPlatform,
+            bundle: this.clientBundle
+        };
+    }
     /**
      * Force the parsing of a query parameter as an array of strings.
      */
@@ -210,24 +211,30 @@ class ResourceController extends genericController_1.GenericController {
         else
             return String(this.queryParams[paramName]).split(',');
     }
-    controlHandlerError(err = {}, context, replaceWithErrorMessage) {
+    remapHandlerError(err, context, replaceWithMessage) {
         if (err instanceof RCError)
-            return new Error(err.message);
-        this.logger.error(context, err);
-        return new Error(replaceWithErrorMessage);
-    }
-    done(err, res, statusCode = this.returnStatusCode || (err ? 400 : 200)) {
-        if (err)
-            this.logger.info('END-FAILED', { statusCode, error: err.message || err.errorMessage });
+            return err;
+        const error = err;
+        error.context = context;
+        error.internalMessage = error.message;
+        error.message = replaceWithMessage;
+        return error;
+    }
+    done(error, result, statusCode = this.returnStatusCode ?? (error ? 400 : 200)) {
+        const logContent = { statusCode, event: this.getEventInfo() };
+        if (result)
+            logContent.result = Array.isArray(result) ? `Array (${result.length})` : result;
+        if (error)
+            this.logger.error(`END-FAILED: ${this.httpMethod} ${this.path}`, error, logContent);
         else
-            this.logger.info('END-SUCCESS', { statusCode });
+            this.logger.info(`END-SUCCESS: ${this.httpMethod} ${this.path}`, logContent);
         if (this.logRequestsWithKey)
-            this.storeLog(!err);
+            this.storeLog(!error);
         if (this.metrics)
-            this.publishMetrics(statusCode, err);
+            this.publishMetrics(statusCode, error);
         this.callback(null, {
             statusCode: String(statusCode),
-            body: err ? JSON.stringify({ message: err.message }) : JSON.stringify(res || {}),
+            body: error ? JSON.stringify({ message: error.message }) : JSON.stringify(result ?? {}),
             headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' }
         });
     }
@@ -380,7 +387,7 @@ class ResourceController extends genericController_1.GenericController {
         this.metrics.addMetric('statusCode', statusCode);
         if (error) {
             this.metrics.addMetric('failed');
-            this.metrics.addMetadata('errorMessage', error.name);
+            this.metrics.addMetadata('error', error.name);
         }
         else
             this.metrics.addMetric('success');
@@ -406,7 +413,7 @@ class ResourceController extends genericController_1.GenericController {
             FunctionName: params.lambda,
             InvocationType: 'RequestResponse',
             Payload: this.mapEventForInternalApiRequest(params),
-            Qualifier: params.stage || this.stage
+            Qualifier: params.stage ?? this.stage
         });
         const client = new Lambda.LambdaClient();
         const { Payload } = await client.send(command);
@@ -432,14 +439,14 @@ class ResourceController extends genericController_1.GenericController {
         // 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;
+        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.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])
@@ -467,7 +474,7 @@ class ResourceController extends genericController_1.GenericController {
             return;
         // set the languages
         this.currentLang = lang;
-        this.defaultLang = defLang || lang;
+        this.defaultLang = defLang ?? lang;
         this.translations = {};
         // load the translations in the chosen language
         this.translations[this.currentLang] = JSON.parse(this.loadSharedResource(`i18n/${this.currentLang}.json`).toString());
@@ -539,3 +546,8 @@ class RCError extends Error {
     }
 }
 exports.RCError = RCError;
+/**
+ * An unhandled error thrown inside the RC (i.e. `!(error instanceof RCError)`) .
+ */
+class RCUnhandledError extends Error {
+}