@tomassabol/dynamodb-tools 1.0.19

package/README.md

@@ -0,0 +1,13 @@
+# tomassabol DynamoDB Tools
+
+Tools for working with DynamoDB using AWS SDK v3.
+
+## Installation
+
+```
+npm install @tomassabol/dynamodb-tools
+```
+
+# API Documentation
+
+See [API Documentation](docs/README.md)

package/dist/common/logger-interface.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Logger interface
+ */
+export interface ILogger {
+    debug(message?: any, ...optionalParams: any[]): void;
+    info(message?: any, ...optionalParams: any[]): void;
+    error(message?: any, ...optionalParams: any[]): void;
+    warn(message?: any, ...optionalParams: any[]): void;
+}

package/dist/common/logger-interface.js

@@ -0,0 +1,3 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/common/logger.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Empty logger used to disable logging for unit tests.
+ */
+import { ILogger } from "./logger-interface";
+/**
+ * CloudWatch logger.
+ */
+export declare const logger: ILogger;

package/dist/common/logger.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Empty logger used to disable logging for unit tests.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const noLogger = {
+    log: () => undefined,
+    debug: () => undefined,
+    info: () => undefined,
+    error: () => undefined,
+    warn: () => undefined,
+};
+/**
+ * CloudWatch logger.
+ */
+exports.logger = process.env.JEST_WORKER_ID === undefined || process.env.TEST_LOGGER
+    ? console
+    : noLogger;

package/dist/dynamodb/command-builder.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Abstract base class for DynamoDB command builders.
+ */
+export declare abstract class CommandBuilder<T extends Record<string, unknown>> {
+    protected expressionAttributeNames: Record<string, string>;
+    protected expressionAttributeValues: Record<string, unknown>;
+    /**
+     * Create new attribute name #attr = attr
+     */
+    protected createAttributeName(attr: keyof T): string;
+    /**
+     * Create new attribute value :name = value
+     */
+    protected createAttributeValue(name: string, value: unknown): string;
+    /**
+     * Create new attribute name and value: #attr = attr, :attr = value
+     */
+    protected createAttributeNameAndValue(attr: keyof T, value: unknown): {
+        attrName: string;
+        valueName: string;
+    };
+}

package/dist/dynamodb/command-builder.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandBuilder = void 0;
+const assert_1 = __importDefault(require("assert"));
+/**
+ * Abstract base class for DynamoDB command builders.
+ */
+class CommandBuilder {
+    expressionAttributeNames = {};
+    expressionAttributeValues = {};
+    /**
+     * Create new attribute name #attr = attr
+     */
+    createAttributeName(attr) {
+        (0, assert_1.default)(typeof attr === "string", "Invalid attribute");
+        const attrName = "#" + attr;
+        this.expressionAttributeNames[attrName] = attr;
+        return attrName;
+    }
+    /**
+     * Create new attribute value :name = value
+     */
+    createAttributeValue(name, value) {
+        let valueName = ":" + name;
+        if (Object.hasOwn(this.expressionAttributeValues, valueName) &&
+            this.expressionAttributeValues[valueName] !== value) {
+            const index = Object.keys(this.expressionAttributeValues).length; // Create unique index
+            valueName = `${valueName}_${index}`;
+        }
+        this.expressionAttributeValues[valueName] = value;
+        return valueName;
+    }
+    /**
+     * Create new attribute name and value: #attr = attr, :attr = value
+     */
+    createAttributeNameAndValue(attr, value) {
+        (0, assert_1.default)(typeof attr === "string", "Invalid attribute");
+        const attrName = this.createAttributeName(attr);
+        const valueName = this.createAttributeValue(attr, value);
+        return { attrName, valueName };
+    }
+}
+exports.CommandBuilder = CommandBuilder;

package/dist/dynamodb/default-table-fields.d.ts

@@ -0,0 +1,18 @@
+import { TTLValue } from "../utils/create-ttl";
+/**
+ * Default fields added to tables
+ */
+export type DefaultTableFields = {
+    /** Date and time when record was created */
+    createdAt: string;
+    /** Date and time when record was last updated */
+    updatedAt: string;
+    /** Time to live */
+    ttl?: number | null;
+};
+/**
+ * Create values for default table fields
+ */
+export declare function createDefaultTableFields(options?: {
+    ttl?: TTLValue | null;
+}): DefaultTableFields;

package/dist/dynamodb/default-table-fields.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultTableFields = createDefaultTableFields;
+const create_ttl_1 = require("../utils/create-ttl");
+const date_time_1 = require("../utils/date-time");
+/**
+ * Create values for default table fields
+ */
+function createDefaultTableFields(options = {}) {
+    const { ttl } = options;
+    const currentDate = (0, date_time_1.getCurrentDateTimeISO)();
+    return {
+        createdAt: currentDate,
+        updatedAt: currentDate,
+        ...(ttl !== undefined && { ttl: (0, create_ttl_1.createTTL)(ttl) }),
+    };
+}

package/dist/dynamodb/get-many.d.ts

@@ -0,0 +1,9 @@
+import { BatchGetCommandInput, DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
+/**
+ * Generator to split an array into smaller arrays containing max batchSize items
+ */
+export declare function splitToBatches<T>(arr: T[], batchSize?: number): Generator<T[], void, unknown>;
+/**
+ * Async generator to perform GetBatchCommand and handle unprocessed keys with retries
+ */
+export declare function retryBatchGetCommand(client: DynamoDBDocumentClient, requestItems: BatchGetCommandInput["RequestItems"]): AsyncGenerator<import("@aws-sdk/lib-dynamodb").BatchGetCommandOutput, void, unknown>;

package/dist/dynamodb/get-many.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitToBatches = splitToBatches;
+exports.retryBatchGetCommand = retryBatchGetCommand;
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
+/**
+ * Generator to split an array into smaller arrays containing max batchSize items
+ */
+function* splitToBatches(arr, batchSize = 25) {
+    let start = 0;
+    while (start < arr.length) {
+        const end = start + batchSize;
+        yield arr.slice(start, end);
+        start = end;
+    }
+}
+/**
+ * Async generator to perform GetBatchCommand and handle unprocessed keys with retries
+ */
+async function* retryBatchGetCommand(client, requestItems) {
+    let current = requestItems;
+    while (current && Object.keys(current).length > 0) {
+        const command = new lib_dynamodb_1.BatchGetCommand({
+            RequestItems: current,
+        });
+        const output = await client.send(command);
+        current = output.UnprocessedKeys;
+        yield output;
+    }
+}

package/dist/dynamodb/iterators.d.ts

@@ -0,0 +1,12 @@
+import { DynamoDBDocumentClient, QueryCommandInput, ScanCommandInput } from "@aws-sdk/lib-dynamodb";
+export type QueryTableIteratorOptions = Omit<QueryCommandInput, "TableName" | "ExclusiveStartKey">;
+export type ScanTableIteratorOptions = Omit<ScanCommandInput, "TableName" | "ExclusiveStartKey">;
+/**
+ * Create asynchronous iterator to query all items of a table
+ */
+export declare function queryTableIterator<T = unknown>(client: DynamoDBDocumentClient, tableName: string, startKey?: object, options?: QueryTableIteratorOptions): AsyncGenerator<Awaited<T>, void, unknown>;
+/**
+ * Create asynchronous iterator to scan all items of a table
+ */
+export declare function scanTableIterator<T = unknown>(client: DynamoDBDocumentClient, tableName: string, startKey?: object, options?: ScanTableIteratorOptions): AsyncGenerator<Awaited<T>, void, unknown>;
+export declare function collectItems<T>(iterator: AsyncGenerator<T>): Promise<Awaited<T>[]>;

package/dist/dynamodb/iterators.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryTableIterator = queryTableIterator;
+exports.scanTableIterator = scanTableIterator;
+exports.collectItems = collectItems;
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
+/**
+ * Create asynchronous iterator to query all items of a table
+ */
+async function* queryTableIterator(client, tableName, startKey, options = {}) {
+    let lastKey = startKey;
+    do {
+        const command = new lib_dynamodb_1.QueryCommand({
+            ...options,
+            TableName: tableName,
+            ExclusiveStartKey: lastKey,
+        });
+        const output = await client.send(command);
+        const items = output.Items;
+        if (items) {
+            for (const item of items) {
+                yield item;
+            }
+        }
+        lastKey = output.LastEvaluatedKey;
+    } while (lastKey);
+}
+/**
+ * Create asynchronous iterator to scan all items of a table
+ */
+async function* scanTableIterator(client, tableName, startKey, options = {}) {
+    let lastKey = startKey;
+    do {
+        const command = new lib_dynamodb_1.ScanCommand({
+            ...options,
+            TableName: tableName,
+            ExclusiveStartKey: lastKey,
+        });
+        const output = await client.send(command);
+        const items = output.Items;
+        if (items) {
+            for (const item of items) {
+                yield item;
+            }
+        }
+        lastKey = output.LastEvaluatedKey;
+    } while (lastKey);
+}
+async function collectItems(iterator) {
+    const result = [];
+    for await (const item of iterator) {
+        result.push(item);
+    }
+    return result;
+}

package/dist/dynamodb/query-command-builder.d.ts

@@ -0,0 +1,92 @@
+import { QueryCommandInput } from "@aws-sdk/lib-dynamodb";
+import { CommandBuilder } from "./command-builder";
+type ArrayKeys<T> = {
+    [K in keyof T]: T[K] extends readonly any[] ? K : never;
+}[keyof T];
+/**
+ * Builder for update expression in DynamoDB update command
+ *
+ * @example
+ * ```typescript
+ * const builder = new QueryCommandBuilder<MyTableRecord>("table")
+ *
+ * const input = builder
+ *   .partitionKeyEquals("pk", "12345")
+ *   .buildCommandInput()
+ * const command = new QueryCommand(input)
+ * await documentClient.client.send(command)
+ * ```
+ */
+export declare class QueryCommandBuilder<T extends Record<string, unknown>> extends CommandBuilder<T> {
+    private partitionKeyExpression;
+    private sortKeyExpression;
+    private projectionExpression;
+    private filterExpression;
+    private commandOptions;
+    constructor(tableName: string, options?: Partial<QueryCommandInput>);
+    /**
+     * Add key condition for partition key
+     */
+    partitionKeyEquals<K extends keyof T>(attr: K, value: T[K]): this;
+    /**
+     * Add key condition for sort key
+     */
+    sortKeyCondition<K extends keyof T>(attr: K, operator: "=" | "<" | "<=" | ">" | ">=" | "begins_with", value: T[K]): this;
+    /**
+     * Add filter expression condition
+     *
+     * @examples
+     * ```ts
+     *   builder
+     *     .addFilterCondition("attr1", ">", 10)         // attr3 > 10
+     *     .addFilterCondition("attr2", "IN", [1, 2, 3]) // attr2 IN (1, 2, 3)
+     *     .addFilterCondition("attr3", "IN", [1, 2, 3], { not: true }) // NOT (attr3 IN (1, 2, 3))
+     * ```
+     */
+    addFilterCondition<K extends keyof T>(attr: K, operator: "IN", value: T[K][], options?: {
+        not?: boolean;
+    }): this;
+    addFilterCondition<K extends keyof T>(attr: K, operator: "=" | "<" | "<=" | ">" | ">=" | "<>", value: T[K], options?: {
+        not?: boolean;
+    }): this;
+    /**
+     * Add existential filter expression condition
+     */
+    addExistentialFilterCondition<K extends keyof T>(attr: K, operator: "exists" | "not_exists"): this;
+    /**
+     * Add filter condition based on array size using DynamoDB's size() function.
+     *
+     * @param attr - The attribute to filter by size (should be an array)
+     * @param condition - The size condition with value and operator
+     * @param options - Optional settings like negation
+     *
+     * @example
+     * ```typescript
+     * // Filter by array size
+     * builder.addArraySizeFilterCondition("shipmentItems", { value: 5, operator: ">" })
+     * // Generates: size(#shipmentItems) > :shipmentItems
+     *
+     * // Works with all comparison operators
+     * builder.addArraySizeFilterCondition("tags", { value: 0, operator: "<>" })
+     * builder.addArraySizeFilterCondition("items", { value: 10, operator: "<=" })
+     *
+     * // Can be negated
+     * builder.addArraySizeFilterCondition("items", { value: 0, operator: "=" }, { not: true })
+     * ```
+     */
+    addArraySizeFilterCondition<K extends ArrayKeys<T>>(attr: K, condition: {
+        value: number;
+        operator: "=" | "<>" | "<" | "<=" | ">" | ">=";
+    }, options?: {
+        not?: boolean;
+    }): this;
+    /**
+     * Add attributes which should be returned in result (by default all attributes are returned).
+     */
+    addProjectionAttributes(attrs: Array<keyof T>): this;
+    /**
+     * Build command input
+     */
+    buildCommandInput(): QueryCommandInput;
+}
+export {};

package/dist/dynamodb/query-command-builder.js

@@ -0,0 +1,161 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryCommandBuilder = void 0;
+const command_builder_1 = require("./command-builder");
+const assert_1 = __importDefault(require("assert"));
+/**
+ * Builder for update expression in DynamoDB update command
+ *
+ * @example
+ * ```typescript
+ * const builder = new QueryCommandBuilder<MyTableRecord>("table")
+ *
+ * const input = builder
+ *   .partitionKeyEquals("pk", "12345")
+ *   .buildCommandInput()
+ * const command = new QueryCommand(input)
+ * await documentClient.client.send(command)
+ * ```
+ */
+class QueryCommandBuilder extends command_builder_1.CommandBuilder {
+    partitionKeyExpression = "";
+    sortKeyExpression = "";
+    projectionExpression = [];
+    filterExpression = [];
+    commandOptions;
+    constructor(tableName, options = {}) {
+        super();
+        this.commandOptions = {
+            ...options,
+            TableName: tableName,
+        };
+    }
+    /**
+     * Add key condition for partition key
+     */
+    partitionKeyEquals(attr, value) {
+        const { attrName, valueName } = this.createAttributeNameAndValue(attr, value);
+        if (this.partitionKeyExpression)
+            throw new Error("Max one partition key condition is allowed");
+        this.partitionKeyExpression = `${attrName} = ${valueName}`;
+        return this;
+    }
+    /**
+     * Add key condition for sort key
+     */
+    sortKeyCondition(attr, operator, value) {
+        const { attrName, valueName } = this.createAttributeNameAndValue(attr, value);
+        if (this.sortKeyExpression)
+            throw new Error("Max one sort key condition is allowed");
+        this.sortKeyExpression =
+            operator === "begins_with"
+                ? `begins_with(${attrName}, ${valueName})`
+                : `${attrName} ${operator} ${valueName}`;
+        return this;
+    }
+    addFilterCondition(attr, operator, value, options = {}) {
+        // See https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Syntax
+        (0, assert_1.default)(typeof attr === "string", "Invalid attribute");
+        const attrName = this.createAttributeName(attr);
+        const expectArrayOfValues = operator === "IN";
+        const valueArr = Array.isArray(value) ? value : [value];
+        if (valueArr.length > 1 && !expectArrayOfValues) {
+            throw new Error("QueryCommandBuilder.addFilterCondition: invalid value - array not expected for this operation");
+        }
+        const valueNames = valueArr.map((value) => this.createAttributeValue(attr, value));
+        const rightOperand = expectArrayOfValues
+            ? `(${valueNames.join(", ")})`
+            : valueNames[0];
+        const condition = `${attrName} ${operator} ${rightOperand}`;
+        const expression = options.not ? `NOT (${condition})` : condition;
+        this.filterExpression.push(expression);
+        return this;
+    }
+    /**
+     * Add existential filter expression condition
+     */
+    addExistentialFilterCondition(attr, operator) {
+        // See https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Syntax
+        let existentialExpression;
+        const attributeName = this.createAttributeName(attr);
+        if (operator === "exists") {
+            existentialExpression = `attribute_exists(${attributeName})`;
+        }
+        if (operator === "not_exists") {
+            existentialExpression = `attribute_not_exists(${attributeName})`;
+        }
+        if (existentialExpression)
+            this.filterExpression.push(existentialExpression);
+        return this;
+    }
+    /**
+     * Add filter condition based on array size using DynamoDB's size() function.
+     *
+     * @param attr - The attribute to filter by size (should be an array)
+     * @param condition - The size condition with value and operator
+     * @param options - Optional settings like negation
+     *
+     * @example
+     * ```typescript
+     * // Filter by array size
+     * builder.addArraySizeFilterCondition("shipmentItems", { value: 5, operator: ">" })
+     * // Generates: size(#shipmentItems) > :shipmentItems
+     *
+     * // Works with all comparison operators
+     * builder.addArraySizeFilterCondition("tags", { value: 0, operator: "<>" })
+     * builder.addArraySizeFilterCondition("items", { value: 10, operator: "<=" })
+     *
+     * // Can be negated
+     * builder.addArraySizeFilterCondition("items", { value: 0, operator: "=" }, { not: true })
+     * ```
+     */
+    addArraySizeFilterCondition(attr, condition, options = {}) {
+        (0, assert_1.default)(typeof attr === "string", "Invalid attribute");
+        const attrName = this.createAttributeName(attr);
+        const valueName = this.createAttributeValue(attr, condition.value);
+        const filterExpression = `size(${attrName}) ${condition.operator} ${valueName}`;
+        const expression = options.not
+            ? `NOT (${filterExpression})`
+            : filterExpression;
+        this.filterExpression.push(expression);
+        return this;
+    }
+    /**
+     * Add attributes which should be returned in result (by default all attributes are returned).
+     */
+    addProjectionAttributes(attrs) {
+        attrs.forEach((attr) => {
+            const attrName = this.createAttributeName(attr);
+            this.projectionExpression.push(attrName);
+        });
+        return this;
+    }
+    /**
+     * Build command input
+     */
+    buildCommandInput() {
+        if (!this.partitionKeyExpression) {
+            throw new Error("Missing partition key condition");
+        }
+        const keyConditionExpression = this.sortKeyExpression
+            ? `${this.partitionKeyExpression} AND ${this.sortKeyExpression}`
+            : this.partitionKeyExpression;
+        return {
+            ...this.commandOptions,
+            KeyConditionExpression: keyConditionExpression,
+            ExpressionAttributeNames: this.expressionAttributeNames,
+            ExpressionAttributeValues: this.expressionAttributeValues,
+            ...(this.projectionExpression.length > 0 && {
+                Select: "SPECIFIC_ATTRIBUTES",
+                ProjectionExpression: this.projectionExpression.join(", "),
+            }),
+            ...(this.filterExpression.length > 0 && {
+                FilterExpression: this.filterExpression.join(" AND "),
+            }),
+        };
+    }
+}
+exports.QueryCommandBuilder = QueryCommandBuilder;

package/dist/dynamodb/query-iterator.d.ts

@@ -0,0 +1,41 @@
+import { DynamoDBDocumentClient, QueryCommandInput, QueryCommandOutput } from "@aws-sdk/lib-dynamodb";
+/**
+ * Async iterator for query items.
+ * Executes query and yields array of returned items. Repeats until all items are returned.
+ *
+ * @example
+ * ```typescript
+ * for await (const items of queryIterator(exclusiveStartKey => doDynamoDBQuery(exclusiveStartKey))) {
+ *   console.log(items)
+ * }
+ * ```
+ */
+export declare function queryIterator(query: (exclusiveStartKey?: object) => Promise<QueryCommandOutput>, options?: {
+    startKey?: object;
+}): AsyncGenerator<Record<string, any>[], void, unknown>;
+/**
+ * Async iterator for single query items.
+ * Executes query and yields each returned item. Repeats until all items are returned.
+ *
+ * @example
+ * ```typescript
+ * for await (const item of queryItemIterator(exclusiveStartKey => doDynamoDBQuery(exclusiveStartKey))) {
+ *   console.log(item)
+ * }
+ * ```
+ */
+export declare function queryItemIterator(query: (exclusiveStartKey?: object) => Promise<QueryCommandOutput>, options?: {
+    startKey?: object;
+}): AsyncGenerator<Record<string, any>, void, unknown>;
+/**
+ * Concatenate all query results into an array of items
+ *
+ * @example
+ * ```typescript
+ * const input = { TableName: "tableName", ... }
+ * const output = await concatQueryResults(client, input)
+ * ```
+ */
+export declare function concatQueryResults<T>(client: DynamoDBDocumentClient, input: QueryCommandInput, options?: {
+    startKey?: object;
+}): Promise<T[]>;

package/dist/dynamodb/query-iterator.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryIterator = queryIterator;
+exports.queryItemIterator = queryItemIterator;
+exports.concatQueryResults = concatQueryResults;
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
+/**
+ * Async iterator for query items.
+ * Executes query and yields array of returned items. Repeats until all items are returned.
+ *
+ * @example
+ * ```typescript
+ * for await (const items of queryIterator(exclusiveStartKey => doDynamoDBQuery(exclusiveStartKey))) {
+ *   console.log(items)
+ * }
+ * ```
+ */
+async function* queryIterator(query, options = {}) {
+    let { startKey: exclusiveStartKey } = options;
+    do {
+        const result = await query(exclusiveStartKey);
+        if (result.Items) {
+            yield result.Items;
+        }
+        exclusiveStartKey = result.LastEvaluatedKey;
+    } while (exclusiveStartKey);
+}
+/**
+ * Async iterator for single query items.
+ * Executes query and yields each returned item. Repeats until all items are returned.
+ *
+ * @example
+ * ```typescript
+ * for await (const item of queryItemIterator(exclusiveStartKey => doDynamoDBQuery(exclusiveStartKey))) {
+ *   console.log(item)
+ * }
+ * ```
+ */
+async function* queryItemIterator(query, options = {}) {
+    for await (const result of queryIterator(query, options)) {
+        for (const item of result) {
+            yield item;
+        }
+    }
+}
+/**
+ * Concatenate all query results into an array of items
+ *
+ * @example
+ * ```typescript
+ * const input = { TableName: "tableName", ... }
+ * const output = await concatQueryResults(client, input)
+ * ```
+ */
+async function concatQueryResults(client, input, options = {}) {
+    const result = [];
+    const asyncIterator = queryItemIterator((exclusiveStartKey) => {
+        const command = new lib_dynamodb_1.QueryCommand({
+            ...input,
+            ExclusiveStartKey: exclusiveStartKey,
+        });
+        return client.send(command);
+    }, options);
+    for await (const item of asyncIterator)
+        result.push(item);
+    return result;
+}

package/dist/dynamodb/update-command-builder.d.ts

@@ -0,0 +1,64 @@
+import { UpdateCommandInput } from "@aws-sdk/lib-dynamodb";
+import { CommandBuilder } from "./command-builder";
+/**
+ * Update Command Options
+ */
+export type UpdateCommandOptions = {
+    ifNotExists?: boolean;
+};
+export type ConditionOperator = "=" | "<" | "<=" | ">" | ">=" | "<>" | "IN";
+/**
+ * Builder for update expression in DynamoDB update command
+ *
+ * @example
+ * ```typescript
+ * const builder = new UpdateCommandBuilder("table", { key: "value" })
+ *
+ * builder.setAttributeValue("message", "hello")
+ * builder.addValueToAttribute("count", 1)
+ *
+ * const command = new UpdateCommand(builder.buildCommandInput())
+ * await documentClient.client.send(command)
+ * ```
+ */
+export declare class UpdateCommandBuilder<T extends Record<string, unknown>> extends CommandBuilder<T> {
+    private setExpressions;
+    private removeExpressions;
+    private addExpressions;
+    private conditionExpressions;
+    private updateParams;
+    constructor(tableName: string, key: UpdateCommandInput["Key"], options?: Partial<UpdateCommandInput>);
+    /**
+     * Set value of an attribute
+     */
+    setAttributeValue(attr: keyof T, value: unknown, options?: UpdateCommandOptions): this;
+    /**
+     * Delete attribute
+     */
+    removeAttribute(attr: keyof T): this;
+    /**
+     * Set values for many attributes based on object with attributes as properties
+     */
+    setAttributesValues(obj: Partial<Record<keyof T, unknown>>, options?: UpdateCommandOptions): this;
+    /**
+     * Add numeric value to attribute.
+     * Note: if attribute has no value, DynamoDB assumes value to be zero.
+     */
+    addValueToAttribute(attr: keyof T, value: number): this;
+    /**
+     * Create condition that an attribute exist
+     */
+    ifAttributeExists(attr: keyof T): this;
+    /**
+     * Create condition that an attribute does not exist
+     */
+    ifAttributeNotExists(attr: keyof T): this;
+    addCondition<K extends keyof T, O extends ConditionOperator>(attr: K, operator: O, value: O extends "IN" ? T[K][] : T[K], options?: {
+        not?: boolean;
+    }): this;
+    /**
+     * Add listAppend method to UpdateCommandBuilder class that appends a value to a list attribute in DynamoDB.
+     */
+    listAppend<K extends keyof T>(attr: K, value: T[K]): this;
+    buildCommandInput(): UpdateCommandInput;
+}

package/dist/dynamodb/update-command-builder.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateCommandBuilder = void 0;
+const command_builder_1 = require("./command-builder");
+const assert_1 = __importDefault(require("assert"));
+/**
+ * Builder for update expression in DynamoDB update command
+ *
+ * @example
+ * ```typescript
+ * const builder = new UpdateCommandBuilder("table", { key: "value" })
+ *
+ * builder.setAttributeValue("message", "hello")
+ * builder.addValueToAttribute("count", 1)
+ *
+ * const command = new UpdateCommand(builder.buildCommandInput())
+ * await documentClient.client.send(command)
+ * ```
+ */
+class UpdateCommandBuilder extends command_builder_1.CommandBuilder {
+    setExpressions = [];
+    removeExpressions = [];
+    addExpressions = [];
+    conditionExpressions = [];
+    updateParams;
+    constructor(tableName, key, options = {}) {
+        super();
+        this.updateParams = {
+            ...options,
+            TableName: tableName,
+            Key: key,
+        };
+    }
+    /**
+     * Set value of an attribute
+     */
+    setAttributeValue(attr, value, options = {}) {
+        const { attrName, valueName } = this.createAttributeNameAndValue(attr, value);
+        const expression = options.ifNotExists
+            ? `${attrName} = if_not_exists(${attrName}, ${valueName})`
+            : `${attrName} = ${valueName}`;
+        this.setExpressions.push(expression);
+        return this;
+    }
+    /**
+     * Delete attribute
+     */
+    removeAttribute(attr) {
+        const attrName = this.createAttributeName(attr);
+        this.removeExpressions.push(attrName);
+        return this;
+    }
+    /**
+     * Set values for many attributes based on object with attributes as properties
+     */
+    setAttributesValues(obj, options = {}) {
+        Object.entries(obj).forEach(([key, value]) => this.setAttributeValue(key, value, options));
+        return this;
+    }
+    /**
+     * Add numeric value to attribute.
+     * Note: if attribute has no value, DynamoDB assumes value to be zero.
+     */
+    addValueToAttribute(attr, value) {
+        const { attrName, valueName } = this.createAttributeNameAndValue(attr, value);
+        const expression = `${attrName} ${valueName}`;
+        this.addExpressions.push(expression);
+        return this;
+    }
+    /**
+     * Create condition that an attribute exist
+     */
+    ifAttributeExists(attr) {
+        const attrName = this.createAttributeName(attr);
+        this.conditionExpressions.push(`attribute_exists(${attrName})`);
+        return this;
+    }
+    /**
+     * Create condition that an attribute does not exist
+     */
+    ifAttributeNotExists(attr) {
+        const attrName = this.createAttributeName(attr);
+        this.conditionExpressions.push(`attribute_not_exists(${attrName})`);
+        return this;
+    }
+    addCondition(attr, operator, value, options = {}) {
+        // See https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Syntax
+        if (operator === "IN") {
+            (0, assert_1.default)(typeof attr === "string", "Invalid condition attribute, expected string");
+            (0, assert_1.default)(Array.isArray(value), "Invalid condition value, expected array");
+            const attrName = this.createAttributeName(attr);
+            const valueNames = value.map((val) => this.createAttributeValue(attr, val));
+            const condition = `${attrName} IN (${valueNames.join(", ")})`;
+            const expression = options.not ? `NOT (${condition})` : condition;
+            this.conditionExpressions.push(expression);
+        }
+        else {
+            const { attrName, valueName } = this.createAttributeNameAndValue(attr, value);
+            const condition = `${attrName} ${operator} ${valueName}`;
+            const expression = options.not ? `NOT (${condition})` : condition;
+            this.conditionExpressions.push(expression);
+        }
+        return this;
+    }
+    /**
+     * Add listAppend method to UpdateCommandBuilder class that appends a value to a list attribute in DynamoDB.
+     */
+    listAppend(attr, value) {
+        const { attrName, valueName } = this.createAttributeNameAndValue(attr, value);
+        const expression = `${attrName} = list_append(${attrName}, ${valueName})`;
+        this.setExpressions.push(expression);
+        return this;
+    }
+    buildCommandInput() {
+        let expression = "";
+        if (this.setExpressions.length > 0) {
+            expression += `SET ${this.setExpressions.join(", ")} `;
+        }
+        if (this.removeExpressions.length > 0) {
+            expression += `REMOVE ${this.removeExpressions.join(", ")} `;
+        }
+        if (this.addExpressions.length > 0) {
+            expression += `ADD ${this.addExpressions.join(", ")} `;
+        }
+        let condition;
+        if (this.conditionExpressions.length > 0) {
+            condition = this.conditionExpressions.join(" AND ");
+        }
+        return {
+            ...this.updateParams,
+            UpdateExpression: expression,
+            ExpressionAttributeNames: this.expressionAttributeNames,
+            ExpressionAttributeValues: this.expressionAttributeValues,
+            ...(condition && { ConditionExpression: condition }),
+        };
+    }
+}
+exports.UpdateCommandBuilder = UpdateCommandBuilder;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./common/logger-interface";
+export * from "./dynamodb/default-table-fields";
+export * from "./dynamodb/get-many";
+export * from "./dynamodb/query-command-builder";
+export * from "./dynamodb/query-iterator";
+export * from "./dynamodb/iterators";
+export * from "./dynamodb/update-command-builder";
+export * from "./streams/stream-handler";
+export * from "./utils/compound-key";
+export * from "./utils/create-ttl";
+export * from "./utils/date-time";

package/dist/index.js

@@ -0,0 +1,27 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./common/logger-interface"), exports);
+__exportStar(require("./dynamodb/default-table-fields"), exports);
+__exportStar(require("./dynamodb/get-many"), exports);
+__exportStar(require("./dynamodb/query-command-builder"), exports);
+__exportStar(require("./dynamodb/query-iterator"), exports);
+__exportStar(require("./dynamodb/iterators"), exports);
+__exportStar(require("./dynamodb/update-command-builder"), exports);
+__exportStar(require("./streams/stream-handler"), exports);
+__exportStar(require("./utils/compound-key"), exports);
+__exportStar(require("./utils/create-ttl"), exports);
+__exportStar(require("./utils/date-time"), exports);

package/dist/streams/stream-handler.d.ts

@@ -0,0 +1,70 @@
+import type { Context, DynamoDBRecord, DynamoDBStreamEvent } from "aws-lambda";
+import { ILogger } from "../common/logger-interface";
+import { DynamoDBPersistenceLayer } from "@aws-lambda-powertools/idempotency/dynamodb";
+import { BasePersistenceLayer } from "@aws-lambda-powertools/idempotency/persistence";
+import { DynamoDBPersistenceOptions, IdempotencyConfigOptions } from "@aws-lambda-powertools/idempotency/types";
+/**
+ * Create standard Lambda handler for DynamoDB Stream events
+ *
+ * @examples
+ * ```ts
+ * const handler = createDynamoDbStreamHandler<TableRecord>(
+ *   onInsert: (record) => handleInsert(record),
+ *   // ...
+ * })
+ * ```
+ */
+export declare function createDynamoDbStreamHandler<T>(options: DynamoDbStreamHandlerOptions<T>): (event: DynamoDBStreamEvent, context: Context) => Promise<void>;
+export type DynamoDbStreamHandlerOptions<T> = {
+    /** Handle insertion of an item into DynamoDB table */
+    onInsert?: (item: T) => Promise<void>;
+    /** Handle update of an item into DynamoDB table */
+    onModify?: (oldItem: T, newItem: T) => Promise<void>;
+    /** Handle removal of an item into DynamoDB table */
+    onRemove?: (item: T) => Promise<void>;
+    /**
+     * Handle errors in onInsert, onModify and onRemove handlers.
+     * If not used then error is thrown
+     * Note: when used onError handler the idempotency management will prevent retry on the same record!
+     */
+    onError?: (record: DynamoDBRecord, error: unknown) => Promise<void | unknown> | void | unknown;
+    /**
+     * Logger instance
+     */
+    logger?: ILogger;
+    /**
+     * Optional store for idempotency handling using @aws-lambda-powertools/idempotency
+     * If not specified then idempotency is not managed.
+     */
+    idempotencyPersistanceStore?: BasePersistenceLayer;
+    /**
+     * Optional configuration for idempotency
+     */
+    idempotencyConfig?: IdempotencyConfigOptions;
+    /**
+     * Process batch items concurrently. Default is false, i.e. sequentially
+     * Should not be used if the processing order if items is important.
+     */
+    concurrentBatchProcessing?: boolean;
+    /**
+     * If exception is handled by onError then the exception is
+     */
+    consumeHandledExceptions?: boolean;
+    /**
+     * Enable logging of incoming events, default is true
+     */
+    logEvents?: boolean;
+};
+/**
+ * Helper to create DynamoDB persistance store to keep idempotency records.
+ *
+ * @example
+ *
+ * ```ts
+ * createDefaultIdempotencyPersistanceStore({
+ *   tableName: "MyIdempotencyTable", // Default is process.env.IDEMPOTENCY_TABLE
+ *   awsSdkV3Client: myDynamoDBClient, // Default is a new instance of DynamoDb client
+ * })
+ * ```
+ */
+export declare function createDefaultIdempotencyPersistanceStore(config?: Partial<DynamoDBPersistenceOptions>): DynamoDBPersistenceLayer;

package/dist/streams/stream-handler.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDynamoDbStreamHandler = createDynamoDbStreamHandler;
+exports.createDefaultIdempotencyPersistanceStore = createDefaultIdempotencyPersistanceStore;
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const logger_1 = require("../common/logger");
+const dynamodb_1 = require("@aws-lambda-powertools/idempotency/dynamodb");
+const idempotency_1 = require("@aws-lambda-powertools/idempotency");
+const assert_1 = __importDefault(require("assert"));
+/**
+ * Create standard Lambda handler for DynamoDB Stream events
+ *
+ * @examples
+ * ```ts
+ * const handler = createDynamoDbStreamHandler<TableRecord>(
+ *   onInsert: (record) => handleInsert(record),
+ *   // ...
+ * })
+ * ```
+ */
+function createDynamoDbStreamHandler(options) {
+    const { logger = logger_1.logger, idempotencyPersistanceStore, idempotencyConfig = {}, logEvents = true, } = options;
+    /*
+     * Enable idempotency if persistance store is defined
+     */
+    const enableIdempotency = idempotencyPersistanceStore !== undefined;
+    /*
+     * Configuration for powertools idempotency helper
+     */
+    const config = new idempotency_1.IdempotencyConfig({
+        eventKeyJmesPath: "eventID", // JMES path to idempotency key, see https://jmespath.org/
+        throwOnNoIdempotencyKey: true,
+        ...idempotencyConfig,
+    });
+    /**
+     * Wrap handler with idempotency layer
+     */
+    const idempotencyWrapper = (handler) => {
+        if (enableIdempotency) {
+            return (0, idempotency_1.makeIdempotent)(handler, {
+                persistenceStore: idempotencyPersistanceStore,
+                config,
+            });
+        }
+        return handler;
+    };
+    /**
+     * Handlers for insert / modify / remove events
+     */
+    const handleInsert = idempotencyWrapper(async (record) => {
+        (0, assert_1.default)(options.onInsert);
+        assertImage(record.dynamodb?.NewImage);
+        await options.onInsert((0, util_dynamodb_1.unmarshall)(record.dynamodb?.NewImage));
+        return `INSERT eventID=${record.eventID}`; // Idempotency handler expect handler to return some value which is then stored in persistance store
+    });
+    const handleModify = idempotencyWrapper(async (record) => {
+        (0, assert_1.default)(options.onModify);
+        assertImage(record.dynamodb?.OldImage);
+        assertImage(record.dynamodb?.NewImage);
+        await options.onModify((0, util_dynamodb_1.unmarshall)(record.dynamodb?.OldImage), (0, util_dynamodb_1.unmarshall)(record.dynamodb?.NewImage));
+        return `MODIFY eventID=${record.eventID}`; // Idempotency handler expect handler to return some value which is then stored in persistance store
+    });
+    const handleRemove = idempotencyWrapper(async (record) => {
+        (0, assert_1.default)(options.onRemove);
+        assertImage(record.dynamodb?.OldImage);
+        await options.onRemove((0, util_dynamodb_1.unmarshall)(record.dynamodb?.OldImage));
+        return `REMOVE eventID=${record.eventID}`; // Idempotency handler expect handler to return some value which is then stored in persistance store
+    });
+    /*
+     * Dispatch event to appropriate handler
+     */
+    const dispatchEventToHandler = async (record) => {
+        try {
+            switch (record.eventName) {
+                case "INSERT":
+                    if (options.onInsert)
+                        await handleInsert(record);
+                    break;
+                case "MODIFY":
+                    if (options.onModify)
+                        await handleModify(record);
+                    break;
+                case "REMOVE":
+                    if (options.onRemove)
+                        await handleRemove(record);
+                    break;
+                default:
+                    throw new Error(`Event ${record.eventName} not expected`);
+            }
+        }
+        catch (error) {
+            if (options.onError) {
+                // onError can be either synchronous or asynchronous
+                await options.onError(record, error);
+                // Ignore error if consumeHandledExceptions is true
+                if (options.consumeHandledExceptions) {
+                    return "ERROR"; // Idempotency handler from powertools expect that handler returns some result
+                }
+            }
+            throw error;
+        }
+    };
+    /*
+     * Lambda function handler managing DynamoDB stream events
+     */
+    const lambdaHandler = async (event, context) => {
+        if (logEvents)
+            logger.info("Incoming event", { batchSize: event?.Records.length, event });
+        /*
+         * Idempotency handler is using context to get Lambda timeout
+         */
+        config.registerLambdaContext(context);
+        if (options.concurrentBatchProcessing) {
+            /*
+             * Process batch concurrently, try to process all items before reporting an error
+             */
+            const settled = await Promise.allSettled(event.Records.map((record) => dispatchEventToHandler(record)));
+            if (settled.some((result) => result.status === "rejected")) {
+                throw new Error("Some batch items failed");
+            }
+        }
+        else {
+            /*
+             * Process batch sequentially, breaks on first error
+             */
+            for (const record of event.Records) {
+                await dispatchEventToHandler(record);
+            }
+        }
+    };
+    return lambdaHandler;
+}
+/**
+ * Helper to create DynamoDB persistance store to keep idempotency records.
+ *
+ * @example
+ *
+ * ```ts
+ * createDefaultIdempotencyPersistanceStore({
+ *   tableName: "MyIdempotencyTable", // Default is process.env.IDEMPOTENCY_TABLE
+ *   awsSdkV3Client: myDynamoDBClient, // Default is a new instance of DynamoDb client
+ * })
+ * ```
+ */
+function createDefaultIdempotencyPersistanceStore(config = {}) {
+    const { tableName = process.env.IDEMPOTENCY_TABLE } = config;
+    if (!tableName)
+        throw new Error("createDefaultIdempotencyPersistanceStore: invalid table name, use options or env IDEMPOTENCY_TABLE");
+    return new dynamodb_1.DynamoDBPersistenceLayer({
+        tableName,
+        ...config,
+    });
+}
+/**
+ * Check DynamoDB Stream record and cast it to proper type for unmarshall function
+ */
+function assertImage(value) {
+    if (value === null || typeof value !== "object") {
+        throw new Error("Invalid image in DynamoDB Stream record ");
+    }
+}

package/dist/tsconfig.build.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/index.ts","../src/common/logger-interface.ts","../src/common/logger.ts","../src/dynamodb/command-builder.ts","../src/dynamodb/default-table-fields.ts","../src/dynamodb/get-many.ts","../src/dynamodb/iterators.ts","../src/dynamodb/query-command-builder.ts","../src/dynamodb/query-iterator.ts","../src/dynamodb/update-command-builder.ts","../src/streams/stream-handler.ts","../src/utils/compound-key.ts","../src/utils/create-ttl.ts","../src/utils/date-time.ts"],"version":"5.9.3"}

package/dist/utils/compound-key.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Create compound key from object
+ */
+export declare function createCompoundKey(key: Record<string, string>): string;
+/**
+ * Parse compound key into an object
+ */
+export declare function parseCompoundKey<K extends string>(compoundKey: string, keys: K[]): {
+    [index in K]: string;
+};

package/dist/utils/compound-key.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Create compound key from object
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompoundKey = createCompoundKey;
+exports.parseCompoundKey = parseCompoundKey;
+function createCompoundKey(key) {
+    return Object.values(key).join("#");
+}
+/**
+ * Parse compound key into an object
+ */
+function parseCompoundKey(compoundKey, keys) {
+    const parts = compoundKey.split("#");
+    if (parts.length !== keys.length) {
+        throw new Error(`Cannot parse compound key "${compoundKey}", expected ${keys.length} elements got ${parts.length}.`);
+    }
+    return Object.fromEntries(keys.map((key, index) => [key, parts[index]]));
+}

package/dist/utils/create-ttl.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Create AWS TTL value
+ */
+export declare function createTTL(ttl: TTLValue | null): number | null;
+export type TTLValue = {
+    days?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+};

package/dist/utils/create-ttl.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * Create AWS TTL value
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTTL = createTTL;
+function createTTL(ttl) {
+    if (ttl === null)
+        return null;
+    const ttlSeconds = ((ttl.days || 0) * 24 + (ttl.hours || 0)) * 3600 +
+        (ttl.minutes || 0) * 60 +
+        (ttl.seconds || 0);
+    return Math.floor(Date.now() / 1000) + ttlSeconds;
+}

package/dist/utils/date-time.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Create current date and time in default ISO format.
+ * Default format is supposed to be used to store dates in DynamoDB tables.
+ */
+export declare function getCurrentDateTimeISO(options?: {
+    offsetMilliseconds?: number;
+}): string;

package/dist/utils/date-time.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Create current date and time in default ISO format.
+ * Default format is supposed to be used to store dates in DynamoDB tables.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrentDateTimeISO = getCurrentDateTimeISO;
+function getCurrentDateTimeISO(options = {}) {
+    if (options.offsetMilliseconds) {
+        const now = Date.now() + options.offsetMilliseconds;
+        return new Date(now).toISOString();
+    }
+    else {
+        return new Date().toISOString();
+    }
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@tomassabol/dynamodb-tools",
+  "version": "1.0.19",
+  "description": "Tools for working with DynamoDB using AWS SDK v3",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build-doc": "typedoc",
+    "build": "tsc -b tsconfig.build.json",
+    "clean": "rimraf dist/",
+    "format-check": "prettier --check .",
+    "husky-install": "husky install",
+    "lint": "eslint . --max-warnings 0",
+    "open-coverage": "open .coverage/lcov-report/index.html",
+    "prepare": "npm-run-all husky-install lint clean build",
+    "test": "jest"
+  },
+  "dependencies": {
+    "@aws-lambda-powertools/idempotency": "^2.28.1",
+    "@aws-sdk/lib-dynamodb": "^3.914.0",
+    "@aws-sdk/util-dynamodb": "^3.914.0"
+  },
+  "devDependencies": {
+    "@tsconfig/node22": "^22.0.2",
+    "@types/aws-lambda": "^8.10.114",
+    "@types/jest": "^29.4.0",
+    "@types/node": "^22.18.12",
+    "@typescript-eslint/eslint-plugin": "^5.25.0",
+    "@typescript-eslint/parser": "^5.25.0",
+    "aws-lambda": "^1.0.7",
+    "esbuild-jest": "^0.4.0",
+    "eslint": "^8.11.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-import": "^2.25.4",
+    "eslint-plugin-json": "^3.1.0",
+    "eslint-plugin-markdown": "^3.0.0",
+    "husky": "^8.0.1",
+    "jest": "^29.4.3",
+    "jest-cli": "^29.4.3",
+    "jest-sonar-reporter": "^2.0.0",
+    "lint-staged": "^13.1.2",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^2.6.2",
+    "prettier-plugin-sh": "^0.12.8",
+    "rimraf": "^4.1.2",
+    "typedoc": "^0.23.28",
+    "typedoc-plugin-markdown": "^3.14.0",
+    "typescript": "^5.9.3"
+  },
+  "jestSonar": {
+    "reportPath": ".sonar",
+    "reportFile": "test-report.xml"
+  }
+}