electrodb 2.4.1 → 2.5.0

package/src/client.js

@@ -1,12 +1,13 @@
 const lib = require('@aws-sdk/lib-dynamodb')
+const util = require('@aws-sdk/lib-dynamodb/dist-cjs/commands/utils')
 const { isFunction } = require('./validations');
 const { ElectroError, ErrorCodes } = require('./errors');
-
 const DocumentClientVersions = {
     v2: 'v2',
     v3: 'v3',
     electro: 'electro',
 };
+const unmarshallOutput = util.unmarshallOutput || ((val) => val);
 
 const v3Methods = ['send'];
 const v2Methods = ['get', 'put', 'update', 'delete', 'batchWrite', 'batchGet', 'scan', 'query', 'createSet', 'transactWrite', 'transactGet'];
@@ -15,6 +16,99 @@ const supportedClientVersions = {
     [DocumentClientVersions.v3]: v3Methods,
 }
 
+class DocumentClientV2Wrapper {
+    static init(client) {
+        return new DocumentClientV2Wrapper(client, lib);
+    }
+
+    constructor(client, lib) {
+        this.client = client;
+        this.lib = lib;
+        this.__v = 'v2';
+    }
+
+    get(params) {
+        return this.client.get(params);
+    }
+
+    put(params) {
+        return this.client.put(params);
+    }
+
+    update(params) {
+        return this.client.update(params);
+    }
+
+    delete(params) {
+        return this.client.delete(params);
+    }
+
+    batchWrite(params) {
+        return this.client.batchWrite(params);
+    }
+
+    batchGet(params) {
+        return this.client.batchGet(params);
+    }
+
+    scan(params) {
+        return this.client.scan(params);
+    }
+
+    query(params) {
+        return this.client.query(params);
+    }
+
+    _transact(transactionRequest) {
+        let cancellationReasons;
+        transactionRequest.on('extractError', (response) => {
+            try {
+                cancellationReasons = JSON.parse(response.httpResponse.body.toString()).CancellationReasons;
+            } catch (err) {}
+        });
+
+        return {
+            async promise() {
+                return transactionRequest.promise()
+                    .catch((err) => {
+                        if (err) {
+                            if (Array.isArray(cancellationReasons)) {
+                                return {
+                                    canceled: cancellationReasons
+                                        .map(reason => {
+                                            if (reason.Item) {
+                                                return unmarshallOutput(reason, [{ key: "Item" }]);
+                                            }
+                                            return reason;
+                                        })
+                                };
+                            }
+                            throw err;
+                        }
+                    });
+            }
+        }
+    }
+
+    transactWrite(params) {
+        const transactionRequest = this.client.transactWrite(params);
+        return this._transact(transactionRequest);
+    }
+
+    transactGet(params) {
+        const transactionRequest = this.client.transactGet(params);
+        return this._transact(transactionRequest);
+    }
+
+    createSet(value, ...rest) {
+        if (Array.isArray(value)) {
+            return this.client.createSet(value, ...rest);
+        } else {
+            return this.client.createSet([value], ...rest);
+        }
+    }
+}
+
 class DocumentClientV3Wrapper {
     static init(client) {
         return new DocumentClientV3Wrapper(client, lib);
@@ -23,6 +117,7 @@ class DocumentClientV3Wrapper {
     constructor(client, lib) {
         this.client = client;
         this.lib = lib;
+        this.__v = 'v3';
     }
 
     promiseWrap(fn) {
@@ -81,16 +176,49 @@ class DocumentClientV3Wrapper {
             return this.client.send(command);
         });
     }
+
     transactWrite(params) {
         return this.promiseWrap(async () => {
             const command = new this.lib.TransactWriteCommand(params);
-            return this.client.send(command);
+            return this.client.send(command)
+                .then((result) => {
+                    return result;
+                })
+                .catch(err => {
+                    if (err.CancellationReasons) {
+                        return {
+                            canceled: err.CancellationReasons.map(reason => {
+                                if (reason.Item) {
+                                    return unmarshallOutput(reason, [{ key: "Item" }]);
+                                }
+                                return reason;
+                            })
+                        }
+                    }
+                    throw err;
+                });
         });
     }
     transactGet(params) {
         return this.promiseWrap(async () => {
             const command = new this.lib.TransactGetCommand(params);
-            return this.client.send(command);
+            return this.client.send(command)
+                .then((result) => {
+                    return result;
+                })
+                .catch(err => {
+                    if (err.CancellationReasons) {
+                        return {
+                            canceled: err.CancellationReasons.map(reason => {
+                                if (reason.Item) {
+                                    return unmarshallOutput(reason, [{ key: "Item" }]);
+                                }
+                                return reason;
+                            })
+                        }
+                    }
+                    throw err;
+                });
         });
     }
     createSet(value) {
@@ -103,7 +231,9 @@ class DocumentClientV3Wrapper {
 }
 
 function identifyClientVersion(client = {}) {
-    if (client instanceof DocumentClientV3Wrapper) return DocumentClientVersions.electro;
+    if (client instanceof DocumentClientV3Wrapper || client instanceof DocumentClientV2Wrapper) {
+        return DocumentClientVersions.electro;
+    }
     for (const [version, methods] of Object.entries(supportedClientVersions)) {
         const hasMethods = methods.every(method => {
             return method in client && isFunction(client[method]);
@@ -121,6 +251,7 @@ function normalizeClient(client) {
         case DocumentClientVersions.v3:
             return DocumentClientV3Wrapper.init(client);
         case DocumentClientVersions.v2:
+            return DocumentClientV2Wrapper.init(client);
         case DocumentClientVersions.electro:
             return client;
         default:
@@ -136,6 +267,7 @@ function normalizeConfig(config = {}) {
 }
 
 module.exports = {
+    util,
     v2Methods,
     v3Methods,
     normalizeClient,
@@ -144,4 +276,5 @@ module.exports = {
     DocumentClientVersions,
     supportedClientVersions,
     DocumentClientV3Wrapper,
+    DocumentClientV2Wrapper,
 };

package/src/entity.js

@@ -24,6 +24,7 @@ const { AllPages,
 	IndexTypes,
 	PartialComparisons,
 	MethodTypeTranslation,
+	TransactionCommitSymbol,
 } = require("./types");
 const { FilterFactory } = require("./filters");
 const { FilterOperations } = require("./operations");
@@ -35,6 +36,7 @@ const c = require('./client');
 const u = require("./util");
 const e = require("./errors");
 const { validate } = require("jsonschema");
+const v = require('./validations');
 
 class Entity {
 	constructor(model, config = {}) {
@@ -229,6 +231,10 @@ class Entity {
 		return validations.model(model);
 	}
 
+	check(compositeAttributes = {}) {
+		return this._makeChain(TableIndex, this._clausesWithFilters, clauses.index).check(compositeAttributes);
+	}
+
 	get(facets = {}) {
 		let index = TableIndex;
 		if (Array.isArray(facets)) {
@@ -285,6 +291,16 @@ class Entity {
 		return this._makeChain(index, this._clausesWithFilters, clauses.index, options).remove(facets);
 	}
 
+	async transactWrite(parameters, config) {
+		let response = await this._exec(MethodTypes.transactWrite, parameters, config);
+		return response;
+	}
+
+	async transactGet(parameters, config) {
+		let response = await this._exec(MethodTypes.transactGet, parameters, config);
+		return response;
+	}
+
 	async go(method, parameters = {}, config = {}) {
 		let stackTrace;
 		if (!config.originalErr) {
@@ -486,7 +502,7 @@ class Entity {
 			case FormatToReturnValues.all_old:
 			case FormatToReturnValues.updated_new:
 			case FormatToReturnValues.updated_old:
-				return this.formatResponse(response, config);
+				return this.formatResponse(response, TableIndex, config);
 			case FormatToReturnValues.default:
 			default:
 				return this._formatDefaultResponse(method, parameters.IndexName, parameters, config, response);
@@ -583,7 +599,7 @@ class Entity {
 			for (let i = 0; i < responses.length; i++) {
 				const item = responses[i];
 				const slot = orderMaintainer.getOrder(item);
-				const formatted = this.formatResponse({Item: item}, index, config);
+				const formatted = this.formatResponse({ Item: item }, index, config);
 				if (slot !== -1) {
 					resultsAll[slot] = formatted.data;
 				} else {
@@ -617,6 +633,8 @@ class Entity {
 						if (Object.keys(results).length === 0) {
 							results = null;
 						}
+					} else if (!config._objectOnEmpty) {
+						results = null;
 					}
 				} else if (response.Items) {
 					results = [];
@@ -881,7 +899,7 @@ class Entity {
 		return pager
 	}
 
-	_applyParameterOptions(params, ...options) {
+	_normalizeExecutionOptions({ provided = [], context = {} } = {}) {
 		let config = {
 			includeKeys: false,
 			originalErr: false,
@@ -909,7 +927,7 @@ class Entity {
 			order: undefined,
 		};
 
-		config = options.reduce((config, option) => {
+		return provided.filter(Boolean).reduce((config, option) => {
 			if (typeof option.order === 'string') {
 				switch (option.order.toLowerCase()) {
 					case 'asc':
@@ -929,11 +947,15 @@ class Entity {
 					throw new e.ElectroError(e.ErrorCodes.InvalidOptions, `Invalid value for query option "format" provided: "${option.format}". Allowed values include ${u.commaSeparatedString(Object.keys(ReturnValues))}.`);
 				}
 				config.response = format;
-				config.params.ReturnValues = FormatToReturnValues[format];
+				if (context.operation === MethodTypes.transactWrite) {
+					config.params.ReturnValuesOnConditionCheckFailure = FormatToReturnValues[format];
+				} else {
+					config.params.ReturnValues = FormatToReturnValues[format];
+				}
 			}
 
 			if (option.formatCursor) {
-				const isValid = ['serialize', 'deserialize'].every(method => 
+				const isValid = ['serialize', 'deserialize'].every(method =>
 					method in option.formatCursor &&
 					validations.isFunction(option.formatCursor[method])
 				);
@@ -1058,16 +1080,18 @@ class Entity {
 			config.params = Object.assign({}, config.params, option.params);
 			return config;
 		}, config);
+	}
 
+	_applyParameterOptions({ params = {}, options = {} } = {}) {
 		let parameters = Object.assign({}, params);
 
-		for (let customParameter of Object.keys(config.params)) {
-			if (config.params[customParameter] !== undefined) {
-				parameters[customParameter] = config.params[customParameter];
+		for (let customParameter of Object.keys(options.params || {})) {
+			if (options.params[customParameter] !== undefined) {
+				parameters[customParameter] = options.params[customParameter];
 			}
 		}
 
-		return { parameters, config };
+		return parameters;
 	}
 
 	addListeners(logger) {
@@ -1117,10 +1141,11 @@ class Entity {
 	}
 	/* istanbul ignore next */
 	_params(state, config = {}) {
-		let { keys = {}, method = "", put = {}, update = {}, filter = {}, options = {}, updateProxy, upsert } = state.query;
+		const { keys = {}, method = "", put = {}, update = {}, filter = {}, upsert } = state.query;
 		let consolidatedQueryFacets = this._consolidateQueryFacets(keys.sk);
 		let params = {};
 		switch (method) {
+			case MethodTypes.check:
 			case MethodTypes.get:
 			case MethodTypes.delete:
 			case MethodTypes.remove:
@@ -1148,8 +1173,13 @@ class Entity {
 			default:
 				throw new Error(`Invalid method: ${method}`);
 		}
-		let applied = this._applyParameterOptions(params, options, config);
-		return this._applyParameterExpressions(method, applied.parameters, applied.config, filter);
+
+		let appliedParameters = this._applyParameterOptions({
+			params,
+			options: config,
+		});
+
+		return this._applyParameterExpressions(method, appliedParameters, config, filter);
 	}
 
 	_applyParameterExpressions(method, parameters, config, filter) {
@@ -1251,12 +1281,19 @@ class Entity {
 	_batchGetParams(state, config = {}) {
 		let table = config.table || this.getTableName();
 		let userDefinedParams = config.params || {};
+
+		// TableName is added when the config provided includes "table"
+		// this is evaluated upstream so we remove it to avoid forming
+		// bad syntax. Code should reconsider how this is applied to
+		// make this cleaner :(
+		delete userDefinedParams.TableName;
+
 		let records = [];
 		for (let itemState of state.subStates) {
 			let method = itemState.query.method;
 			let params = this._params(itemState, config);
 			if (method === MethodTypes.get) {
-				let {Key} = params;
+				let { Key } = params;
 				records.push(Key);
 			}
 		}
@@ -1356,11 +1393,7 @@ class Entity {
 			),
 			FilterExpression: `begins_with(#${pkField}, :${pkField})`,
 		};
-		params.ExpressionAttributeNames["#" + this.identifiers.entity] = this.identifiers.entity;
-		params.ExpressionAttributeNames["#" + this.identifiers.version] = this.identifiers.version;
-		params.ExpressionAttributeValues[":" + this.identifiers.entity] = this.getName();
-		params.ExpressionAttributeValues[":" + this.identifiers.version] = this.getVersion();
-		params.FilterExpression = `${params.FilterExpression} AND #${this.identifiers.entity} = :${this.identifiers.entity} AND #${this.identifiers.version} = :${this.identifiers.version}`;
+
 		if (hasSortKey) {
 			let skField = this.model.indexes[accessPattern].sk.field;
 			params.FilterExpression = `${params.FilterExpression} AND begins_with(#${skField}, :${skField})`;
@@ -1380,7 +1413,7 @@ class Entity {
 		});
 		let Key = this._makeParameterKey(index, keys.pk, ...keys.sk);
 		let TableName = this.getTableName();
-		return {Key, TableName};
+		return { Key, TableName };
 	}
 
 	_removeAttributes(item, keys) {
@@ -1691,8 +1724,16 @@ class Entity {
 			default:
 				throw new Error(`Invalid query type: ${state.query.type}`);
 		}
-		let applied = this._applyParameterOptions(parameters, state.query.options, options);
-		return this._applyProjectionExpressions(applied);
+
+		const appliedParameters = this._applyParameterOptions({
+			params: parameters,
+			options,
+		});
+
+		return this._applyProjectionExpressions({
+			parameters: appliedParameters,
+			config: options,
+		});
 	}
 
 	_makeBetweenQueryParams(index, filter, pk, ...sk) {
@@ -2293,7 +2334,6 @@ class Entity {
 	   indexType,
 	   isCollection = false,
 	}) {
-
 		this._validateIndex(index);
 		const excludePostfix = indexType === IndexTypes.clustered && isCollection;
 		const transforms = this._makeKeyTransforms(queryType);
@@ -3115,7 +3155,49 @@ class Entity {
 	}
 }
 
+function getEntityIdentifiers(entities) {
+	let identifiers = [];
+	for (let alias of Object.keys(entities)) {
+		let entity = entities[alias];
+		let name = entity.model.entity;
+		let version = entity.model.version;
+		identifiers.push({
+			name,
+			alias,
+			version,
+			entity,
+			nameField: entity.identifiers.entity,
+			versionField: entity.identifiers.version
+		});
+	}
+	return identifiers;
+}
+
+function matchToEntityAlias({ paramItem, identifiers, record } = {}) {
+	let entity;
+	let entityAlias;
+
+	if (paramItem && v.isFunction(paramItem[TransactionCommitSymbol])) {
+		const committed = paramItem[TransactionCommitSymbol]();
+		entity = committed.entity;
+	}
+
+	for (let {name, version, nameField, versionField, alias} of identifiers) {
+		if (entity && entity.model.entity === name && entity.model.version === version) {
+			entityAlias = alias;
+			break;
+		} else if (record[nameField] !== undefined && record[nameField] === name && record[versionField] !== undefined && record[versionField] === version) {
+			entityAlias = alias;
+			break;
+		}
+	}
+
+	return entityAlias;
+}
+
 module.exports = {
 	Entity,
 	clauses,
+	getEntityIdentifiers,
+	matchToEntityAlias,
 };

package/src/filters.js

@@ -76,7 +76,7 @@ class FilterFactory {
 		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);
@@ -86,7 +86,7 @@ class FilterFactory {
 			injected[name] = {
 				name: name,
 				action: this.buildClause(filter),
-				children: ["params", "go", "filter", ...modelFilters],
+				children: ["params", "go", "commit", "filter", ...modelFilters],
 			};
 		}
 		filterChildren.push("filter");
@@ -95,7 +95,7 @@ class FilterFactory {
 			action: (entity, state, fn) => {
 				return this.buildClause(fn)(entity, state);
 			},
-			children: ["params", "go", "filter", ...modelFilters],
+			children: ["params", "go", "commit", "filter", ...modelFilters],
 		};
 		for (let parent of filterParents) {
 			injected[parent] = { ...injected[parent] };

package/src/service.js

@@ -1,14 +1,15 @@
-const { Entity } = require("./entity");
+const { Entity, getEntityIdentifiers, matchToEntityAlias } = require("./entity");
 const { clauses } = require("./clauses");
-const { KeyCasing, ServiceVersions, Pager, ElectroInstance, ElectroInstanceTypes, ModelVersions, IndexTypes } = require("./types");
+const { TableIndex, TransactionMethods, KeyCasing, ServiceVersions, Pager, ElectroInstance, ElectroInstanceTypes, ModelVersions, IndexTypes } = require("./types");
 const { FilterFactory } = require("./filters");
 const { FilterOperations } = require("./operations");
 const { WhereFactory } = require("./where");
-const { getInstanceType, getModelVersion, applyBetaModelOverrides } = require("./util");
 const v = require("./validations");
 const c = require('./client');
 const e = require("./errors");
 const u = require("./util");
+const txn = require("./transaction");
+const { getInstanceType, getModelVersion, applyBetaModelOverrides } = require("./util");
 
 const ConstructorTypes = {
 	beta: "beta",
@@ -68,6 +69,22 @@ class Service {
 		this.compositeAttributes = {};
 		this.collections = {};
 		this.identifiers = {};
+		this.transaction = {
+			get: (fn) => {
+				return txn.createTransaction({
+					fn,
+					getEntities: () => this.entities,
+					method: TransactionMethods.transactGet,
+				});
+			},
+			write: (fn) => {
+				return txn.createTransaction({
+					fn,
+					getEntities: () => this.entities,
+					method: TransactionMethods.transactWrite,
+				});
+			}
+		};
 		this._instance = ElectroInstance.service;
 		this._instanceType = ElectroInstanceTypes.service;
 	}
@@ -94,6 +111,22 @@ class Service {
 		this.compositeAttributes = {};
 		this.collections = {};
 		this.identifiers = {};
+		this.transaction = {
+			get: (fn) => {
+				return txn.createTransaction({
+					fn,
+					getEntities: () => this.entities,
+					method: TransactionMethods.transactGet,
+				});
+			},
+			write: (fn) => {
+				return txn.createTransaction({
+					fn,
+					getEntities: () => this.entities,
+					method: TransactionMethods.transactWrite,
+				});
+			}
+		};
 		this._instance = ElectroInstance.service;
 		this._instanceType = ElectroInstanceTypes.service;
 	}
@@ -270,53 +303,39 @@ class Service {
 		}
 	}
 
-	_getEntityIdentifiers(entities) {
-		let identifiers = [];
-		for (let alias of Object.keys(entities)) {
-			let entity = entities[alias];
-			let name = entity.model.entity;
-			let version = entity.model.version;
-			identifiers.push({
-				name,
-				alias,
-				version,
-				entity,
-				nameField: entity.identifiers.entity,
-				versionField: entity.identifiers.version
-			});
-		}
-		return identifiers;
-	}
-
-	cleanseRetrievedData(collection = "", entities, data = {}, config = {}) {
+	cleanseRetrievedData(index = TableIndex, entities, data = {}, config = {}) {
 		if (config.raw) {
 			return data;
 		}
+		const identifiers = getEntityIdentifiers(entities);
+
 		data.Items = data.Items || [];
-		let index = this.collectionSchema[collection].index;
-		let results = {};
-		let identifiers = this._getEntityIdentifiers(entities);
+
+		const results = {};
 		for (let {alias} of identifiers) {
 			results[alias] = [];
 		}
-		for (let record of data.Items) {
-			let entityAlias;
-			for (let {name, version, nameField, versionField, alias} of identifiers) {
-				if (record[nameField] !== undefined && record[nameField] === name && record[versionField] !== undefined && record[versionField] === version) {
-					entityAlias = alias;
-					break;
-				}
+
+		for (let i = 0; i < data.Items.length; i++) {
+			const record = data.Items[i];
+
+			if (!record) {
+				continue;
 			}
+
+			const entityAlias = matchToEntityAlias({identifiers, record});
+
 			if (!entityAlias) {
 				continue;
 			}
 			// pager=false because we don't want the entity trying to parse the lastEvaluatedKey
-			let items = this.collectionSchema[collection].entities[entityAlias].formatResponse({Item: record}, index, {
+			let formatted = entities[entityAlias].formatResponse({Item: record}, index, {
 				...config,
 				pager: false,
 				parse: undefined
 			});
-			results[entityAlias].push(items.data);
+
+			results[entityAlias].push(formatted.data);
 		}
 		return results;
 	}
@@ -364,7 +383,7 @@ class Service {
 		name = "",
 		initialClauses = {},
 	}, facets = {}) {
-		const { entities, attributes, identifiers, indexType } = this.collectionSchema[name];
+		const { entities, attributes, identifiers, indexType, index } = this.collectionSchema[name];
 		const compositeAttributes = this.compositeAttributes[name];
 		const allEntities = Object.values(entities);
 		const entity = allEntities[0];
@@ -381,7 +400,10 @@ class Service {
 		let options = {
 			// expressions, // DynamoDB doesnt return what I expect it would when provided with these entity filters
 			parse: (options, data) => {
-				return this.cleanseRetrievedData(name, entities, data, options);
+				if (options.raw) {
+					return data;
+				}
+				return this.cleanseRetrievedData(index, entities, data, options);
 			},
 			formatCursor: {
 				serialize: (key) => {
@@ -391,13 +413,18 @@ class Service {
 					return this.expectCursorOwner(cursor).deserializeCursor(cursor);
 				}
 			},
-			expressions: {
+			identifiers: {
 				names: identifiers.names || {},
 				values: identifiers.values || {},
 				expression: allEntities.length > 1
 					? `(${expression})`
 					: expression
 			},
+			expressions: {
+				names: {},
+				values: {},
+				expression: '',
+			},
 			attributes,
 			entities,
 			indexType,
@@ -730,4 +757,6 @@ class Service {
 	}
 }
 
-module.exports = { Service };
+module.exports = {
+	Service,
+};