idea-aws 4.3.5 → 4.4.1

package/dist/src/comprehend.d.ts

@@ -1,34 +0,0 @@
-import * as AmazonComprehend from '@aws-sdk/client-comprehend';
-import { Sentiment } from 'idea-toolbox';
-/**
- * A wrapper for Amazon Comprehend.
- */
-export declare class Comprehend {
-    protected comprehend: AmazonComprehend.ComprehendClient;
-    constructor(options?: {
-        region?: string;
-    });
-    /**
-     * Inspects text and returns an inference of the prevailing sentiment (POSITIVE, NEUTRAL, MIXED, or NEGATIVE).
-     */
-    detectSentiment(params: DetectSentimentParameters): Promise<Sentiment>;
-    /**
-     * Determines the dominant language of the input text.
-     */
-    detectDominantLanguage(params: {
-        text: string;
-    }): Promise<string>;
-}
-export interface DetectSentimentParameters {
-    /**
-     * The language of the input contents. You can specify any of the primary languages supported by Amazon Comprehend.
-     * All contents must be in the same language. Required.
-     * Valid Values: en | es | fr | de | it | pt | ar | hi | ja | ko | zh | zh-TW
-     */
-    language: string;
-    /**
-     * The text to analyze. Required.
-     * A UTF-8 text string. Each string must contain fewer that 5,000 bytes of UTF-8 encoded characters.
-     */
-    text: string;
-}

package/dist/src/comprehend.js

@@ -1,58 +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.Comprehend = void 0;
-const AmazonComprehend = __importStar(require("@aws-sdk/client-comprehend"));
-/**
- * A wrapper for Amazon Comprehend.
- */
-class Comprehend {
-    constructor(options = {}) {
-        this.comprehend = new AmazonComprehend.ComprehendClient({ region: options.region });
-    }
-    /**
-     * Inspects text and returns an inference of the prevailing sentiment (POSITIVE, NEUTRAL, MIXED, or NEGATIVE).
-     */
-    async detectSentiment(params) {
-        if (!params.language || !params.text)
-            throw new Error('Missing some parameters');
-        const command = new AmazonComprehend.DetectSentimentCommand({ LanguageCode: params.language, Text: params.text });
-        const { Sentiment } = await this.comprehend.send(command);
-        return Sentiment;
-    }
-    /**
-     * Determines the dominant language of the input text.
-     */
-    async detectDominantLanguage(params) {
-        if (!params.text)
-            throw new Error('Missing text');
-        const command = new AmazonComprehend.DetectDominantLanguageCommand({ Text: params.text });
-        const { Languages } = await this.comprehend.send(command);
-        if (!Languages.length)
-            throw new Error('Not found');
-        return Languages[0].LanguageCode;
-    }
-}
-exports.Comprehend = Comprehend;

package/dist/src/dynamoDB.d.ts

@@ -1,108 +0,0 @@
-import * as DDB from '@aws-sdk/lib-dynamodb';
-import * as DDBUtils from '@aws-sdk/util-dynamodb';
-import { LambdaLogger } from './lambdaLogger';
-/**
- * A wrapper for AWS DynamoDB.
- */
-export declare class DynamoDB {
-    protected dynamo: DDB.DynamoDBDocument;
-    protected logger: LambdaLogger;
-    constructor();
-    /**
-     * 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: Record<string, any>, options?: DDBUtils.unmarshallOptions): Record<string, any>;
-    /**
-     * 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
-     */
-    IUNID(project: string): Promise<string>;
-    protected IUNIDHelper(project: string, attempt: number, maxAttempts: number): Promise<string>;
-    /**
-     * 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
-     */
-    getAtomicCounterByKey(key: string): Promise<number>;
-    /**
-     * Get an item of a DynamoDB table.
-     * @param params the params to apply to DynamoDB's function
-     */
-    get(params: DDB.GetCommandInput): Promise<any>;
-    /**
-     * Put an item in a DynamoDB table.
-     * @param params the params to apply to DynamoDB's function
-     */
-    put(params: DDB.PutCommandInput): Promise<DDB.PutCommandOutput>;
-    /**
-     * Update an item of a DynamoDB table.
-     * @param params the params to apply to DynamoDB's function
-     */
-    update(params: DDB.UpdateCommandInput): Promise<DDB.UpdateCommandOutput>;
-    /**
-     * Delete an item of a DynamoDB table.
-     * @param params the params to apply to DynamoDB's function
-     */
-    delete(params: DDB.DeleteCommandInput): Promise<DDB.DeleteCommandOutput>;
-    /**
-     * 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.
-     */
-    batchGet(table: string, keys: Record<string, any>[], ignoreErr?: boolean): Promise<any[]>;
-    protected batchGetHelper(table: string, keys: Record<string, any>[], resultElements: Record<string, any>[], ignoreErr: boolean, currentChunk?: number, chunkSize?: number): Promise<Record<string, any>[]>;
-    /**
-     * 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
-     */
-    batchPut(table: string, items: Record<string, any>[]): Promise<void>;
-    /**
-     * 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
-     */
-    batchDelete(table: string, keys: Record<string, any>[]): Promise<void>;
-    protected batchWriteHelper(table: string, itemsOrKeys: Record<string, any>[], isPut: boolean, currentChunk?: number, chunkSize?: number): Promise<void>;
-    protected batchWriteChunkWithRetries(table: string, params: DDB.BatchWriteCommandInput): Promise<void>;
-    /**
-     * Query a DynamoDB table, avoiding the limits of DynamoDB's Query.
-     * @param params the params to apply to DynamoDB's function
-     */
-    query(params: DDB.QueryCommandInput): Promise<any[]>;
-    /**
-     * Scan a DynamoDB table, avoiding the limits of DynamoDB's Query.
-     * @param params the params to apply to DynamoDB's function
-     */
-    scan(params: DDB.ScanCommandInput): Promise<any[]>;
-    protected queryScanHelper(params: DDB.QueryCommandInput | DDB.ScanCommandInput, items: Record<string, any>[], isQuery: boolean): Promise<Record<string, any>[]>;
-    /**
-     * Query a DynamoDB table in the traditional way (no pagination or data mapping).
-     * @param params the params to apply to DynamoDB's function
-     */
-    queryClassic(params: DDB.QueryCommandInput): Promise<DDB.QueryCommandOutput>;
-    /**
-     * Scan a DynamoDB table in the traditional way (no pagination or data mapping).
-     * @param params the params to apply to DynamoDB's function
-     */
-    scanClassic(params: DDB.ScanCommandInput): Promise<DDB.ScanCommandOutput>;
-    /**
-     * Execute a series of write operations in a single transaction.
-     * @param ops the operations to execute in the transaction
-     */
-    transactWrites(ops: {
-        ConditionCheck?: any;
-        Put?: any;
-        Delete?: any;
-        Update?: any;
-    }[]): Promise<void>;
-}

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>;