electrodb 2.4.1 → 2.5.0

package/src/transaction.js

@@ -0,0 +1,179 @@
+const { TableIndex, TransactionMethods } = require('./types');
+const { getEntityIdentifiers, matchToEntityAlias } = require('./entity');
+
+function cleanseCanceledData(index = TableIndex, entities, data = {}, config = {}) {
+    if (config.raw) {
+        return data;
+    }
+    const identifiers = getEntityIdentifiers(entities);
+    const canceled = data.canceled || [];
+    const paramItems = config._paramItems || [];
+    const results = [];
+    for (let i = 0; i < canceled.length; i++) {
+        const { Item, Code, Message } = canceled[i] || {};
+        const paramItem = paramItems[i];
+        const code = Code || 'None';
+        const rejected = code !== 'None';
+        const result = {
+            rejected,
+            code,
+            message: Message,
+        }
+
+        if (Item) {
+            const entityAlias = matchToEntityAlias({
+                record: Item,
+                paramItem,
+                identifiers
+            });
+            result.item = entities[entityAlias].formatResponse({Item}, index, {
+                ...config,
+                pager: false,
+                parse: undefined,
+            }).data;
+        } else {
+            result.item = null;
+        }
+
+        results.push(result);
+    }
+
+    return results;
+}
+
+function cleanseTransactionData(index = TableIndex, entities, data = {}, config = {}) {
+    if (config.raw) {
+        return data;
+    }
+    const identifiers = getEntityIdentifiers(entities);
+    data.Items = data.Items || [];
+    const paramItems = config._paramItems || [];
+    const results = [];
+    for (let i = 0; i < data.Items.length; i++) {
+        const record = data.Items[i];
+        if (!record) {
+            results.push(null);
+            continue;
+        }
+
+        const paramItem = paramItems[i];
+        const entityAlias = matchToEntityAlias({paramItem, identifiers, record});
+        if (!entityAlias) {
+            continue;
+        }
+
+        // pager=false because we don't want the entity trying to parse the lastEvaluatedKey
+        let formatted = entities[entityAlias].formatResponse({ Item: record }, index, {
+            ...config,
+            pager: false,
+            parse: undefined
+        });
+
+        results.push(formatted.data);
+    }
+
+    return results.map(item => ({
+        rejected: false,
+        item,
+    }));
+}
+
+function createTransaction(options) {
+    const { fn, method, getEntities } = options;
+    const operations = {
+        params: (options = {}) => {
+            const paramItems = fn(getEntities());
+            const params = {
+                TransactItems: paramItems,
+            };
+
+            if (typeof options.token === 'string' && options.token.length) {
+                params['ClientRequestToken'] = options.token;
+            }
+            if (options._returnParamItems) {
+                return { params, paramItems };
+            }
+            return params;
+        },
+        go: async (options) => {
+            const driver = Object.values(getEntities())[0];
+
+            if (!driver) {
+                throw new Error('At least one entity must exist to perform a transaction');
+            }
+
+            const { params, paramItems } = operations.params({
+                ...options,
+                _returnParamItems: true
+            });
+
+            let canceled = false;
+            if (paramItems.length === 0) {
+                return {
+                    canceled,
+                    data: [],
+                }
+            }
+
+            const response = await driver.go(method, params, {
+                ...options,
+                parse: (options, data) => {
+                    if (options.raw) {
+                        return data;
+                    } else if (data.canceled) {
+                        canceled = true;
+                        return cleanseCanceledData(TableIndex, getEntities(), data, {
+                            ...options,
+                            _isTransaction: true,
+                            _paramItems: paramItems,
+                        });
+                    } else if (data.Responses) {
+                        return cleanseTransactionData(TableIndex, getEntities(), {
+                            Items: data.Responses.map(response => response.Item)
+                        }, {
+                            ...options,
+                            _isTransaction: true,
+                            _paramItems: paramItems,
+                        });
+                    } else {
+                        return new Array(paramItems ? paramItems.length : 0).fill({
+                            item: null,
+                            code: 'None',
+                            rejected: false,
+                            message: undefined,
+                        });
+                    }
+                }
+            });
+
+            return {
+                ...response,
+                canceled,
+            }
+        }
+    }
+
+    return operations;
+}
+
+function createWriteTransaction(entities, fn) {
+    return createTransaction({
+        fn,
+        method: TransactionMethods.transactWrite,
+        getEntities: () => entities,
+    });
+}
+
+function createGetTransaction(entities, fn) {
+    return createTransaction({
+        fn,
+        method: TransactionMethods.transactGet,
+        getEntities: () => entities,
+    });
+}
+
+module.exports = {
+    createTransaction,
+    createWriteTransaction,
+    createGetTransaction,
+}

package/src/types.js

@@ -23,6 +23,7 @@ const QueryTypes = {
 };
 
 const MethodTypes = {
+	check: "check",
 	put: "put",
 	get: "get",
 	query: "query",
@@ -35,8 +36,27 @@ const MethodTypes = {
 	batchGet: "batchGet",
 	batchWrite: "batchWrite",
 	upsert: "upsert",
+	transactWrite: "transactWrite",
+	transactGet: "transactGet",
 };
 
+const TransactionMethods = {
+	transactWrite: MethodTypes.transactWrite,
+	transactGet: MethodTypes.transactGet,
+}
+
+const TransactionOperations = {
+	[MethodTypes.get]: "Get",
+	[MethodTypes.check]: "ConditionCheck",
+	[MethodTypes.put]: "Put",
+	[MethodTypes.create]: "Put",
+	[MethodTypes.upsert]: "Update",
+	[MethodTypes.update]: "Update",
+	[MethodTypes.patch]: "Update",
+	[MethodTypes.remove]: "Delete",
+	[MethodTypes.delete]: "Delete",
+}
+
 const MethodTypeTranslation = {
 	put: "put",
 	get: "get",
@@ -50,6 +70,8 @@ const MethodTypeTranslation = {
 	batchGet: "batchGet",
 	batchWrite: "batchWrite",
 	upsert: "update",
+	transactWrite: 'transactWrite',
+	transactGet: 'transactGet',
 }
 
 const IndexTypes = {
@@ -198,6 +220,7 @@ const ItemOperations = {
 };
 
 const AttributeProxySymbol = Symbol("attribute_proxy");
+const TransactionCommitSymbol = Symbol('transaction_commit');
 
 const BuilderTypes = {
 	update: "update",
@@ -325,4 +348,7 @@ module.exports = {
 	AllPages,
 	ResultOrderOption,
 	ResultOrderParam,
+	TransactionCommitSymbol,
+	TransactionOperations,
+	TransactionMethods,
 };

package/src/where.js

@@ -76,6 +76,7 @@ class WhereFactory {
 		case MethodTypes.remove:
 		case MethodTypes.upsert:
 		case MethodTypes.get:
+		case MethodTypes.check:
 			return ExpressionTypes.ConditionExpression
 		default:
 			return ExpressionTypes.FilterExpression
@@ -108,7 +109,7 @@ class WhereFactory {
 		let filterParents = Object.entries(injected)
 			.filter(clause => {
 				let [name, { children }] = clause;
-				return children.includes("go");
+				return children.find(child => ['go', 'commit'].includes(child));
 			})
 			.map(([name]) => name);
 		let modelFilters = Object.keys(filters);
@@ -118,7 +119,7 @@ class WhereFactory {
 			injected[name] = {
 				name,
 				action: this.buildClause(filter),
-				children: ["params", "go", "where", ...modelFilters],
+				children: ["params", "go", "commit", "where", ...modelFilters],
 			};
 		}
 		filterChildren.push("where");
@@ -127,7 +128,7 @@ class WhereFactory {
 			action: (entity, state, fn) => {
 				return this.buildClause(fn)(entity, state);
 			},
-			children: ["params", "go", "where", ...modelFilters],
+			children: ["params", "go", "commit", "where", ...modelFilters],
 		};
 		for (let parent of filterParents) {
 			injected[parent] = { ...injected[parent] };

package/notes

@@ -1,8 +0,0 @@
-- add hydrate option to query
-- add hydrate option to collection
-- implement hydrate on entity query
-- implement hydrate on collection query
-- add index property to signify only keys are present
-    - skip for match/find
-    - do not apply automatic filters on queries
-- validate