idea-aws 4.4.3 → 4.4.4

package/dist/src/dynamoDB.js

@@ -1,296 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-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 nanoid_1 = require("nanoid");
-const NanoID = (0, nanoid_1.customAlphabet)('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz', 25);
-const lambdaLogger_1 = require("./lambdaLogger");
-/**
- * A wrapper for AWS DynamoDB.
- */
-class DynamoDB {
-    constructor() {
-        this.logger = new lambdaLogger_1.LambdaLogger();
-        this.dynamo = DDB.DynamoDBDocument.from(new client_dynamodb_1.DynamoDB(), {
-            marshallOptions: { convertEmptyValues: true, removeUndefinedValues: true, convertClassInstanceToMap: true }
-        });
-    }
-    /**
-     * Convert a JSON object from DynamoDB format to simple JSON.
-     * @data the data in DynamoDB's original format to convert in plain objects
-     * @options the options to use to convert the data
-     */
-    unmarshall(data, options) {
-        return DDBUtils.unmarshall(data, options);
-    }
-    /**
-     * 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.
-     * @param project project code
-     * @return the IUNID
-     */
-    async IUNID(project) {
-        const MAX_ATTEMPTS = 3;
-        if (!project)
-            throw new Error('Missing project');
-        return await this.IUNIDHelper(project, 0, MAX_ATTEMPTS);
-    }
-    async IUNIDHelper(project, attempt, maxAttempts) {
-        if (attempt > maxAttempts)
-            throw new Error('Operation failed');
-        const id = NanoID();
-        const result = `${project}_${id}`;
-        try {
-            await this.put({
-                TableName: 'idea_IUNID',
-                Item: { project, id },
-                ConditionExpression: 'NOT (#p = :project AND #id = :id)',
-                ExpressionAttributeNames: { '#p': 'project', '#id': 'id' },
-                ExpressionAttributeValues: { ':project': project, ':id': id }
-            });
-            return result;
-        }
-        catch (err) {
-            // ID exists, try again
-            await this.IUNIDHelper(project, attempt + 1, maxAttempts);
-        }
-    }
-    /**
-     * Manage atomic counters (atomic autoincrement values) in IDEA's projects.
-     * They key of an atomic counter should be composed as the following: `DynamoDBTableName_uniqueKey`.
-     * @param key the key of the counter
-     */
-    async getAtomicCounterByKey(key) {
-        this.logger.trace(`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 (!Attributes.atomicCounter)
-            throw new Error('Operation failed');
-        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.trace(`Get ${params.TableName}`);
-        const { Item } = await this.dynamo.get(params);
-        if (!Item)
-            throw new Error('Not found');
-        return Item;
-    }
-    /**
-     * Put an item in a DynamoDB table.
-     * @param params the params to apply to DynamoDB's function
-     */
-    async put(params) {
-        this.logger.trace(`Put ${params.TableName}`);
-        return await this.dynamo.put(params);
-    }
-    /**
-     * Update an item of a DynamoDB table.
-     * @param params the params to apply to DynamoDB's function
-     */
-    async update(params) {
-        this.logger.trace(`Update ${params.TableName}`);
-        return await this.dynamo.update(params);
-    }
-    /**
-     * Delete an item of a DynamoDB table.
-     * @param params the params to apply to DynamoDB's function
-     */
-    async delete(params) {
-        this.logger.trace(`Delete ${params.TableName}`);
-        return await this.dynamo.delete(params);
-    }
-    /**
-     * Get group of items based on their keys from DynamoDB table, avoiding the limits of DynamoDB's BatchGetItem.
-     * @param table the target DynamoDB table
-     * @param keys the keys of the objects to retrieve
-     * @param ignoreErr if set, ignore the errors and continue the bulk op.
-     */
-    async batchGet(table, keys, ignoreErr) {
-        if (!keys.length) {
-            this.logger.trace(`Batch get ${table}: no elements to get`);
-            return [];
-        }
-        return await this.batchGetHelper(table, keys, [], Boolean(ignoreErr));
-    }
-    async batchGetHelper(table, keys, resultElements, ignoreErr, currentChunk = 0, chunkSize = 100) {
-        const batch = {
-            RequestItems: {
-                [table]: { Keys: keys.slice(currentChunk, currentChunk + chunkSize) }
-            }
-        };
-        this.logger.trace(`Batch get ${table}: ${currentChunk} of ${keys.length}`);
-        let result;
-        try {
-            result = await this.dynamo.batchGet(batch);
-        }
-        catch (err) {
-            if (!ignoreErr)
-                throw err;
-        }
-        if (result)
-            resultElements = resultElements.concat(result.Responses[table]);
-        // if there are still chunks to manage, go on recursively
-        if (currentChunk + chunkSize < keys.length)
-            return await this.batchGetHelper(table, keys, resultElements, ignoreErr, currentChunk + chunkSize, chunkSize);
-        // no more chunks to manage: we're done
-        else
-            return resultElements;
-    }
-    /**
-     * Put an array of items in a DynamoDB table, avoiding the limits of DynamoDB's BatchWriteItem.
-     * In case of errors, it will retry with a random back-off mechanism until the timeout.
-     * Therefore, in case of timeout, there may be some elements written and some not.
-     * @param table the target DynamoDB table
-     * @param items the objects to insert
-     */
-    async batchPut(table, items) {
-        if (!items.length)
-            return this.logger.trace(`Batch write (put) ${table}: no elements to write`);
-        await this.batchWriteHelper(table, items, true);
-    }
-    /**
-     * Delete an array of items from a DynamoDB table, avoiding the limits of DynamoDB's BatchWriteItem.
-     * In case of errors, it will retry with a random back-off mechanism until the timeout.
-     * Therefore, in case of timeout, there may be some elements deleted and some not.
-     * @param table the target DynamoDB table
-     * @param keys the keys to delete
-     */
-    async batchDelete(table, keys) {
-        if (!keys.length)
-            return this.logger.trace(`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.trace(`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 } }));
-        // isDelete
-        else
-            requests = itemsOrKeys.slice(currentChunk, currentChunk + chunkSize).map(k => ({ DeleteRequest: { Key: k } }));
-        const batch = { RequestItems: { [table]: requests } };
-        await this.batchWriteChunkWithRetries(table, batch);
-        // if there are still chunks to manage, go on recursively
-        if (currentChunk + chunkSize < itemsOrKeys.length)
-            await this.batchWriteHelper(table, itemsOrKeys, isPut, currentChunk + chunkSize, chunkSize);
-    }
-    async batchWriteChunkWithRetries(table, params) {
-        const getRandomInt = (max) => Math.floor(Math.random() * max);
-        const wait = (seconds) => new Promise(x => setTimeout(() => x(), seconds * 1000));
-        let attempts = 0;
-        do {
-            const response = await this.dynamo.batchWrite(params);
-            if (response.UnprocessedItems &&
-                response.UnprocessedItems[table] &&
-                response.UnprocessedItems[table].length > 0) {
-                params.RequestItems = response.UnprocessedItems;
-                attempts++;
-                const waitSeconds = getRandomInt(attempts * 5);
-                this.logger.trace(`Batch write throttled: waiting ${waitSeconds} seconds to retry`);
-                await wait(waitSeconds);
-            }
-            else {
-                params.RequestItems = null;
-            }
-        } while (params.RequestItems);
-    }
-    /**
-     * Query a DynamoDB table, avoiding the limits of DynamoDB's Query.
-     * @param params the params to apply to DynamoDB's function
-     */
-    async query(params) {
-        this.logger.trace(`Query ${params.TableName}`);
-        const result = await this.queryScanHelper(params, [], true);
-        this.logger.trace(`Results query ${params.TableName}: ${result.length ?? 0}`);
-        return result;
-    }
-    /**
-     * Scan a DynamoDB table, avoiding the limits of DynamoDB's Query.
-     * @param params the params to apply to DynamoDB's function
-     */
-    async scan(params) {
-        this.logger.trace(`Scan ${params.TableName}`);
-        const result = await this.queryScanHelper(params, [], false);
-        this.logger.trace(`Results scan ${params.TableName}: ${result.length ?? 0}`);
-        return result;
-    }
-    async queryScanHelper(params, items, isQuery) {
-        let result;
-        if (isQuery)
-            result = await this.dynamo.query(params);
-        else
-            result = await this.dynamo.scan(params);
-        items = items.concat(result.Items);
-        if (result.LastEvaluatedKey) {
-            params.ExclusiveStartKey = result.LastEvaluatedKey;
-            return await this.queryScanHelper(params, items, isQuery);
-        }
-        else
-            return items;
-    }
-    /**
-     * Query a DynamoDB table in the traditional way (no pagination or data mapping).
-     * @param params the params to apply to DynamoDB's function
-     */
-    async queryClassic(params) {
-        this.logger.trace(`Query classic ${params.TableName}`);
-        const result = await this.dynamo.query(params);
-        this.logger.trace(`Results query classic ${params.TableName}: ${result.Items.length ?? 0}`);
-        return result;
-    }
-    /**
-     * Scan a DynamoDB table in the traditional way (no pagination or data mapping).
-     * @param params the params to apply to DynamoDB's function
-     */
-    async scanClassic(params) {
-        this.logger.trace(`Scan classic ${params.TableName}`);
-        const result = await this.dynamo.scan(params);
-        this.logger.trace(`Results scan classic ${params.TableName}: ${result.Items.length ?? 0}`);
-        return result;
-    }
-    /**
-     * 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.trace('Transaction writes: no elements to write');
-        this.logger.trace('Transaction writes');
-        await this.dynamo.transactWrite({ TransactItems: ops });
-    }
-}
-exports.DynamoDB = DynamoDB;

package/dist/src/genericController.d.ts

@@ -1,60 +0,0 @@
-import 'source-map-support/register';
-import { LambdaLogger } from './lambdaLogger';
-/**
- * An abstract class to inherit to manage some resources with an AWS Lambda function.
- */
-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);
-    /**
-     * The main function (to override), that handles the request and must terminate invoking the method `done`.
-     */
-    handleRequest(): Promise<void>;
-    /**
-     * Default callback for the Lambda.
-     */
-    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.
-     */
-    getLambdaLogLevel(): 'TRACE' | 'DEBUG' | 'INFO' | 'WARN' | 'ERROR' | 'FATAL';
-    /**
-     * Set the log level for the current Lambda function's `logger`.
-     */
-    setLambdaLogLevel(logLevel: 'TRACE' | 'DEBUG' | 'INFO' | 'WARN' | 'ERROR' | 'FATAL'): void;
-    /**
-     * Raise the log level of the current Lambda function's `logger` to "FATAL", hence avoiding printing any log.
-     */
-    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,89 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnhandledError = exports.HandledError = exports.GenericController = void 0;
-require("source-map-support/register");
-const lambdaLogger_1 = require("./lambdaLogger");
-/**
- * An abstract class to inherit to manage some resources with an AWS Lambda function.
- */
-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) {
-        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();
-    }
-    /**
-     * Default callback for the Lambda.
-     */
-    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.
-     */
-    getLambdaLogLevel() {
-        return process.env.AWS_LAMBDA_LOG_LEVEL;
-    }
-    /**
-     * Set the log level for the current Lambda function's `logger`.
-     */
-    setLambdaLogLevel(logLevel) {
-        process.env.AWS_LAMBDA_LOG_LEVEL = logLevel;
-    }
-    /**
-     * Raise the log level of the current Lambda function's `logger` to "FATAL", hence avoiding printing any log.
-     */
-    silentLambdaLogs() {
-        process.env.AWS_LAMBDA_LOG_LEVEL = 'FATAL';
-    }
-}
-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/lambdaLogger.d.ts

@@ -1,13 +0,0 @@
-/**
- * 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 LambdaLogger {
-    shouldLog: (logLevel: 'TRACE' | 'DEBUG' | 'INFO' | 'WARN' | 'ERROR' | 'FATAL') => boolean;
-    trace: (summary: string, content?: object) => void;
-    debug: (summary: string, content?: object) => void;
-    info: (summary: string, content?: object) => void;
-    warn: (summary: string, error: Error | any, content?: object) => void;
-    error: (summary: string, error: Error | any, content?: object) => void;
-}
-export declare const LOG_LEVELS_PRIORITY: Record<string, number>;

package/dist/src/lambdaLogger.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LOG_LEVELS_PRIORITY = exports.LambdaLogger = void 0;
-/**
- * Manage structured logging in the context of a Lambda function.
- * Note: the log level is controlled by each Lambda function's configuration.
- */
-class LambdaLogger {
-    constructor() {
-        // note: this is needed as long as the Lambda functions don't become reactive to changes to `AWS_LAMBDA_LOG_LEVEL`
-        this.shouldLog = (logLevel) => exports.LOG_LEVELS_PRIORITY[logLevel] >= exports.LOG_LEVELS_PRIORITY[process.env.AWS_LAMBDA_LOG_LEVEL];
-        this.trace = (summary, content = {}) => {
-            if (this.shouldLog('TRACE'))
-                console.trace({ summary, ...content });
-        };
-        this.debug = (summary, content = {}) => {
-            if (this.shouldLog('DEBUG'))
-                console.debug({ summary, ...content });
-        };
-        this.info = (summary, content = {}) => {
-            if (this.shouldLog('INFO'))
-                console.info({ summary, ...content });
-        };
-        this.warn = (summary, error, content = {}) => {
-            if (this.shouldLog('WARN'))
-                console.warn({ summary, ...content, error });
-        };
-        this.error = (summary, error, content = {}) => {
-            if (this.shouldLog('ERROR'))
-                console.error({ summary, ...content, error });
-        };
-    }
-}
-exports.LambdaLogger = LambdaLogger;
-// levels here are identical to bunyan practices (https://github.com/trentm/node-bunyan#levels)
-exports.LOG_LEVELS_PRIORITY = {
-    TRACE: 10,
-    DEBUG: 20,
-    INFO: 30,
-    WARN: 40,
-    ERROR: 50,
-    FATAL: 60
-};

package/dist/src/metrics.d.ts

@@ -1,31 +0,0 @@
-import { Metrics, MetricUnits } from '@aws-lambda-powertools/metrics';
-/**
- * A wrapper for simple uses of CloudWatch Metrics.
- */
-export declare class CloudWatchMetrics {
-    private metrics;
-    constructor(options?: {
-        project?: string;
-    });
-    /**
-     * Get the raw Metrics object. To use for custom purposes.
-     */
-    __raw(): Metrics;
-    /**
-     * Add an entry for the metrics.
-     */
-    addMetric(metricName: string, value?: number, unit?: MetricUnits): void;
-    /**
-     * Add a metadata useful when you want to search highly contextual information along with your metrics in your logs.
-     */
-    addMetadata(key: string, value: string): void;
-    /**
-     * Add an additional metrics dimension.
-     */
-    addDimension(name: string, value: string, defaultValue?: string): void;
-    /**
-     * Synchronous function to actually publish your metrics.
-     * It will create a new EMF blob and log it to be then ingested by Cloudwatch logs and processed for metrics creation.
-     */
-    publishStoredMetrics(): void;
-}

package/dist/src/metrics.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CloudWatchMetrics = void 0;
-const metrics_1 = require("@aws-lambda-powertools/metrics");
-/**
- * A wrapper for simple uses of CloudWatch Metrics.
- */
-class CloudWatchMetrics {
-    constructor(options = {}) {
-        const namespace = options.project ?? 'unknownProject';
-        this.metrics = new metrics_1.Metrics({ namespace });
-    }
-    /**
-     * Get the raw Metrics object. To use for custom purposes.
-     */
-    __raw() {
-        return this.metrics;
-    }
-    /**
-     * Add an entry for the metrics.
-     */
-    addMetric(metricName, value = 1, unit = metrics_1.MetricUnits.Count) {
-        this.metrics.addMetric(metricName, unit, value);
-    }
-    /**
-     * Add a metadata useful when you want to search highly contextual information along with your metrics in your logs.
-     */
-    addMetadata(key, value) {
-        this.metrics.addMetadata(key, value);
-    }
-    /**
-     * Add an additional metrics dimension.
-     */
-    addDimension(name, value, defaultValue = '-') {
-        this.metrics.addDimension(name, value ?? defaultValue);
-    }
-    /**
-     * Synchronous function to actually publish your metrics.
-     * It will create a new EMF blob and log it to be then ingested by Cloudwatch logs and processed for metrics creation.
-     */
-    publishStoredMetrics() {
-        this.metrics.publishStoredMetrics();
-    }
-}
-exports.CloudWatchMetrics = CloudWatchMetrics;