@allthings/cloud-toolkit 5.2.0-beta.1 → 5.2.0-beta.2

package/dist/dynamodb.cjs.js

@@ -0,0 +1,195 @@
+'use strict';
+
+var clientDynamodb = require('@aws-sdk/client-dynamodb');
+var libDynamodb = require('@aws-sdk/lib-dynamodb');
+var Bottleneck = require('bottleneck');
+
+const DEFAULT_AWS_CONFIGURATION = {
+    region: 'eu-central-2',
+};
+
+const splitEvery = (every, list) => Array.from({ length: Math.ceil(list.length / every) }).map((_, count) => list.slice(count * every, count * every + every));
+const until = async (predicate, transformer, initialValue, iterationCount = 0) => {
+    const transformed = await transformer(initialValue, iterationCount);
+    return (await predicate(transformed, iterationCount))
+        ? transformed
+        : until(predicate, transformer, transformed, iterationCount + 1);
+};
+
+const DEFAULT_BATCH_ITEMS_MAX_RETRIES = 50;
+let queue;
+const makeKey = (key) => {
+    if (typeof key === 'string') {
+        return { id: key };
+    }
+    return key;
+};
+const deleteItem = async (config, documentClient, table, key, options = {}) => {
+    try {
+        const { ReturnValues = 'NONE' } = options;
+        const command = new libDynamodb.DeleteCommand({
+            Key: makeKey(key),
+            ReturnValues,
+            TableName: config.tableNamePrefix + table,
+        });
+        const result = await queue.schedule(() => documentClient.send(command));
+        return result.Attributes;
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        return undefined;
+    }
+};
+const getItem = async (config, documentClient, table, key, options = {}) => {
+    try {
+        const { ConsistentRead = false } = options;
+        const command = new libDynamodb.GetCommand({
+            ConsistentRead,
+            Key: makeKey(key),
+            TableName: config.tableNamePrefix + table,
+        });
+        const result = await queue.schedule(() => documentClient.send(command));
+        return result.Item;
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        return undefined;
+    }
+};
+const putItem = async (config, documentClient, table, Item) => {
+    try {
+        const { expires, ...data } = Item;
+        const command = new libDynamodb.PutCommand({
+            Item: expires === null ? data : Item,
+            TableName: config.tableNamePrefix + table,
+        });
+        return (await queue.schedule(() => documentClient.send(command))) && Item;
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        return undefined;
+    }
+};
+const updateItem = async (config, documentClient, table, key, options = {}) => {
+    try {
+        const command = new libDynamodb.UpdateCommand({
+            Key: makeKey(key),
+            ...options,
+            ReturnValues: 'ALL_NEW',
+            TableName: config.tableNamePrefix + table,
+        });
+        const result = await queue.schedule(async () => documentClient.send(command));
+        return result.Attributes;
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        return undefined;
+    }
+};
+const hasNoUnprocessedItems = ({ UnprocessedItems, }) => !UnprocessedItems || Object.keys(UnprocessedItems).length === 0;
+const makeBatchWriteRequestWithExponentialBackoff = (documentClient, table, batchWriteMaxRetries) => async (batchItems, retries) => {
+    if (retries > batchWriteMaxRetries) {
+        throw new Error('Reached maximum number of DynamoDB BatchWrite request retries.');
+    }
+    if (batchItems === undefined) {
+        throw new Error('makeBatchWriteRequestWithExponentialBackoff: batchItems must not be undefined.');
+    }
+    const command = new libDynamodb.BatchWriteCommand({
+        RequestItems: batchItems.UnprocessedItems ?? {
+            [table]: batchItems.map((Item) => ({
+                PutRequest: { Item },
+            })),
+        },
+        ReturnConsumedCapacity: 'TOTAL',
+        ReturnItemCollectionMetrics: 'SIZE',
+    });
+    return documentClient.send(command);
+};
+const batchWriteItems = async (config, documentClient, table, items) => {
+    try {
+        const batches = splitEvery(25, items);
+        const result = await Promise.all(batches.map(async (batch) => queue.schedule(async () => until(hasNoUnprocessedItems, makeBatchWriteRequestWithExponentialBackoff(documentClient, config.tableNamePrefix + table, config.batchWriteMaxRetries ?? DEFAULT_BATCH_ITEMS_MAX_RETRIES), batch))));
+        return result && items;
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        return undefined;
+    }
+};
+const scanTable = async (config, documentClient, table, options = {}) => {
+    try {
+        const { ConsistentRead = false } = options;
+        const command = new libDynamodb.ScanCommand({
+            ...options,
+            ConsistentRead,
+            TableName: config.tableNamePrefix + table,
+        });
+        return await queue.schedule(() => documentClient.send(command));
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        return undefined;
+    }
+};
+const queryTable = async (config, documentClient, table, options = {}) => {
+    try {
+        const { ConsistentRead = false } = options;
+        const command = new libDynamodb.QueryCommand({
+            ...options,
+            ConsistentRead,
+            TableName: config.tableNamePrefix + table,
+        });
+        return await queue.schedule(() => documentClient.send(command));
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        return undefined;
+    }
+};
+const dynamodb = (userConfig) => {
+    const { clientConfig, ...config } = {
+        ...DEFAULT_AWS_CONFIGURATION,
+        ...userConfig,
+    };
+    const ddbClient = new clientDynamodb.DynamoDBClient(config.dockerConfig
+        ? {
+            credentials: {
+                accessKeyId: 'foobarkey',
+                secretAccessKey: 'foobarsecret',
+            },
+            endpoint: config.dockerConfig.endpoint,
+            region: 'local',
+            retryMode: 'standard',
+        }
+        : { retryMode: 'standard', ...clientConfig });
+    const documentClient = libDynamodb.DynamoDBDocumentClient.from(ddbClient);
+    queue = new Bottleneck({
+        maxConcurrent: config.queueConfig?.queueConcurrency ?? 25,
+        minTime: config.queueConfig?.queueDelay ?? undefined,
+    });
+    return {
+        batchWriteItems: (table, items) => batchWriteItems(config, documentClient, table, items),
+        deleteItem: (table, key, options) => deleteItem(config, documentClient, table, key, options),
+        getItem: (table, key, options) => getItem(config, documentClient, table, key, options),
+        putItem: (table, item) => putItem(config, documentClient, table, item),
+        queryTable: (table, options) => queryTable(config, documentClient, table, options),
+        scanTable: (table, options) => scanTable(config, documentClient, table, options),
+        updateItem: (table, key, options) => updateItem(config, documentClient, table, key, options),
+    };
+};
+
+module.exports = dynamodb;

package/dist/dynamodb.esm.mjs

@@ -0,0 +1,193 @@
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { DynamoDBDocumentClient, UpdateCommand, ScanCommand, QueryCommand, PutCommand, GetCommand, DeleteCommand, BatchWriteCommand } from '@aws-sdk/lib-dynamodb';
+import Bottleneck from 'bottleneck';
+
+const DEFAULT_AWS_CONFIGURATION = {
+    region: 'eu-central-2',
+};
+
+const splitEvery = (every, list) => Array.from({ length: Math.ceil(list.length / every) }).map((_, count) => list.slice(count * every, count * every + every));
+const until = async (predicate, transformer, initialValue, iterationCount = 0) => {
+    const transformed = await transformer(initialValue, iterationCount);
+    return (await predicate(transformed, iterationCount))
+        ? transformed
+        : until(predicate, transformer, transformed, iterationCount + 1);
+};
+
+const DEFAULT_BATCH_ITEMS_MAX_RETRIES = 50;
+let queue;
+const makeKey = (key) => {
+    if (typeof key === 'string') {
+        return { id: key };
+    }
+    return key;
+};
+const deleteItem = async (config, documentClient, table, key, options = {}) => {
+    try {
+        const { ReturnValues = 'NONE' } = options;
+        const command = new DeleteCommand({
+            Key: makeKey(key),
+            ReturnValues,
+            TableName: config.tableNamePrefix + table,
+        });
+        const result = await queue.schedule(() => documentClient.send(command));
+        return result.Attributes;
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        return undefined;
+    }
+};
+const getItem = async (config, documentClient, table, key, options = {}) => {
+    try {
+        const { ConsistentRead = false } = options;
+        const command = new GetCommand({
+            ConsistentRead,
+            Key: makeKey(key),
+            TableName: config.tableNamePrefix + table,
+        });
+        const result = await queue.schedule(() => documentClient.send(command));
+        return result.Item;
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        return undefined;
+    }
+};
+const putItem = async (config, documentClient, table, Item) => {
+    try {
+        const { expires, ...data } = Item;
+        const command = new PutCommand({
+            Item: expires === null ? data : Item,
+            TableName: config.tableNamePrefix + table,
+        });
+        return (await queue.schedule(() => documentClient.send(command))) && Item;
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        return undefined;
+    }
+};
+const updateItem = async (config, documentClient, table, key, options = {}) => {
+    try {
+        const command = new UpdateCommand({
+            Key: makeKey(key),
+            ...options,
+            ReturnValues: 'ALL_NEW',
+            TableName: config.tableNamePrefix + table,
+        });
+        const result = await queue.schedule(async () => documentClient.send(command));
+        return result.Attributes;
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        return undefined;
+    }
+};
+const hasNoUnprocessedItems = ({ UnprocessedItems, }) => !UnprocessedItems || Object.keys(UnprocessedItems).length === 0;
+const makeBatchWriteRequestWithExponentialBackoff = (documentClient, table, batchWriteMaxRetries) => async (batchItems, retries) => {
+    if (retries > batchWriteMaxRetries) {
+        throw new Error('Reached maximum number of DynamoDB BatchWrite request retries.');
+    }
+    if (batchItems === undefined) {
+        throw new Error('makeBatchWriteRequestWithExponentialBackoff: batchItems must not be undefined.');
+    }
+    const command = new BatchWriteCommand({
+        RequestItems: batchItems.UnprocessedItems ?? {
+            [table]: batchItems.map((Item) => ({
+                PutRequest: { Item },
+            })),
+        },
+        ReturnConsumedCapacity: 'TOTAL',
+        ReturnItemCollectionMetrics: 'SIZE',
+    });
+    return documentClient.send(command);
+};
+const batchWriteItems = async (config, documentClient, table, items) => {
+    try {
+        const batches = splitEvery(25, items);
+        const result = await Promise.all(batches.map(async (batch) => queue.schedule(async () => until(hasNoUnprocessedItems, makeBatchWriteRequestWithExponentialBackoff(documentClient, config.tableNamePrefix + table, config.batchWriteMaxRetries ?? DEFAULT_BATCH_ITEMS_MAX_RETRIES), batch))));
+        return result && items;
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        return undefined;
+    }
+};
+const scanTable = async (config, documentClient, table, options = {}) => {
+    try {
+        const { ConsistentRead = false } = options;
+        const command = new ScanCommand({
+            ...options,
+            ConsistentRead,
+            TableName: config.tableNamePrefix + table,
+        });
+        return await queue.schedule(() => documentClient.send(command));
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        return undefined;
+    }
+};
+const queryTable = async (config, documentClient, table, options = {}) => {
+    try {
+        const { ConsistentRead = false } = options;
+        const command = new QueryCommand({
+            ...options,
+            ConsistentRead,
+            TableName: config.tableNamePrefix + table,
+        });
+        return await queue.schedule(() => documentClient.send(command));
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        return undefined;
+    }
+};
+const dynamodb = (userConfig) => {
+    const { clientConfig, ...config } = {
+        ...DEFAULT_AWS_CONFIGURATION,
+        ...userConfig,
+    };
+    const ddbClient = new DynamoDBClient(config.dockerConfig
+        ? {
+            credentials: {
+                accessKeyId: 'foobarkey',
+                secretAccessKey: 'foobarsecret',
+            },
+            endpoint: config.dockerConfig.endpoint,
+            region: 'local',
+            retryMode: 'standard',
+        }
+        : { retryMode: 'standard', ...clientConfig });
+    const documentClient = DynamoDBDocumentClient.from(ddbClient);
+    queue = new Bottleneck({
+        maxConcurrent: config.queueConfig?.queueConcurrency ?? 25,
+        minTime: config.queueConfig?.queueDelay ?? undefined,
+    });
+    return {
+        batchWriteItems: (table, items) => batchWriteItems(config, documentClient, table, items),
+        deleteItem: (table, key, options) => deleteItem(config, documentClient, table, key, options),
+        getItem: (table, key, options) => getItem(config, documentClient, table, key, options),
+        putItem: (table, item) => putItem(config, documentClient, table, item),
+        queryTable: (table, options) => queryTable(config, documentClient, table, options),
+        scanTable: (table, options) => scanTable(config, documentClient, table, options),
+        updateItem: (table, key, options) => updateItem(config, documentClient, table, key, options),
+    };
+};
+
+export { dynamodb as default };

package/dist/lambda.cjs.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var clientLambda = require('@aws-sdk/client-lambda');
+
+const DEFAULT_AWS_CONFIGURATION = {
+    region: 'eu-central-2',
+};
+
+const invokeLambda = async (lambdaClient, config, invocationType, payload) => {
+    try {
+        const invokeCommand = new clientLambda.InvokeCommand({
+            FunctionName: config.functionName,
+            InvocationType: invocationType,
+            Payload: Buffer.from(JSON.stringify(payload)),
+        });
+        const result = await lambdaClient.send(invokeCommand);
+        if (config.logger) {
+            config.logger.info(JSON.stringify(result));
+        }
+        return true;
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        return false;
+    }
+};
+const lambda = (userConfig) => {
+    const { clientConfig, ...config } = {
+        ...DEFAULT_AWS_CONFIGURATION,
+        ...userConfig,
+    };
+    const lambdaClient = new clientLambda.LambdaClient(clientConfig);
+    return {
+        invokeLambda: (invocationType, payload) => invokeLambda(lambdaClient, config, invocationType, payload),
+    };
+};
+
+module.exports = lambda;

package/dist/lambda.esm.mjs

@@ -0,0 +1,38 @@
+import { LambdaClient, InvokeCommand } from '@aws-sdk/client-lambda';
+
+const DEFAULT_AWS_CONFIGURATION = {
+    region: 'eu-central-2',
+};
+
+const invokeLambda = async (lambdaClient, config, invocationType, payload) => {
+    try {
+        const invokeCommand = new InvokeCommand({
+            FunctionName: config.functionName,
+            InvocationType: invocationType,
+            Payload: Buffer.from(JSON.stringify(payload)),
+        });
+        const result = await lambdaClient.send(invokeCommand);
+        if (config.logger) {
+            config.logger.info(JSON.stringify(result));
+        }
+        return true;
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        return false;
+    }
+};
+const lambda = (userConfig) => {
+    const { clientConfig, ...config } = {
+        ...DEFAULT_AWS_CONFIGURATION,
+        ...userConfig,
+    };
+    const lambdaClient = new LambdaClient(clientConfig);
+    return {
+        invokeLambda: (invocationType, payload) => invokeLambda(lambdaClient, config, invocationType, payload),
+    };
+};
+
+export { lambda as default };

package/dist/logger.cjs.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var winston = require('winston');
+
+const logger = (config) => {
+    const loggerConfig = {
+        defaultMeta: {
+            ...config.defaultLogInformation,
+            deploymentStage: config.deploymentStage,
+            service: config.service,
+        },
+        format: winston.format.combine(winston.format.timestamp({
+            format: 'DD-MM-YYYY HH:mm:ss',
+        }), winston.format.json()),
+        level: config.level || 'info',
+    };
+    if (config.datadogApiKey) {
+        const httpOptions = {
+            host: 'http-intake.logs.datadoghq.eu',
+            path: `/api/v2/logs?dd-api-key=${config.datadogApiKey}&ddsource=nodejs&service=${config.service}`,
+            port: 443,
+            ssl: true,
+        };
+        return winston.createLogger({
+            ...loggerConfig,
+            transports: [new winston.transports.Http(httpOptions)],
+        });
+    }
+    return winston.createLogger({
+        ...loggerConfig,
+        transports: [new winston.transports.Console({ forceConsole: true })],
+    });
+};
+
+module.exports = logger;

package/dist/logger.esm.mjs

@@ -0,0 +1,33 @@
+import { format, createLogger, transports } from 'winston';
+
+const logger = (config) => {
+    const loggerConfig = {
+        defaultMeta: {
+            ...config.defaultLogInformation,
+            deploymentStage: config.deploymentStage,
+            service: config.service,
+        },
+        format: format.combine(format.timestamp({
+            format: 'DD-MM-YYYY HH:mm:ss',
+        }), format.json()),
+        level: config.level || 'info',
+    };
+    if (config.datadogApiKey) {
+        const httpOptions = {
+            host: 'http-intake.logs.datadoghq.eu',
+            path: `/api/v2/logs?dd-api-key=${config.datadogApiKey}&ddsource=nodejs&service=${config.service}`,
+            port: 443,
+            ssl: true,
+        };
+        return createLogger({
+            ...loggerConfig,
+            transports: [new transports.Http(httpOptions)],
+        });
+    }
+    return createLogger({
+        ...loggerConfig,
+        transports: [new transports.Console({ forceConsole: true })],
+    });
+};
+
+export { logger as default };

package/dist/ses.cjs.js

@@ -0,0 +1,62 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var clientSesv2 = require('@aws-sdk/client-sesv2');
+var nodemailer = require('nodemailer');
+
+const DEFAULT_CLIENT_CONFIG = {
+    clientConfig: { region: 'eu-west-1' },
+};
+const sendMail = async (config, transport, options, responseCallback) => {
+    try {
+        if (!options.html && !options.text) {
+            if (config.logger) {
+                config.logger.error('The option text or html needs to be set.');
+            }
+            return false;
+        }
+        if (!options.to || !options.subject) {
+            if (config.logger) {
+                config.logger.error('The fields to and subject have to be set.');
+            }
+            return false;
+        }
+        const transportResponse = await transport.sendMail(options);
+        if (responseCallback) {
+            await responseCallback(transportResponse);
+        }
+        if (!transportResponse) {
+            if (config.logger) {
+                config.logger.error('Sending email failed!');
+            }
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        return false;
+    }
+};
+const ses = (userConfig) => {
+    const { clientConfig, ...config } = {
+        ...DEFAULT_CLIENT_CONFIG,
+        ...userConfig,
+    };
+    const sesClient = new clientSesv2.SESv2Client(clientConfig);
+    const transport = nodemailer.createTransport(userConfig.customSMTPConfig ?? {
+        SES: {
+            SendEmailCommand: clientSesv2.SendEmailCommand,
+            sesClient,
+        },
+    });
+    return {
+        sendMail: (options, responseCallback) => sendMail(config, transport, options, responseCallback),
+    };
+};
+
+exports.DEFAULT_CLIENT_CONFIG = DEFAULT_CLIENT_CONFIG;
+exports.default = ses;

package/dist/ses.esm.mjs

@@ -0,0 +1,57 @@
+import { SESv2Client, SendEmailCommand } from '@aws-sdk/client-sesv2';
+import { createTransport } from 'nodemailer';
+
+const DEFAULT_CLIENT_CONFIG = {
+    clientConfig: { region: 'eu-west-1' },
+};
+const sendMail = async (config, transport, options, responseCallback) => {
+    try {
+        if (!options.html && !options.text) {
+            if (config.logger) {
+                config.logger.error('The option text or html needs to be set.');
+            }
+            return false;
+        }
+        if (!options.to || !options.subject) {
+            if (config.logger) {
+                config.logger.error('The fields to and subject have to be set.');
+            }
+            return false;
+        }
+        const transportResponse = await transport.sendMail(options);
+        if (responseCallback) {
+            await responseCallback(transportResponse);
+        }
+        if (!transportResponse) {
+            if (config.logger) {
+                config.logger.error('Sending email failed!');
+            }
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        return false;
+    }
+};
+const ses = (userConfig) => {
+    const { clientConfig, ...config } = {
+        ...DEFAULT_CLIENT_CONFIG,
+        ...userConfig,
+    };
+    const sesClient = new SESv2Client(clientConfig);
+    const transport = createTransport(userConfig.customSMTPConfig ?? {
+        SES: {
+            SendEmailCommand,
+            sesClient,
+        },
+    });
+    return {
+        sendMail: (options, responseCallback) => sendMail(config, transport, options, responseCallback),
+    };
+};
+
+export { DEFAULT_CLIENT_CONFIG, ses as default };