electrodb 2.4.1 → 2.4.2

package/index.d.ts

@@ -2257,6 +2257,10 @@ export type EntityConfiguration = {
     client?: DocumentClient;
     listeners?: Array<ElectroEventListener>;
     logger?: ElectroEventListener;
+    identifiers?: {
+      entity?: string;
+      version?: string;
+    },
 };
 
 export class Entity<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> {
@@ -2374,4 +2378,4 @@ declare function CustomAttributeType<T>(
     ? OpaquePrimitiveTypeName<T>
     : CustomAttributeTypeName<T>;
 
-declare function createSchema<A extends string, F extends string, C extends string, S extends Schema<A,F,C>>(schema: S): S
+declare function createSchema<A extends string, F extends string, C extends string, S extends Schema<A,F,C>>(schema: S): S

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electrodb",
-  "version": "2.4.1",
+  "version": "2.4.2",
   "description": "A library to more easily create and interact with multiple entities and heretical relationships in dynamodb",
   "main": "index.js",
   "scripts": {

package/src/clauses.js

@@ -37,7 +37,7 @@ let clauses = {
 				return state;
 			}
 			try {
-				const {pk, sk} = state.getCompositeAttributes();
+				const { pk, sk } = state.getCompositeAttributes();
 				return state
 					.setType(QueryTypes.clustered_collection)
 					.setMethod(MethodTypes.query)
@@ -50,6 +50,22 @@ let clauses = {
 						if (sk.length > 1) {
 							state.filterProperties(FilterOperationNames.eq, {...unused, ...composites});
 						}
+					})
+					.whenOptions(({ options, state }) => {
+						if (!options.ignoreOwnership) {
+							state.query.options.expressions.names = {
+								...state.query.options.expressions.names,
+								...state.query.options.identifiers.names,
+							};
+							state.query.options.expressions.values = {
+								...state.query.options.expressions.values,
+								...state.query.options.identifiers.values,
+							};
+							state.query.options.expressions.expression =
+								state.query.options.expressions.expression.length > 1
+									? `(${state.query.options.expressions.expression}) AND ${state.query.options.identifiers.expression}`
+									: `${state.query.options.identifiers.expression}`;
+						}
 					});
 
 			} catch(err) {
@@ -72,7 +88,23 @@ let clauses = {
 					.setType(QueryTypes.collection)
 					.setMethod(MethodTypes.query)
 					.setCollection(collection)
-					.setPK(entity._expectFacets(facets, pk));
+					.setPK(entity._expectFacets(facets, pk))
+					.whenOptions(({ options, state }) => {
+						if (!options.ignoreOwnership) {
+							state.query.options.expressions.names = {
+								...state.query.options.expressions.names,
+								...state.query.options.identifiers.names,
+							};
+							state.query.options.expressions.values = {
+								...state.query.options.expressions.values,
+								...state.query.options.identifiers.values,
+							};
+							state.query.options.expressions.expression =
+								state.query.options.expressions.expression.length > 1
+									? `(${state.query.options.expressions.expression}) AND ${state.query.options.identifiers.expression}`
+									: `${state.query.options.identifiers.expression}`;
+						}
+					});
 			} catch(err) {
 				state.setError(err);
 				return state;
@@ -87,7 +119,13 @@ let clauses = {
 				return state;
 			}
 			try {
-				return state.setMethod(MethodTypes.scan);
+				return state.setMethod(MethodTypes.scan)
+					.whenOptions(({ state, options }) => {
+						if (!options.ignoreOwnership) {
+							state.unsafeApplyFilter(FilterOperationNames.eq, entity.identifiers.entity, entity.getName());
+							state.unsafeApplyFilter(FilterOperationNames.eq, entity.identifiers.version, entity.getVersion());
+						}
+					});
 			} catch(err) {
 				state.setError(err);
 				return state;
@@ -478,10 +516,13 @@ let clauses = {
 						if (sk.length > 1) {
 							state.filterProperties(FilterOperationNames.eq, {...unused, ...composites});
 						}
-						if (state.query.options.indexType === IndexTypes.clustered && Object.keys(composites).length < sk.length) {
-							state.unsafeApplyFilter(FilterOperationNames.eq, entity.identifiers.entity, entity.getName())
-								.unsafeApplyFilter(FilterOperationNames.eq, entity.identifiers.version, entity.getVersion());
-						}
+
+						state.whenOptions(({ options, state }) => {
+							if (state.query.options.indexType === IndexTypes.clustered && Object.keys(composites).length < sk.length && !options.ignoreOwnership) {
+								state.unsafeApplyFilter(FilterOperationNames.eq, entity.identifiers.entity, entity.getName())
+									.unsafeApplyFilter(FilterOperationNames.eq, entity.identifiers.version, entity.getVersion());
+							}
+						});
 					});
 			} catch(err) {
 				state.setError(err);
@@ -632,20 +673,26 @@ let clauses = {
 					throw new e.ElectroError(e.ErrorCodes.MissingTable, `Table name not defined. Table names must be either defined on the model, instance configuration, or as a query option.`);
 				}
 				const method = state.getMethod();
+				const normalizedOptions = entity._normalizeExecutionOptions({ provided: [ state.getOptions(), state.query.options, options ] });
+				state.applyWithOptions(normalizedOptions);
 				let results;
 				switch (method) {
-					case MethodTypes.query:
-						results = entity._queryParams(state, options);
+					case MethodTypes.query: {
+						results = entity._queryParams(state, normalizedOptions);
 						break;
-					case MethodTypes.batchWrite:
-						results = entity._batchWriteParams(state, options);
-						break
-					case MethodTypes.batchGet:
-						results = entity._batchGetParams(state, options);
+					}
+					case MethodTypes.batchWrite: {
+						results = entity._batchWriteParams(state, normalizedOptions);
 						break;
-					default:
-						results = entity._params(state, options);
+					}
+					case MethodTypes.batchGet: {
+						results = entity._batchGetParams(state, normalizedOptions);
 						break;
+					}
+					default: {
+						results = entity._params(state, normalizedOptions);
+						break;
+					}
 				}
 
 				if (method === MethodTypes.update && results.ExpressionAttributeValues && Object.keys(results.ExpressionAttributeValues).length === 0) {
@@ -653,6 +700,14 @@ let clauses = {
 					// todo: change the getValues() method to return undefined in this case (would potentially require a more generous refactor)
 					delete results.ExpressionAttributeValues;
 				}
+
+				if (options._returnOptions) {
+					return {
+						params: results,
+						options: normalizedOptions,
+					}
+				}
+
 				return results;
 			} catch(err) {
 				throw err;
@@ -671,9 +726,8 @@ let clauses = {
 					throw new e.ElectroError(e.ErrorCodes.NoClientDefined, "No client defined on model");
 				}
 				options.terminalOperation = TerminalOperation.go;
-				let params = clauses.params.action(entity, state, options);
-				let {config} = entity._applyParameterOptions({}, state.getOptions(), options);
-				return entity.go(state.getMethod(), params, config);
+				const paramResults = clauses.params.action(entity, state, { ...options, _returnOptions: true });
+				return entity.go(state.getMethod(), paramResults.params, paramResults.options);
 			} catch(err) {
 				return Promise.reject(err);
 			}
@@ -718,6 +772,7 @@ class ChainState {
 			options,
 		};
 		this.subStates = [];
+		this.applyAfterOptions = [];
 		this.hasSortKey = hasSortKey;
 		this.prev = null;
 		this.self = null;
@@ -911,6 +966,18 @@ class ChainState {
 		this.query.put.data = {...this.query.put.data, ...data};
 		return this;
 	}
+
+	whenOptions(fn) {
+		if (v.isFunction(fn)) {
+			this.applyAfterOptions.push((options) => {
+				fn({ options, state: this });
+			});
+		}
+	}
+
+	applyWithOptions(options = {}) {
+		this.applyAfterOptions.forEach((fn) => fn(options));
+	}
 }
 
 module.exports = {

package/src/entity.js

@@ -583,7 +583,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 +617,8 @@ class Entity {
 						if (Object.keys(results).length === 0) {
 							results = null;
 						}
+					} else if (!config._objectOnEmpty) {
+						results = null;
 					}
 				} else if (response.Items) {
 					results = [];
@@ -881,7 +883,7 @@ class Entity {
 		return pager
 	}
 
-	_applyParameterOptions(params, ...options) {
+	_normalizeExecutionOptions({ provided = [] } = {}) {
 		let config = {
 			includeKeys: false,
 			originalErr: false,
@@ -909,7 +911,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':
@@ -933,7 +935,7 @@ class Entity {
 			}
 
 			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 +1060,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,7 +1121,7 @@ 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) {
@@ -1148,8 +1152,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 +1260,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 +1372,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})`;
@@ -1691,8 +1703,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 +2313,6 @@ class Entity {
 	   indexType,
 	   isCollection = false,
 	}) {
-
 		this._validateIndex(index);
 		const excludePostfix = indexType === IndexTypes.clustered && isCollection;
 		const transforms = this._makeKeyTransforms(queryType);

package/src/service.js

@@ -391,13 +391,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,