electrodb 2.8.0 → 2.8.2

package/package.json

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

package/src/entity.js

@@ -1886,12 +1886,20 @@ class Entity {
 		// should only happen when an attribute is changed.
 		const { indexKey, updatedKeys, deletedKeys = [] } = this._getUpdatedKeys(pk, sk, preparedUpdateValues, removed);
 		const accessPattern = this.model.translations.indexes.fromIndexToAccessPattern[TableIndex];
-
 		for (const path of Object.keys(preparedUpdateValues)) {
 			if (modifiedAttributeNames[path] !== undefined && preparedUpdateValues[path] !== undefined) {
 				update.updateValue(modifiedAttributeNames[path], preparedUpdateValues[path]);
 			} else if (preparedUpdateValues[path] !== undefined) {
-				update.set(path, preparedUpdateValues[path]);
+				const attr = this.model.schema.getAttribute(path);
+				if (attr) {
+					// attributes might enter into this flow because they were triggered via a `watch` event and were
+					// not supplied directly by the user. In this case we should set the field name.
+					// TODO: This will only work with root attributes and should be refactored for nested attributes.
+					update.set(attr.field, preparedUpdateValues[path]);
+				} else {
+					// this could be fields added by electro that don't apeear in the schema
+					update.set(path, preparedUpdateValues[path]);
+				}
 			}
 		}
 
@@ -1901,7 +1909,6 @@ class Entity {
 			const wasNotAlreadyModified = modifiedAttributeNames[indexKey] === undefined;
 			if (isNotTablePK && isNotTableSK && wasNotAlreadyModified) {
 				update.set(indexKey, updatedKeys[indexKey]);
-
 			}
 		}
 
@@ -1948,7 +1955,6 @@ class Entity {
 	_makePutParams({ data } = {}, pk, sk) {
 		let { updatedKeys, setAttributes } = this._getPutKeys(pk, sk && sk.facets, data);
 		let translatedFields = this.model.schema.translateToFields(setAttributes);
-
 		return {
 			Item: {
 				...translatedFields,
@@ -2406,8 +2412,10 @@ class Entity {
 					indexKey[sk] = keys.sk[0];
 				}
 			}
-			updatedKeys[pk] = keys.pk;
-			if (sk) {
+			if (keys.pk !== undefined && keys.pk !== '') {
+				updatedKeys[pk] = keys.pk;
+			}
+			if (sk && keys.sk[0] !== undefined && keys.sk[0] !== '') {
 				updatedKeys[sk] = keys.sk[0];
 			}
 		}
@@ -3298,7 +3306,9 @@ class Entity {
 			if (Array.isArray(sk.facets)) {
 				let duplicates = pk.facets.filter(facet => sk.facets.includes(facet));
 				if (duplicates.length !== 0) {
-					throw new e.ElectroError(e.ErrorCodes.DuplicateIndexCompositeAttributes, `The Access Pattern '${accessPattern}' contains duplicate references the composite attribute(s): ${u.commaSeparatedString(duplicates)}. Composite attributes may only be used once within an index. If this leaves the Sort Key (sk) without any composite attributes simply set this to be an empty array.`);
+					if (sk.facets.length > 1) {
+						throw new e.ElectroError(e.ErrorCodes.DuplicateIndexCompositeAttributes, `The Access Pattern '${accessPattern}' contains duplicate references the composite attribute(s): ${u.commaSeparatedString(duplicates)}. Composite attributes can only be used more than once in an index if your sort key is limitted to a single attribute. This is to prevent unexpected runtime errors related to the inability to generate keys.`);
+					}
 				}
 			}
 
@@ -3595,7 +3605,6 @@ class Entity {
 
 	_parseModel(model, config = {}) {
 		/** start beta/v1 condition **/
-		const {client} = config;
 		let modelVersion = u.getModelVersion(model);
 		let service, entity, version, table, name;
 		switch(modelVersion) {
@@ -3635,7 +3644,10 @@ class Entity {
 			indexAccessPattern,
 			indexHasSubCollections,
 		} = this._normalizeIndexes(model.indexes);
-		let schema = new Schema(model.attributes, facets, {client, isRoot: true});
+		let schema = new Schema(model.attributes, facets, {
+			getClient: () => this.client,
+			isRoot: true,
+		});
 		let filters = this._normalizeFilters(model.filters);
 		// todo: consider a rename
 		let prefixes = this._normalizeKeyFixings({service, entity, version, indexes, modelVersion, clusteredIndexes, schema});

package/src/schema.js

@@ -127,7 +127,7 @@ class Attribute {
 		this.parent = { parentType: this.type, parentPath: this.path };
 		this.get = this._makeGet(definition.get);
 		this.set = this._makeSet(definition.set);
-		this.client = definition.client;
+		this.getClient = definition.getClient;
 	}
 
 	static buildChildAttributes(type, definition, parent) {
@@ -145,25 +145,25 @@ class Attribute {
 	}
 
 	static buildChildListItems(definition, parent) {
-		const {items, client} = definition;
+		const {items, getClient} = definition;
 		const prop = {...items, ...parent};
 		// The use of "*" is to ensure the child's name is "*" when added to the traverser and searching for the children of a list
-		return Schema.normalizeAttributes({ '*': prop }, {}, {client, traverser: parent.traverser, parent}).attributes["*"];
+		return Schema.normalizeAttributes({ '*': prop }, {}, {getClient, traverser: parent.traverser, parent}).attributes["*"];
 	}
 
 	static buildChildSetItems(definition, parent) {
-		const {items, client} = definition;
+		const {items, getClient} = definition;
 
 		const allowedTypes = [AttributeTypes.string, AttributeTypes.boolean, AttributeTypes.number, AttributeTypes.enum];
 		if (!Array.isArray(items) && !allowedTypes.includes(items)) {
 			throw new e.ElectroError(e.ErrorCodes.InvalidAttributeDefinition, `Invalid "items" definition for Set attribute: "${definition.path}". Acceptable item types include ${u.commaSeparatedString(allowedTypes)}`);
 		}
 		const prop = {type: items, ...parent};
-		return Schema.normalizeAttributes({ prop }, {}, {client, traverser: parent.traverser, parent}).attributes.prop;
+		return Schema.normalizeAttributes({ prop }, {}, {getClient, traverser: parent.traverser, parent}).attributes.prop;
 	}
 
 	static buildChildMapProperties(definition, parent) {
-		const {properties, client} = definition;
+		const {properties, getClient} = definition;
 		if (!properties || typeof properties !== "object") {
 			throw new e.ElectroError(e.ErrorCodes.InvalidAttributeDefinition, `Invalid "properties" definition for Map attribute: "${definition.path}". The "properties" definition must describe the attributes that the Map will accept`);
 		}
@@ -171,7 +171,7 @@ class Attribute {
 		for (let name of Object.keys(properties)) {
 			attributes[name] = {...properties[name], ...parent};
 		}
-		return Schema.normalizeAttributes(attributes, {}, {client, traverser: parent.traverser, parent});
+		return Schema.normalizeAttributes(attributes, {}, {getClient, traverser: parent.traverser, parent});
 	}
 
 	static buildPath(name, type, parentPath) {
@@ -886,11 +886,12 @@ class SetAttribute extends Attribute {
 	}
 
 	_createDDBSet(value) {
-		if (this.client && typeof this.client.createSet === "function") {
+		const client = this.getClient();
+		if (client && typeof client.createSet === "function") {
 			value = Array.isArray(value)
 				? Array.from(new Set(value))
 				: value;
-			return this.client.createSet(value, { validate: true });
+			return client.createSet(value, { validate: true });
 		} else {
 			return new DynamoDBSet(value, this.items.type);
 		}
@@ -1005,10 +1006,10 @@ class SetAttribute extends Attribute {
 }
 
 class Schema {
-	constructor(properties = {}, facets = {}, {traverser = new AttributeTraverser(), client, parent, isRoot} = {}) {
+	constructor(properties = {}, facets = {}, {traverser = new AttributeTraverser(), getClient, parent, isRoot} = {}) {
 		this._validateProperties(properties, parent);
-		let schema = Schema.normalizeAttributes(properties, facets, {traverser, client, parent, isRoot});
-		this.client = client;
+		let schema = Schema.normalizeAttributes(properties, facets, {traverser, getClient, parent, isRoot});
+		this.getClient = getClient;
 		this.attributes = schema.attributes;
 		this.enums = schema.enums;
 		this.translationForTable = schema.translationForTable;
@@ -1021,7 +1022,7 @@ class Schema {
 		this.isRoot = !!isRoot;
 	}
 
-	static normalizeAttributes(attributes = {}, facets = {}, {traverser, client, parent, isRoot} = {}) {
+	static normalizeAttributes(attributes = {}, facets = {}, {traverser, getClient, parent, isRoot} = {}) {
 		const attributeHasParent = !!parent;
 		let invalidProperties = [];
 		let normalized = {};
@@ -1114,7 +1115,7 @@ class Schema {
 			let definition = {
 				name,
 				field,
-				client,
+				getClient,
 				casing,
 				prefix,
 				postfix,