quidproquo-actionprocessor-awslambda 0.0.253 → 0.0.255

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

@@ -1,185 +1,185 @@
-import { KvsLogicalOperatorType, KvsQueryOperationType, } from 'quidproquo-core';
-import crypto from 'crypto';
-// 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;
-};
+import { KvsLogicalOperatorType, KvsQueryOperationType, } from 'quidproquo-core';
+import crypto from 'crypto';
+// 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

@@ -1,12 +1,12 @@
-import { KvsUpdate, KvsUpdateActionType } from 'quidproquo-core';
-import { AttributeValue } from '@aws-sdk/client-dynamodb';
-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 {};
+import { KvsUpdate, KvsUpdateActionType } from 'quidproquo-core';
+import { AttributeValue } from '@aws-sdk/client-dynamodb';
+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

@@ -1,118 +1,118 @@
-import { KvsUpdateActionType } from 'quidproquo-core';
-import { buildAttributeValue, getItemName, getValueName } 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;
-};
+import { KvsUpdateActionType } from 'quidproquo-core';
+import { buildAttributeValue, getItemName, getValueName } 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

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