@allthings/cloud-toolkit 5.1.0 → 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/parameterStore.cjs.js

@@ -0,0 +1,84 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var clientSsm = require('@aws-sdk/client-ssm');
+
+const DEFAULT_AWS_CONFIGURATION = {
+    region: 'eu-central-2',
+};
+
+const DEFAULT_CLIENT_CONFIG = {
+    clientConfig: DEFAULT_AWS_CONFIGURATION,
+    onlyDefault: false,
+    prefix: process.env.SSM_PARAM_PATH,
+};
+const getSecrets = async (ssm, config, parameters_, defaultValues) => {
+    if (config.onlyDefault) {
+        return defaultValues;
+    }
+    try {
+        const command = new clientSsm.GetParametersCommand({
+            Names: parameters_.map((parameter) => `${config.prefix ?? ''}${parameter}`),
+            WithDecryption: true,
+        });
+        const parameters = await ssm.send(command);
+        return (parameters?.Parameters?.map((parameter) => {
+            const defaultIfNoParameter = !parameter.Value && parameter.Name
+                ? defaultValues.find((defaultValue) => defaultValue.name === parameter.Name)
+                : defaultValues[0];
+            return {
+                name: parameter.Name ?? defaultIfNoParameter?.name ?? '',
+                value: parameter.Value ?? defaultIfNoParameter?.value ?? '',
+            };
+        }) ?? defaultValues);
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        return defaultValues;
+    }
+};
+const getSecret = async (ssm, config, parameter_, defaultValue) => {
+    if (config.onlyDefault) {
+        if (defaultValue === undefined) {
+            throw new Error(`Cannot retrieve parameter ${parameter_}: onlyDefault is enabled and no default value was provided`);
+        }
+        return defaultValue;
+    }
+    try {
+        const parameter = await ssm.send(new clientSsm.GetParameterCommand({
+            Name: `${config.prefix ?? ''}${parameter_}`,
+            WithDecryption: true,
+        }));
+        const value = parameter?.Parameter?.Value;
+        if (value === undefined) {
+            throw new Error(`Could not retrieve parameter ${parameter_} from AWS SSM parameter store`);
+        }
+        return value;
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        if (defaultValue === undefined) {
+            throw error;
+        }
+        return defaultValue;
+    }
+};
+const parameterStore = (userConfig) => {
+    const { clientConfig, ...config } = {
+        ...DEFAULT_CLIENT_CONFIG,
+        ...userConfig,
+    };
+    const ssm = new clientSsm.SSMClient(clientConfig);
+    return {
+        getSecret: (parameter, defaultValue) => getSecret(ssm, config, parameter, defaultValue),
+        getSecrets: (parameters, defaultValues = []) => getSecrets(ssm, config, parameters, defaultValues),
+    };
+};
+
+exports.DEFAULT_CLIENT_CONFIG = DEFAULT_CLIENT_CONFIG;
+exports.default = parameterStore;

package/dist/parameterStore.esm.mjs

@@ -0,0 +1,79 @@
+import { SSMClient, GetParametersCommand, GetParameterCommand } from '@aws-sdk/client-ssm';
+
+const DEFAULT_AWS_CONFIGURATION = {
+    region: 'eu-central-2',
+};
+
+const DEFAULT_CLIENT_CONFIG = {
+    clientConfig: DEFAULT_AWS_CONFIGURATION,
+    onlyDefault: false,
+    prefix: process.env.SSM_PARAM_PATH,
+};
+const getSecrets = async (ssm, config, parameters_, defaultValues) => {
+    if (config.onlyDefault) {
+        return defaultValues;
+    }
+    try {
+        const command = new GetParametersCommand({
+            Names: parameters_.map((parameter) => `${config.prefix ?? ''}${parameter}`),
+            WithDecryption: true,
+        });
+        const parameters = await ssm.send(command);
+        return (parameters?.Parameters?.map((parameter) => {
+            const defaultIfNoParameter = !parameter.Value && parameter.Name
+                ? defaultValues.find((defaultValue) => defaultValue.name === parameter.Name)
+                : defaultValues[0];
+            return {
+                name: parameter.Name ?? defaultIfNoParameter?.name ?? '',
+                value: parameter.Value ?? defaultIfNoParameter?.value ?? '',
+            };
+        }) ?? defaultValues);
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        return defaultValues;
+    }
+};
+const getSecret = async (ssm, config, parameter_, defaultValue) => {
+    if (config.onlyDefault) {
+        if (defaultValue === undefined) {
+            throw new Error(`Cannot retrieve parameter ${parameter_}: onlyDefault is enabled and no default value was provided`);
+        }
+        return defaultValue;
+    }
+    try {
+        const parameter = await ssm.send(new GetParameterCommand({
+            Name: `${config.prefix ?? ''}${parameter_}`,
+            WithDecryption: true,
+        }));
+        const value = parameter?.Parameter?.Value;
+        if (value === undefined) {
+            throw new Error(`Could not retrieve parameter ${parameter_} from AWS SSM parameter store`);
+        }
+        return value;
+    }
+    catch (error) {
+        if (config.logger) {
+            config.logger.error(error);
+        }
+        if (defaultValue === undefined) {
+            throw error;
+        }
+        return defaultValue;
+    }
+};
+const parameterStore = (userConfig) => {
+    const { clientConfig, ...config } = {
+        ...DEFAULT_CLIENT_CONFIG,
+        ...userConfig,
+    };
+    const ssm = new SSMClient(clientConfig);
+    return {
+        getSecret: (parameter, defaultValue) => getSecret(ssm, config, parameter, defaultValue),
+        getSecrets: (parameters, defaultValues = []) => getSecrets(ssm, config, parameters, defaultValues),
+    };
+};
+
+export { DEFAULT_CLIENT_CONFIG, parameterStore as default };