quidproquo-actionprocessor-awslambda 0.0.198 → 0.0.200

package/lib/esm/logic/dynamo/deleteItem.d.ts

@@ -0,0 +1,2 @@
+import { KvsCoreDataType } from 'quidproquo-core';
+export declare function deleteItem(tableName: string, region: string, key: KvsCoreDataType, keyName: string, sortKey?: KvsCoreDataType, sortKeyName?: string): Promise<void>;

package/lib/esm/logic/dynamo/deleteItem.js

@@ -0,0 +1,16 @@
+import { DynamoDBClient, DeleteItemCommand, } from '@aws-sdk/client-dynamodb';
+import { buildAttributeValue } from './qpqDynamoOrm';
+import { createAwsClient } from '../createAwsClient';
+export async function deleteItem(tableName, region, key, keyName, sortKey, sortKeyName) {
+    const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
+    const deleteItemParams = {
+        TableName: tableName,
+        Key: {
+            [keyName]: buildAttributeValue(key),
+        },
+    };
+    if (sortKey && sortKeyName) {
+        deleteItemParams.Key[sortKeyName] = buildAttributeValue(sortKey);
+    }
+    await dynamoDBClient.send(new DeleteItemCommand(deleteItemParams));
+}

package/lib/esm/logic/dynamo/getAllItems.d.ts

@@ -0,0 +1 @@
+export declare function getAllItems(tableName: string, region: string): Promise<any[]>;

package/lib/esm/logic/dynamo/getAllItems.js

@@ -0,0 +1,23 @@
+import { DynamoDBClient, ScanCommand } from '@aws-sdk/client-dynamodb';
+import { createAwsClient } from '../createAwsClient';
+export async function getAllItems(tableName, region) {
+    const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
+    let records = [];
+    let lastEvaluatedKey;
+    do {
+        const scanParams = {
+            TableName: tableName,
+            ExclusiveStartKey: lastEvaluatedKey,
+        };
+        try {
+            const result = await dynamoDBClient.send(new ScanCommand(scanParams));
+            records = records.concat(result.Items);
+            lastEvaluatedKey = result.LastEvaluatedKey;
+        }
+        catch (error) {
+            console.error('Error scanning DynamoDB table:', error);
+            throw error;
+        }
+    } while (lastEvaluatedKey);
+    return records;
+}

package/lib/esm/logic/dynamo/getItem.d.ts

@@ -0,0 +1 @@
+export declare function getItem(tableName: string, key: string, region: string): Promise<any | null>;

package/lib/esm/logic/dynamo/getItem.js

@@ -0,0 +1,21 @@
+import { DynamoDBClient, GetItemCommand } from '@aws-sdk/client-dynamodb';
+import { createAwsClient } from '../createAwsClient';
+export async function getItem(tableName, key, region) {
+    const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
+    const getItemParams = {
+        TableName: tableName,
+        Key: {
+            key: {
+                S: key,
+            },
+        },
+    };
+    try {
+        const result = await dynamoDBClient.send(new GetItemCommand(getItemParams));
+        return result.Item ? JSON.parse(result.Item.value.S) : null;
+    }
+    catch (error) {
+        console.error('Error getting item from DynamoDB:', error);
+        throw error;
+    }
+}

package/lib/esm/logic/dynamo/getLogByCorrelation.d.ts

@@ -0,0 +1,2 @@
+import { StoryResultMetadata } from 'quidproquo-core';
+export declare function getLogByCorrelation(tableName: string, region: string, correlation: string): Promise<StoryResultMetadata>;

package/lib/esm/logic/dynamo/getLogByCorrelation.js

@@ -0,0 +1,39 @@
+import { DynamoDBClient, QueryCommand } from '@aws-sdk/client-dynamodb';
+import { createAwsClient } from '../createAwsClient';
+export async function getLogByCorrelation(tableName, region, correlation) {
+    const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
+    const queryParams = {
+        TableName: tableName,
+        IndexName: 'CorrelationIndex',
+        KeyConditionExpression: 'correlation = :correlation',
+        ExpressionAttributeValues: {
+            ':correlation': { S: correlation },
+        },
+    };
+    try {
+        const queryResult = await dynamoDBClient.send(new QueryCommand(queryParams));
+        const items = (queryResult.Items || []).map((i) => {
+            const [startedAt, correlation] = i.startedAtWithCorrelation.S?.split('#') || [];
+            const metaData = {
+                generic: i.generic.S || '',
+                runtimeType: i.runtimeType.S,
+                error: i.error?.S,
+                startedAt: startedAt,
+                correlation,
+                moduleName: i.moduleName.S || '',
+                fromCorrelation: i.fromCorrelation?.S,
+                executionTimeMs: i.executionTimeMs?.N ? parseInt(i.executionTimeMs.N) : 0,
+            };
+            return metaData;
+        });
+        const [result] = items;
+        if (!result) {
+            throw new Error(`Failed to find log with correlation: ${correlation}`);
+        }
+        return result;
+    }
+    catch (err) {
+        console.error(`Failed to find log: ${err}`);
+        throw err;
+    }
+}

package/lib/esm/logic/dynamo/getLogChildrenByFromCorrelation.d.ts

@@ -0,0 +1,2 @@
+import { QpqLogList } from 'quidproquo-webserver';
+export declare function getLogChildrenByFromCorrelation(tableName: string, region: string, fromCorrelation: string, pageKey?: string): Promise<QpqLogList>;

package/lib/esm/logic/dynamo/getLogChildrenByFromCorrelation.js

@@ -0,0 +1,49 @@
+import { DynamoDBClient, QueryCommand } from '@aws-sdk/client-dynamodb';
+import { lastEvaluatedKeyToString, stringToLastEvaluatedKey } from './logs';
+import { createAwsClient } from '../createAwsClient';
+export async function getLogChildrenByFromCorrelation(tableName, region, fromCorrelation, pageKey) {
+    const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
+    const queryParams = {
+        TableName: tableName,
+        // removed IndexName
+        KeyConditionExpression: '#fromCorrelation = :fromCorrelation',
+        ExpressionAttributeNames: {
+            '#fromCorrelation': 'fromCorrelation', // define attribute name
+        },
+        ExpressionAttributeValues: {
+            ':fromCorrelation': { S: fromCorrelation },
+        },
+    };
+    if (pageKey) {
+        queryParams.ExclusiveStartKey = stringToLastEvaluatedKey(pageKey);
+    }
+    try {
+        const queryResult = await dynamoDBClient.send(new QueryCommand(queryParams));
+        const items = (queryResult.Items || []).map((i) => {
+            const [startedAt, correlation] = i.startedAtWithCorrelation.S?.split('#') || [];
+            const metaData = {
+                generic: i.generic.S || '',
+                runtimeType: i.runtimeType.S,
+                error: i.error?.S,
+                startedAt: startedAt,
+                correlation,
+                moduleName: i.moduleName.S || '',
+                fromCorrelation: i.fromCorrelation?.S,
+                executionTimeMs: i.executionTimeMs?.N ? parseInt(i.executionTimeMs.N) : 0,
+            };
+            return metaData;
+        });
+        if (queryResult.LastEvaluatedKey) {
+            const nextPageKey = lastEvaluatedKeyToString(queryResult.LastEvaluatedKey);
+            // You can return the nextPageKey along with the items, so it can be used for the next query.
+            return { items, nextPageKey };
+        }
+        else {
+            return { items };
+        }
+    }
+    catch (err) {
+        console.error(`Failed to query items with the specified fromCorrelation: ${err}`);
+        throw err;
+    }
+}

package/lib/esm/logic/dynamo/getPagedItemsOverRange.d.ts

@@ -0,0 +1,2 @@
+import { QpqLogList } from 'quidproquo-webserver';
+export declare function getPagedItemsOverRange(tableName: string, region: string, runtimeType: string, startIsoDateTime: string, endIsoDateTime: string, pageKey?: string): Promise<QpqLogList>;

package/lib/esm/logic/dynamo/getPagedItemsOverRange.js

@@ -0,0 +1,48 @@
+import { DynamoDBClient, QueryCommand } from '@aws-sdk/client-dynamodb';
+import { lastEvaluatedKeyToString, stringToLastEvaluatedKey } from './logs';
+import { createAwsClient } from '../createAwsClient';
+export async function getPagedItemsOverRange(tableName, region, runtimeType, startIsoDateTime, endIsoDateTime, pageKey) {
+    const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
+    const queryParams = {
+        TableName: tableName,
+        KeyConditionExpression: 'runtimeType = :runtimeType AND startedAtWithCorrelation BETWEEN :startIsoDateTime AND :endIsoDateTime',
+        ExpressionAttributeValues: {
+            ':runtimeType': { S: runtimeType },
+            ':startIsoDateTime': { S: startIsoDateTime + '#00000000-0000-0000-0000-000000000000' },
+            ':endIsoDateTime': { S: endIsoDateTime + '#ffffffff-ffff-ffff-ffff-ffffffffffff' },
+        },
+        ScanIndexForward: false,
+    };
+    if (pageKey) {
+        queryParams.ExclusiveStartKey = stringToLastEvaluatedKey(pageKey);
+    }
+    try {
+        const queryResult = await dynamoDBClient.send(new QueryCommand(queryParams));
+        const items = (queryResult.Items || []).map((i) => {
+            const [startedAt, correlation] = i.startedAtWithCorrelation.S?.split('#') || [];
+            const metaData = {
+                generic: i.generic.S || '',
+                runtimeType: i.runtimeType.S,
+                error: i.error?.S,
+                startedAt: startedAt,
+                correlation,
+                moduleName: i.moduleName.S || '',
+                fromCorrelation: i.fromCorrelation?.S,
+                executionTimeMs: i.executionTimeMs?.N ? parseInt(i.executionTimeMs.N) : 0,
+            };
+            return metaData;
+        });
+        if (queryResult.LastEvaluatedKey) {
+            const nextPageKey = lastEvaluatedKeyToString(queryResult.LastEvaluatedKey);
+            // You can return the nextPageKey along with the items, so it can be used for the next query.
+            return { items, nextPageKey };
+        }
+        else {
+            return { items };
+        }
+    }
+    catch (err) {
+        console.error(`Failed to query items in the specified date range: ${err}`);
+        throw err;
+    }
+}

package/lib/esm/logic/dynamo/index.d.ts

@@ -0,0 +1,6 @@
+export * from './deleteItem';
+export * from './getAllItems';
+export * from './getItem';
+export * from './putItem';
+export * from './updateItem';
+export * from './query';

package/lib/esm/logic/dynamo/index.js

@@ -0,0 +1,6 @@
+export * from './deleteItem';
+export * from './getAllItems';
+export * from './getItem';
+export * from './putItem';
+export * from './updateItem';
+export * from './query';

package/lib/esm/logic/dynamo/logs/index.d.ts

@@ -0,0 +1 @@
+export * from './utils';

package/lib/esm/logic/dynamo/logs/index.js

@@ -0,0 +1 @@
+export * from './utils';

package/lib/esm/logic/dynamo/logs/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lastEvaluatedKeyToString';
+export * from './stringToLastEvaluatedKey';

package/lib/esm/logic/dynamo/logs/utils/index.js

@@ -0,0 +1,2 @@
+export * from './lastEvaluatedKeyToString';
+export * from './stringToLastEvaluatedKey';

package/lib/esm/logic/dynamo/logs/utils/lastEvaluatedKeyToString.d.ts

@@ -0,0 +1 @@
+export declare function lastEvaluatedKeyToString(lastEvaluatedKey: any): string;

package/lib/esm/logic/dynamo/logs/utils/lastEvaluatedKeyToString.js

@@ -0,0 +1,3 @@
+export function lastEvaluatedKeyToString(lastEvaluatedKey) {
+    return Buffer.from(JSON.stringify(lastEvaluatedKey)).toString('base64');
+}

package/lib/esm/logic/dynamo/logs/utils/stringToLastEvaluatedKey.d.ts

@@ -0,0 +1,2 @@
+import { AttributeValue } from '@aws-sdk/client-dynamodb';
+export declare function stringToLastEvaluatedKey(encodedKey: string): Record<string, AttributeValue>;

package/lib/esm/logic/dynamo/logs/utils/stringToLastEvaluatedKey.js

@@ -0,0 +1,3 @@
+export function stringToLastEvaluatedKey(encodedKey) {
+    return JSON.parse(Buffer.from(encodedKey, 'base64').toString());
+}

package/lib/esm/logic/dynamo/putItem.d.ts

@@ -0,0 +1,5 @@
+import { KvsKey } from 'quidproquo-core';
+export interface PutItemOptions {
+    expires?: number;
+}
+export declare function putItem<Item, T extends object = any>(tableName: string, item: Item, attributes: KvsKey[], options: PutItemOptions, region: string): Promise<void>;

package/lib/esm/logic/dynamo/putItem.js

@@ -0,0 +1,33 @@
+import { DynamoDBClient, PutItemCommand } from '@aws-sdk/client-dynamodb';
+import { buildAttributeValue } from './qpqDynamoOrm';
+import { createAwsClient } from '../createAwsClient';
+// We currently only support objects as root items in dynamo
+// Storing a list (array) as the root of your DynamoDB record is indeed possible,
+// but there are some caveats. One of the main challenges is that DynamoDB doesn't support
+// complex operations on list items. For instance, you can't perform a conditional update or
+// delete on a specific item in the list based on its value. However, you can read and write
+// entire lists, and you can append items to a list with an update operation.
+//
+// TODO?: support lists as root items in dynamo ~ Probably not worth it
+// a root list probably should be a table!
+// Something like this:
+// const convertObjectOrListToDynamoMap = (value: KvsObjectDataType | KvsListDataType): AttributeValue => {
+//   const attributeValue = buildAttributeValue(value);
+//   if ('M' in attributeValue) {
+//     return attributeValue.M!;
+//   }
+//   if ('L' in attributeValue) {
+//     return attributeValue.L!;
+//   }
+//   throw new Error("Value must be an object or a list");
+// }
+const convertObjectToDynamoItem = (obj) => {
+    return buildAttributeValue(obj).M;
+};
+export async function putItem(tableName, item, attributes, options, region) {
+    const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
+    await dynamoDBClient.send(new PutItemCommand({
+        TableName: tableName,
+        Item: convertObjectToDynamoItem(item),
+    }));
+}

package/lib/esm/logic/dynamo/qpqDynamoOrm/buildDynamoQuery.d.ts

@@ -0,0 +1,10 @@
+import { KvsQueryOperation, KvsQueryCondition, KvsLogicalOperator, KvsAdvancedDataType } from 'quidproquo-core';
+import { AttributeValue } from '@aws-sdk/client-dynamodb';
+export declare const getItemName: (name: string) => string;
+export declare const getValueName: (value: KvsAdvancedDataType) => string;
+export declare const isKvsQueryCondition: (query: KvsQueryOperation) => query is KvsQueryCondition;
+export declare const isKvsLogicalOperator: (query: KvsQueryOperation) => query is KvsLogicalOperator;
+export declare const buildAttributeValue: (value: KvsAdvancedDataType) => AttributeValue;
+export declare const buildDynamoQueryExpression: (query?: KvsQueryOperation) => string | undefined;
+export declare const buildExpressionAttributeValues: (queries: (KvsQueryOperation | undefined)[]) => Record<string, AttributeValue> | undefined;
+export declare const buildExpressionAttributeNames: (queries: (KvsQueryOperation | undefined)[]) => Record<string, string> | undefined;

package/lib/esm/logic/dynamo/qpqDynamoOrm/buildDynamoQuery.js

@@ -0,0 +1,187 @@
+import crypto from 'crypto';
+import { KvsQueryOperationType, KvsLogicalOperatorType, } from 'quidproquo-core';
+// TODO: Come up with a better way of generating item name / values
+// probably a map ~ however this will most likely never fail.
+const getHash = (name) => {
+    const c = crypto.createHash('md5').update(name).digest('hex');
+    return c;
+};
+export const getItemName = (name) => {
+    return `#${getHash(name)}`;
+};
+export const getValueName = (value) => {
+    return `:${getHash(`${typeof value}-${JSON.stringify(value)}`)}`;
+};
+const buildDynamoQueryExpressionBetween = (query) => {
+    if (!query.key || !query.valueB || !query.valueB) {
+        throw new Error(`Invalid query condition ${KvsQueryOperationType.Between}`);
+    }
+    return `${getItemName(query.key)} BETWEEN ${getValueName(query.valueA)} AND ${getValueName(query.valueB)}`;
+};
+const buildDynamoQueryExpressionEqual = (query) => {
+    return `${getItemName(query.key)} = ${getValueName(query.valueA)}`;
+};
+const buildDynamoQueryExpressionNotEqual = (query) => {
+    return `${getItemName(query.key)} <> ${getValueName(query.valueA)}`;
+};
+const buildDynamoQueryExpressionLessThan = (query) => {
+    return `${getItemName(query.key)} < ${getValueName(query.valueA)}`;
+};
+const buildDynamoQueryExpressionLessThanOrEqual = (query) => {
+    return `${getItemName(query.key)} <= ${getValueName(query.valueA)}`;
+};
+const buildDynamoQueryExpressionGreaterThan = (query) => {
+    return `${getItemName(query.key)} > ${getValueName(query.valueA)}`;
+};
+const buildDynamoQueryExpressionGreaterThanOrEqual = (query) => {
+    return `${getItemName(query.key)} >= ${getValueName(query.valueA)}`;
+};
+const buildDynamoQueryExpressionIn = (query) => {
+    return `${getItemName(query.key)} IN (${query.valueA
+        .map((v) => getValueName(v))
+        .join(', ')})`;
+};
+const buildDynamoQueryExpressionExists = (query) => {
+    return `attribute_exists(${getItemName(query.key)})`;
+};
+const buildDynamoQueryExpressionNotExists = (query) => {
+    return `attribute_not_exists(${getItemName(query.key)})`;
+};
+const buildDynamoQueryExpressionBeginsWith = (query) => {
+    return `begins_with(${getItemName(query.key)}, ${getValueName(query.valueA)})`;
+};
+const buildDynamoQueryExpressionContains = (query) => {
+    return `contains(${getItemName(query.key)}, ${getValueName(query.valueA)})`;
+};
+const buildDynamoQueryExpressionNotContains = (query) => {
+    return `NOT contains(${getItemName(query.key)}, ${getValueName(query.valueA)})`;
+};
+const buildDynamoQueryExpressionOr = (query) => {
+    return query.conditions.map((c) => `(${buildDynamoQueryExpressionRoot(c)})`).join(' OR ');
+};
+const buildDynamoQueryExpressionAnd = (query) => {
+    return query.conditions.map((c) => `(${buildDynamoQueryExpressionRoot(c)})`).join(' AND ');
+};
+export const isKvsQueryCondition = (query) => {
+    return 'key' in query && 'operation' in query;
+};
+export const isKvsLogicalOperator = (query) => {
+    return 'conditions' in query && 'operation' in query;
+};
+const buildDynamoQueryExpressionRoot = (query) => {
+    if (isKvsQueryCondition(query)) {
+        switch (query.operation) {
+            case KvsQueryOperationType.Equal:
+                return buildDynamoQueryExpressionEqual(query);
+            case KvsQueryOperationType.NotEqual:
+                return buildDynamoQueryExpressionNotEqual(query);
+            case KvsQueryOperationType.LessThan:
+                return buildDynamoQueryExpressionLessThan(query);
+            case KvsQueryOperationType.LessThanOrEqual:
+                return buildDynamoQueryExpressionLessThanOrEqual(query);
+            case KvsQueryOperationType.GreaterThan:
+                return buildDynamoQueryExpressionGreaterThan(query);
+            case KvsQueryOperationType.GreaterThanOrEqual:
+                return buildDynamoQueryExpressionGreaterThanOrEqual(query);
+            case KvsQueryOperationType.Between:
+                return buildDynamoQueryExpressionBetween(query);
+            case KvsQueryOperationType.In:
+                return buildDynamoQueryExpressionIn(query);
+            case KvsQueryOperationType.Exists:
+                return buildDynamoQueryExpressionExists(query);
+            case KvsQueryOperationType.NotExists:
+                return buildDynamoQueryExpressionNotExists(query);
+            case KvsQueryOperationType.BeginsWith:
+                return buildDynamoQueryExpressionBeginsWith(query);
+            case KvsQueryOperationType.Contains:
+                return buildDynamoQueryExpressionContains(query);
+            case KvsQueryOperationType.NotContains:
+                return buildDynamoQueryExpressionNotContains(query);
+        }
+    }
+    else if (isKvsLogicalOperator(query)) {
+        switch (query.operation) {
+            case KvsLogicalOperatorType.And:
+                return buildDynamoQueryExpressionAnd(query);
+            case KvsLogicalOperatorType.Or:
+                return buildDynamoQueryExpressionOr(query);
+        }
+    }
+    throw new Error(`Invalid query operation: ${JSON.stringify(query)}`);
+};
+export const buildAttributeValue = (value) => {
+    const valueType = typeof value;
+    switch (valueType) {
+        case 'string':
+            return { S: value };
+        case 'number':
+            return { N: value.toString() };
+        case 'boolean':
+            return { BOOL: value };
+        case 'object':
+            if (Array.isArray(value)) {
+                return {
+                    L: value.map((item) => buildAttributeValue(item)),
+                };
+            }
+            else if (value !== null) {
+                const objectKeyValuePairs = Object.entries(value)
+                    .filter(([k, v]) => v !== undefined)
+                    .map(([k, v]) => {
+                    return [k, buildAttributeValue(v)];
+                });
+                return {
+                    M: Object.fromEntries(objectKeyValuePairs),
+                };
+            }
+            else {
+                return { NULL: true };
+            }
+        default:
+            throw new Error(`Unsupported data type in kvs expression: ${valueType}`);
+    }
+};
+export const buildDynamoQueryExpression = (query) => {
+    if (!query) {
+        return undefined;
+    }
+    return buildDynamoQueryExpressionRoot(query);
+};
+export const buildExpressionAttributeValues = (queries) => {
+    const values = {};
+    const traverse = (query) => {
+        if (isKvsQueryCondition(query)) {
+            if (query.valueA !== undefined) {
+                const valueNameA = getValueName(query.valueA);
+                values[valueNameA] = buildAttributeValue(query.valueA);
+            }
+            if (query.valueB !== undefined) {
+                const valueNameB = getValueName(query.valueB);
+                values[valueNameB] = buildAttributeValue(query.valueB);
+            }
+        }
+        else if (isKvsLogicalOperator(query)) {
+            for (const condition of query.conditions) {
+                traverse(condition);
+            }
+        }
+    };
+    queries.filter((q) => !!q).forEach((q) => traverse(q));
+    return Object.keys(values).length > 0 ? values : undefined;
+};
+export const buildExpressionAttributeNames = (queries) => {
+    const names = {};
+    const traverse = (query) => {
+        if (isKvsQueryCondition(query)) {
+            const itemName = getItemName(query.key);
+            names[itemName] = query.key;
+        }
+        else if (isKvsLogicalOperator(query)) {
+            for (const condition of query.conditions) {
+                traverse(condition);
+            }
+        }
+    };
+    queries.filter((q) => !!q).forEach((q) => traverse(q));
+    return Object.keys(names).length > 0 ? names : undefined;
+};

package/lib/esm/logic/dynamo/qpqDynamoOrm/buildDynamoUpdate.d.ts

@@ -0,0 +1,12 @@
+import { AttributeValue } from '@aws-sdk/client-dynamodb';
+import { KvsUpdateActionType, KvsUpdate } from 'quidproquo-core';
+interface ExpressionAttributeNameMap {
+    [key: string]: string;
+}
+export declare const buildUpdateExpressionAttributeNames: (updates: KvsUpdate) => ExpressionAttributeNameMap;
+export declare const buildUpdateExpressionAttributeValues: (updates: KvsUpdate) => {
+    [key: string]: AttributeValue;
+} | undefined;
+export declare const buildDynamoUpdateExpressionForType: (type: KvsUpdateActionType, kvsUpdate: KvsUpdate) => string;
+export declare const buildDynamoUpdateExpression: (updates: KvsUpdate) => string;
+export {};

package/lib/esm/logic/dynamo/qpqDynamoOrm/buildDynamoUpdate.js

@@ -0,0 +1,125 @@
+import { KvsUpdateActionType } from 'quidproquo-core';
+import { getItemName, getValueName, buildAttributeValue } from './buildDynamoQuery';
+export const buildUpdateExpressionAttributeNames = (updates) => {
+    let attributeNames = {};
+    for (let update of updates) {
+        if (Array.isArray(update.attributePath)) {
+            // Handle nested attributes
+            for (let i = 0; i < update.attributePath.length; i++) {
+                let attribute = update.attributePath[i];
+                if (typeof attribute === 'string') {
+                    const itemName = getItemName(attribute);
+                    attributeNames[itemName] = attribute;
+                    // Replace attribute name in path with safe name
+                    update.attributePath[i] = itemName;
+                }
+            }
+        }
+        else {
+            // Handle top-level attributes
+            const itemName = getItemName(update.attributePath);
+            attributeNames[itemName] = update.attributePath;
+            update.attributePath = itemName;
+        }
+    }
+    return attributeNames;
+};
+export const buildUpdateExpressionAttributeValues = (updates) => {
+    let attributeValues = {};
+    for (let update of updates) {
+        if (update.value !== undefined && update.value !== null) {
+            const valuePlaceholder = getValueName(update.value);
+            attributeValues[valuePlaceholder] = buildAttributeValue(update.value);
+        }
+    }
+    return Object.keys(attributeValues).length > 0 ? attributeValues : undefined;
+};
+const buildDynamoUpdateExpressionSet = (update) => {
+    if (update.value === undefined || update.value === null) {
+        throw new Error("Value must be provided for 'SET' action");
+    }
+    return `${getNestedItemName(update.attributePath)} = ${getValueName(update.value)}`;
+};
+const buildDynamoUpdateExpressionRemove = (update) => {
+    return `${getNestedItemName(update.attributePath)}`;
+};
+const buildDynamoUpdateExpressionAdd = (update) => {
+    if (update.value === undefined || update.value === null) {
+        throw new Error("Value must be provided for 'ADD' action");
+    }
+    return `${getNestedItemName(update.attributePath)} ${getValueName(update.value)}`;
+};
+const buildDynamoUpdateExpressionDelete = (update) => {
+    if (update.value !== undefined && update.value !== null) {
+        return `${getNestedItemName(update.attributePath)} ${getValueName(update.value)}`;
+    }
+    else {
+        return `${getNestedItemName(update.attributePath)}`;
+    }
+};
+const getNestedItemName = (attributePath) => {
+    if (Array.isArray(attributePath)) {
+        let path = '';
+        for (let i = 0; i < attributePath.length; i++) {
+            if (typeof attributePath[i] === 'string') {
+                path += `.${getItemName(attributePath[i])}`;
+            }
+            else {
+                path += `[${attributePath[i]}]`;
+            }
+        }
+        return path.substring(1); // remove the leading dot
+    }
+    else {
+        return getItemName(attributePath);
+    }
+};
+const buildDynamoUpdateExpressionPart = (update, updateIndex) => {
+    switch (update.action) {
+        case KvsUpdateActionType.Set:
+            return buildDynamoUpdateExpressionSet(update);
+        case KvsUpdateActionType.Remove:
+            return buildDynamoUpdateExpressionRemove(update);
+        case KvsUpdateActionType.Add:
+            return buildDynamoUpdateExpressionAdd(update);
+        case KvsUpdateActionType.Delete:
+            return buildDynamoUpdateExpressionDelete(update);
+        default:
+            throw new Error(`Invalid update action type: ${update.action}`);
+    }
+};
+export const buildDynamoUpdateExpressionForType = (type, kvsUpdate) => {
+    const actions = kvsUpdate.filter((update) => update.action === type);
+    // If there are no actions of this type, return an empty string
+    if (actions.length === 0) {
+        return '';
+    }
+    const expressions = actions
+        .map((update, index) => buildDynamoUpdateExpressionPart(update, index))
+        .join(', ');
+    switch (type) {
+        case KvsUpdateActionType.Set:
+            return `SET ${expressions}`;
+        case KvsUpdateActionType.Remove:
+            return `REMOVE ${expressions}`;
+        case KvsUpdateActionType.Add:
+            return `ADD ${expressions}`;
+        case KvsUpdateActionType.Delete:
+            return `DELETE ${expressions}`;
+        default:
+            throw new Error(`Invalid update action type: ${type}`);
+    }
+};
+export const buildDynamoUpdateExpression = (updates) => {
+    const updatesExpressions = [
+        KvsUpdateActionType.Set,
+        KvsUpdateActionType.Remove,
+        KvsUpdateActionType.Add,
+        KvsUpdateActionType.Delete,
+    ]
+        .map((kvsUpdateActionType) => buildDynamoUpdateExpressionForType(kvsUpdateActionType, updates))
+        .filter((expression) => !!expression);
+    const result = updatesExpressions.join(' ');
+    console.log('Update Expression: ', result);
+    return result;
+};

package/lib/esm/logic/dynamo/qpqDynamoOrm/getDynamoTableIndexByConfigAndQuery.d.ts

@@ -0,0 +1,2 @@
+import { KeyValueStoreQPQConfigSetting, KvsQueryOperation } from 'quidproquo-core';
+export declare const getDynamoTableIndexByConfigAndQuery: <T extends object = any>(setting: KeyValueStoreQPQConfigSetting, query: KvsQueryOperation) => string | undefined;