electrodb 2.8.1 → 2.9.0

package/index.d.ts

@@ -810,6 +810,7 @@ export interface SetRecordActionOptionsTransaction<A extends string, F extends s
     append: SetRecordTransaction<A,F,C,S, AppendItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
     delete: SetRecordTransaction<A,F,C,S, DeleteItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
     data: DataUpdateMethodRecordTransaction<A,F,C,S, Item<A,F,C,S,S["attributes"]>,IndexCompositeAttributes,TableItem>;
+    composite: UpdateComposite<A,F,C,S, SetRecordActionOptionsTransaction<A,F,C,S,SetAttr,IndexCompositeAttributes,TableItem>>;
     where: WhereClause<A,F,C,S, Item<A,F,C,S,S["attributes"]>,SetRecordActionOptionsTransaction<A,F,C,S,SetAttr,IndexCompositeAttributes,TableItem>>;
 }
 
@@ -860,6 +861,7 @@ export interface SetRecordActionOptions<A extends string, F extends string, C ex
     subtract: SetRecord<A,F,C,S, SubtractItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
     append: SetRecord<A,F,C,S, AppendItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
     delete: SetRecord<A,F,C,S, DeleteItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
+    composite: UpdateComposite<A,F,C,S, SetRecordActionOptions<A,F,C,S,SetAttr,IndexCompositeAttributes,TableItem>>;
     data: DataUpdateMethodRecord<A,F,C,S, Item<A,F,C,S,S["attributes"]>,IndexCompositeAttributes,TableItem>;
     where: WhereClause<A,F,C,S, Item<A,F,C,S,S["attributes"]>,SetRecordActionOptions<A,F,C,S,SetAttr,IndexCompositeAttributes,TableItem>>;
 }
@@ -2171,6 +2173,12 @@ export type UpdatableItemAttribute<A extends Attribute> =
                                         : never
         : never
 
+type UpdateComposite<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, Response> = (
+    compositeAttributes: Partial<{
+        [I in keyof S["indexes"] as I extends infer Name ? Name extends TableIndexName<A,F,C,S> ? never : Name : never]: IndexPKAttributes<A, F, C, S, I> & IndexSKAttributes<A, F, C, S, I>;
+    }[keyof S["indexes"] extends infer KeyName ? KeyName extends TableIndexName<A,F,C,S> ? never : KeyName : never]>
+) => Response;
+
 export type RemovableItemAttribute<A extends Attribute> =
     A['type'] extends OpaquePrimitiveTypeName<infer T>
         ? T
@@ -2541,6 +2549,7 @@ export class Entity<A extends string, F extends string, C extends string, S exte
         append: SetRecord<A,F,C,S, AppendItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, Partial<ResponseItem<A,F,C,S>>>;
         delete: SetRecord<A,F,C,S, DeleteItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, Partial<ResponseItem<A,F,C,S>>>;
         data: DataUpdateMethodRecord<A,F,C,S, Item<A,F,C,S,S["attributes"]>, TableIndexCompositeAttributes<A,F,C,S>, Partial<ResponseItem<A,F,C,S>>>;
+        composite: UpdateComposite<A,F,C,S, SetRecordActionOptions<A,F,C,S, SetItem<A,F,C,S>,TableIndexCompositeAttributes<A,F,C,S>, Partial<ResponseItem<A,F,C,S>>>>;
     };
     patch(key: AllTableIndexCompositeAttributes<A,F,C,S>): {
         set: SetRecord<A,F,C,S, SetItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
@@ -2550,6 +2559,7 @@ export class Entity<A extends string, F extends string, C extends string, S exte
         append: SetRecord<A,F,C,S, AppendItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
         delete: SetRecord<A,F,C,S, DeleteItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
         data: DataUpdateMethodRecord<A,F,C,S, Item<A,F,C,S,S["attributes"]>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
+        composite: UpdateComposite<A,F,C,S, SetRecordActionOptions<A,F,C,S, SetItem<A,F,C,S>,TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>>;
     };
 
     find(record: Partial<Item<A,F,C,S,S["attributes"]>>): RecordsActionOptions<A,F,C,S, ResponseItem<A,F,C,S>[], AllTableIndexCompositeAttributes<A,F,C,S>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electrodb",
-  "version": "2.8.1",
+  "version": "2.9.0",
   "description": "A library to more easily create and interact with multiple entities and heretical relationships in dynamodb",
   "main": "index.js",
   "scripts": {
@@ -31,8 +31,8 @@
   },
   "homepage": "https://github.com/tywalch/electrodb#readme",
   "devDependencies": {
-    "@aws-sdk/client-dynamodb": "^3.54.1",
-    "@aws-sdk/lib-dynamodb": "^3.54.1",
+    "@aws-sdk/client-dynamodb": "^3.395.0",
+    "@aws-sdk/lib-dynamodb": "^3.395.0",
     "@istanbuljs/nyc-config-typescript": "^1.0.2",
     "@types/chai": "^4.2.12",
     "@types/mocha": "^8.0.3",
@@ -50,8 +50,8 @@
     "nyc": "^15.1.0",
     "source-map-support": "^0.5.19",
     "ts-node": "^10.9.1",
-    "tsd": "^0.21.0",
-    "typescript": "^4.9.5",
+    "tsd": "^0.28.1",
+    "typescript": "^5.1.6",
     "uuid": "7.0.1"
   },
   "keywords": [
@@ -67,7 +67,6 @@
     "directory": "test"
   },
   "dependencies": {
-    "@aws-sdk/lib-dynamodb": "^3.54.1",
     "jsonschema": "1.2.7"
   }
 }

package/src/clauses.js

@@ -1,5 +1,5 @@
 const { QueryTypes, MethodTypes, ItemOperations, ExpressionTypes, TransactionCommitSymbol, TransactionOperations, TerminalOperation, KeyTypes, IndexTypes } = require("./types");
-const {AttributeOperationProxy, UpdateOperations, FilterOperationNames} = require("./operations");
+const {AttributeOperationProxy, UpdateOperations, FilterOperationNames, UpdateOperationNames} = require("./operations");
 const {UpdateExpression} = require("./update");
 const {FilterExpression} = require("./where");
 const v = require("./validations");
@@ -366,7 +366,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["set", "append","updateRemove", "updateDelete", "add", "subtract", "data", "commit"],
+		children: ["set", "append","updateRemove", "updateDelete", "add", "subtract", "data", "composite", "commit"],
 	},
 	update: {
 		name: "update",
@@ -393,7 +393,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit"],
+		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit", "composite"],
 	},
 	data: {
 		name: "data",
@@ -423,7 +423,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit"],
+		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit", "composite"],
 	},
 	set: {
 		name: "set",
@@ -440,7 +440,32 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit"],
+		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit", "composite"],
+	},
+	composite: {
+		name: "composite",
+		action(entity, state, composites = {}) {
+			if (state.getError() !== null) {
+				return state;
+			}
+			try {
+				for (const attrName in composites) {
+					// todo: validate attrName is facet
+					if (entity.model.facets.byAttr[attrName]) {
+						const wasSet = state.query.update.addComposite(attrName, composites[attrName]);
+						if (!wasSet) {
+							throw new e.ElectroError(e.ErrorCodes.DuplicateUpdateCompositesProvided, `The composite attribute ${attrName} has been provided more than once with different values. Remove the duplication before running again`);
+						}
+						state.applyCondition(FilterOperationNames.eq, attrName, composites[attrName]);
+					}
+				}
+				return state;
+			} catch(err) {
+				state.setError(err);
+				return state;
+			}
+		},
+		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit", "composite"],
 	},
 	append: {
 		name: "append",
@@ -457,7 +482,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit"],
+		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit", "composite"],
 	},
 	updateRemove: {
 		name: "remove",
@@ -477,7 +502,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit"],
+		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit", "composite"],
 	},
 	updateDelete: {
 		name: "delete",
@@ -494,7 +519,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit"],
+		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit", "composite"],
 	},
 	add: {
 		name: "add",
@@ -511,7 +536,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit"],
+		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit", "composite"],
 	},
 	subtract: {
 		name: "subtract",
@@ -528,7 +553,7 @@ let clauses = {
 				return state;
 			}
 		},
-		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit"],
+		children: ["data", "set", "append", "add", "updateRemove", "updateDelete", "go", "params", "subtract", "commit", "composite"],
 	},
 	query: {
 		name: "query",
@@ -965,6 +990,17 @@ class ChainState {
 		return this;
 	}
 
+	applyCondition(operation, name, ...values) {
+		if (FilterOperationNames[operation] !== undefined && name !== undefined && values.length > 0) {
+			const attribute = this.attributes[name];
+			if (attribute !== undefined) {
+				const filter = this.query.filter[ExpressionTypes.ConditionExpression];
+				filter.unsafeSet(operation, attribute.field, ...values);
+			}
+		}
+		return this;
+	}
+
 	unsafeApplyFilter(operation, name, ...values) {
 		if (FilterOperationNames[operation] !== undefined & name !== undefined && values.length > 0) {
 			const filter = this.query.filter[ExpressionTypes.FilterExpression];

package/src/entity.js

@@ -1884,14 +1884,26 @@ class Entity {
 		// We need to remove the pk/sk facets from before applying the Attribute setters because these values didnt
 		// change, and we also don't want to trigger the setters of any attributes watching these facets because that
 		// should only happen when an attribute is changed.
-		const { indexKey, updatedKeys, deletedKeys = [] } = this._getUpdatedKeys(pk, sk, preparedUpdateValues, removed);
+		const attributesAndComposites = {
+			...update.composites,
+			...preparedUpdateValues,
+		};
+		const { indexKey, updatedKeys, deletedKeys = [] } = this._getUpdatedKeys(pk, sk, attributesAndComposites, 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 +1913,6 @@ class Entity {
 			const wasNotAlreadyModified = modifiedAttributeNames[indexKey] === undefined;
 			if (isNotTablePK && isNotTableSK && wasNotAlreadyModified) {
 				update.set(indexKey, updatedKeys[indexKey]);
-
 			}
 		}
 
@@ -1948,7 +1959,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,
@@ -2337,7 +2347,7 @@ class Entity {
 			let incompleteAccessPatterns = incomplete.map(({index}) => this.model.translations.indexes.fromIndexToAccessPattern[index]);
 			let missingFacets = incomplete.reduce((result, { missing }) => [...result, ...missing], []);
 			throw new e.ElectroError(e.ErrorCodes.IncompleteCompositeAttributes,
-				`Incomplete composite attributes: Without the composite attributes ${u.commaSeparatedString(missingFacets)} the following access patterns cannot be updated: ${u.commaSeparatedString(incompleteAccessPatterns.filter((val) => val !== undefined))} `,
+				`Incomplete composite attributes: Without the composite attributes ${u.commaSeparatedString(missingFacets)} the following access patterns cannot be updated: ${u.commaSeparatedString(incompleteAccessPatterns.filter((val) => val !== undefined))}. If a composite attribute is readOnly and cannot be set, use the 'composite' chain method on update to supply the value for key formatting purposes.`,
 			);
 		}
 		return complete;
@@ -2406,8 +2416,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 +3310,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.`);
+					}
 				}
 			}
 

package/src/errors.js

@@ -205,6 +205,12 @@ const ErrorCodes = {
     name: "InvalidConversionCompositeProvided",
     sym: ErrorCode,
   },
+  DuplicateUpdateCompositesProvided: {
+    code: 2010,
+    section: "duplicate-update-composites-provided",
+    name: "DuplicateUpdateCompositesProvided",
+    sym: ErrorCode,
+  },
   InvalidAttribute: {
     code: 3001,
     section: "invalid-attribute",

package/src/operations.js

@@ -552,4 +552,9 @@ const FilterOperationNames = Object.keys(FilterOperations).reduce((ops, name) =>
     return ops;
 }, {});
 
-module.exports = {UpdateOperations, FilterOperations, FilterOperationNames, ExpressionState, AttributeOperationProxy};
+const UpdateOperationNames = Object.keys(UpdateOperations).reduce((ops, name) => {
+    ops[name] = name;
+    return ops;
+}, {});
+
+module.exports = {UpdateOperations, UpdateOperationNames, FilterOperations, FilterOperationNames, ExpressionState, AttributeOperationProxy};

package/src/schema.js

@@ -1171,7 +1171,7 @@ class Schema {
 
 			if (facets.byAttr && facets.byAttr[definition.name] !== undefined && (!ValidFacetTypes.includes(definition.type) && !Array.isArray(definition.type))) {
 				let assignedIndexes = facets.byAttr[name].map(assigned => assigned.index === "" ? "Table Index" : assigned.index);
-				throw new e.ElectroError(e.ErrorCodes.InvalidAttributeDefinition, `Invalid composite attribute definition: Composite attributes must be one of the following: ${ValidFacetTypes.join(", ")}. The attribute "${name}" is defined as being type "${attribute.type}" but is a composite attribute of the the following indexes: ${assignedIndexes.join(", ")}`);
+				throw new e.ElectroError(e.ErrorCodes.InvalidAttributeDefinition, `Invalid composite attribute definition: Composite attributes must be one of the following: ${ValidFacetTypes.join(", ")}. The attribute "${name}" is defined as being type "${attribute.type}" but is a composite attribute of the following indexes: ${assignedIndexes.join(", ")}`);
 			}
 
 			if (usedAttrs[definition.field] || usedAttrs[name]) {
@@ -1438,9 +1438,9 @@ class Schema {
 
 	checkUpdate(payload = {}, { allowReadOnly } = {}) {
 		let record = {};
-		for (let [path, attribute] of this.traverser.getAll()) {
-			let value = payload[path];
-			if (value === undefined) {
+		for (let [path, value] of Object.entries(payload)) {
+			let attribute = this.traverser.paths.get(path);
+			if (attribute === undefined) {
 				continue;
 			}
 			if (attribute.readOnly && !allowReadOnly) {

package/src/service.js

@@ -518,6 +518,8 @@ class Service {
 	}
 
 	_validateCollectionDefinition(definition = {}, providedIndex = {}) {
+		let isCustomMatchPK = definition.pk.isCustom === providedIndex.pk.isCustom;
+		let isCustomMatchSK = !!(definition.sk && definition.sk.isCustom) === !!(providedIndex.sk && providedIndex.sk.isCustom);
 		let indexMatch = definition.index === providedIndex.index;
 		let pkFieldMatch = definition.pk.field === providedIndex.pk.field;
 		let pkFacetLengthMatch = definition.pk.facets.length === providedIndex.pk.facets.length;
@@ -526,37 +528,74 @@ class Service {
 		let definitionIndexName = u.formatIndexNameForDisplay(definition.index);
 		let providedIndexName = u.formatIndexNameForDisplay(providedIndex.index);
 		let matchingKeyCasing = this._validateIndexCasingMatch(definition, providedIndex);
-		if (pkFacetLengthMatch) {
-			for (let i = 0; i < definition.pk.labels.length; i++) {
-				let definitionFacet = definition.pk.labels[i].name;
-				let definitionLabel = definition.pk.labels[i].label;
-				let providedFacet = providedIndex.pk.labels[i].name;
-				let providedLabel = providedIndex.pk.labels[i].label;
-				let noLabels = definition.pk.labels[i].label === definition.pk.labels[i].name && providedIndex.pk.labels[i].label === providedIndex.pk.labels[i].name;
-				if (definitionLabel !== providedLabel) {
-					mismatchedFacetLabels.push({
-						definitionFacet,
-						definitionLabel,
-						providedFacet,
-						providedLabel,
-						type: noLabels ? "facet" : "label"
-					});
-				} else if (definitionFacet !== providedFacet) {
-					mismatchedFacetLabels.push({
-						definitionFacet,
-						definitionLabel,
-						providedFacet,
-						providedLabel,
-						type: "facet"
-					});
+
+		for (let i = 0; i < Math.max(definition.pk.labels.length, providedIndex.pk.labels.length); i++) {
+			let definitionFacet = definition.pk.labels[i] && definition.pk.labels[i].name;
+			let definitionLabel = definition.pk.labels[i] && definition.pk.labels[i].label;
+			let providedFacet = providedIndex.pk.labels[i] && providedIndex.pk.labels[i].name;
+			let providedLabel = providedIndex.pk.labels[i] && providedIndex.pk.labels[i].label;
+			let noLabels = definitionLabel === definitionFacet && providedLabel === providedFacet;
+			if (definitionLabel !== providedLabel) {
+				mismatchedFacetLabels.push({
+					definitionFacet,
+					definitionLabel,
+					providedFacet,
+					providedLabel,
+					kind: "Partition",
+					type: noLabels ? "facet" : "label"
+				});
+				break;
+			} else if (definitionFacet !== providedFacet) {
+				mismatchedFacetLabels.push({
+					definitionFacet,
+					definitionLabel,
+					providedFacet,
+					providedLabel,
+					kind: "Partition",
+					type: "facet"
+				});
+				break;
+			}
+		}
+
+		if (!isCustomMatchPK) {
+			collectionDifferences.push(`The usage of key templates the partition key on index ${definitionIndexName} must be consistent across all Entities, some entities provided use template while others do not`);
+		}
+
+		if (!isCustomMatchSK) {
+			collectionDifferences.push(`The usage of key templates the sort key on index ${definitionIndexName} must be consistent across all Entities, some entities provided use template while others do not`);
+		}
+
+		if (definition.type === "clustered") {
+			for (let i = 0; i < Math.min(definition.sk.labels.length, providedIndex.sk.labels.length); i++) {
+				let definitionFacet = definition.sk.labels[i] && definition.sk.labels[i].name;
+				let definitionLabel = definition.sk.labels[i] && definition.sk.labels[i].label;
+				let providedFacet = providedIndex.sk.labels[i] && providedIndex.sk.labels[i].name;
+				let providedLabel = providedIndex.sk.labels[i] && providedIndex.sk.labels[i].label;
+				let noLabels = definitionLabel === definitionFacet && providedLabel === providedFacet;
+				if (definitionFacet === providedFacet) {
+					if (definitionLabel !== providedLabel) {
+						mismatchedFacetLabels.push({
+							definitionFacet,
+							definitionLabel,
+							providedFacet,
+							providedLabel,
+							kind: "Sort",
+							type: noLabels ? "facet" : "label"
+						});
+					}
+				} else {
+					break;
 				}
 			}
 		}
+
 		if (!matchingKeyCasing.pk) {
 			collectionDifferences.push(
 				`The pk property "casing" provided "${providedIndex.pk.casing || KeyCasing.default}" does not match established casing "${definition.pk.casing || KeyCasing.default}" on index "${providedIndexName}". Index casing options must match across all entities participating in a collection`
 			);
 		}
+
 		if (!matchingKeyCasing.sk) {
 			const definedSk = definition.sk || {};
 			const providedSk = providedIndex.sk || {};
@@ -564,6 +603,7 @@ class Service {
 				`The sk property "casing" provided "${definedSk.casing || KeyCasing.default}" does not match established casing "${providedSk.casing || KeyCasing.default}" on index "${providedIndexName}". Index casing options must match across all entities participating in a collection`
 			);
 		}
+
 		if (!indexMatch) {
 			collectionDifferences.push(
 				`Collection defined on provided index "${providedIndexName}" does not match collection established index "${definitionIndexName}". Collections must be defined on the same index across all entities within a service.`,
@@ -573,6 +613,7 @@ class Service {
 				`Partition Key composite attributes provided "${providedIndex.pk.field}" for index "${providedIndexName}" do not match established field "${definition.pk.field}" on established index "${definitionIndexName}"`,
 			);
 		}
+
 		if (!pkFacetLengthMatch) {
 			collectionDifferences.push(
 				`Partition Key composite attributes provided [${providedIndex.pk.facets.map(val => `"${val}"`).join(", ")}] for index "${providedIndexName}" do not match established composite attributes [${definition.pk.facets.map(val => `"${val}"`).join(", ")}] on established index "${definitionIndexName}"`,
@@ -583,11 +624,11 @@ class Service {
 			for (let mismatch of mismatchedFacetLabels) {
 				if (mismatch.type === "facet") {
 					collectionDifferences.push(
-						`Partition Key composite attributes provided for index "${providedIndexName}" do not match established composite attribute "${mismatch.definitionFacet}" on established index "${definitionIndexName}": "${mismatch.definitionLabel}" != "${mismatch.providedLabel}"; Composite attribute definitions must match between all members of a collection to ensure key structures will resolve to identical Partition Keys. Please ensure these composite attribute definitions are identical for all entities associated with this service.`
+						`${mismatch.kind} Key composite attributes provided for index "${providedIndexName}" do not match established composite attribute "${mismatch.definitionFacet}" on established index "${definitionIndexName}": "${mismatch.definitionLabel}" != "${mismatch.providedLabel}"; Composite attribute definitions must match between all members of a collection to ensure key structures will resolve to identical Partition Keys. Please ensure these composite attribute definitions are identical for all entities associated with this service.`
 					);
 				} else {
 					collectionDifferences.push(
-						`Partition Key composite attributes provided for index "${providedIndexName}" contain conflicting composite attribute labels for established composite attribute "${mismatch.definitionFacet}" on established index "${definitionIndexName}". Established composite attribute "${mismatch.definitionFacet}" on established index "${definitionIndexName}" was defined with label "${mismatch.definitionLabel}" while provided composite attribute "${mismatch.providedFacet}" on provided index "${providedIndexName}" is defined with label "${mismatch.providedLabel}". Composite attribute labels definitions must match between all members of a collection to ensure key structures will resolve to identical Partition Keys. Please ensure these labels definitions are identical for all entities associated with this service.`
+						`${mismatch.kind} Key composite attributes provided for index "${providedIndexName}" contain conflicting composite attribute labels for established composite attribute "${mismatch.definitionFacet || ""}" on established index "${definitionIndexName}". Established composite attribute "${mismatch.definitionFacet || ""}" on established index "${definitionIndexName}" was defined with label "${mismatch.definitionLabel}" while provided composite attribute "${mismatch.providedFacet || ""}" on provided index "${providedIndexName}" is defined with label "${mismatch.providedLabel}". Composite attribute labels definitions must match between all members of a collection to ensure key structures will resolve to identical Partition Keys. Please ensure these labels definitions are identical for all entities associated with this service.`
 					);
 				}
 
@@ -644,7 +685,7 @@ class Service {
 		}
 		const [invalidDefinition, invalidIndexMessages] = this._validateCollectionDefinition(definition, providedIndex);
 		if (invalidDefinition) {
-			throw new e.ElectroError(e.ErrorCodes.InvalidJoin, `Validation Error while joining entity, "${name}". ${invalidIndexMessages.join(", ")}`);
+			throw new e.ElectroError(e.ErrorCodes.InvalidJoin, `Validation Error while joining entity, "${name}". ${invalidIndexMessages.join("; ")}`);
 		}
 		const sharedSortKeyAttributes = [];
 		const sharedSortKeyCompositeAttributeLabels = [];

package/src/update.js

@@ -11,9 +11,19 @@ class UpdateExpression extends ExpressionState {
             subtract: new Set(),
             delete: new Set(),
         };
+        this.composites = {};
         this.seen = new Map();
         this.type = BuilderTypes.update;
     }
+    addComposite(attrName, value) {
+        if (value !== undefined) {
+            if (this.composites[attrName] === undefined || this.composites[attrName] === value) {
+                this.composites[attrName] = value;
+                return true;
+            }
+        }
+        return false;
+    }
 
     add(type, expression) {
         this.operations[type].add(expression);

package/src/where.js

@@ -47,7 +47,7 @@ class FilterExpression extends ExpressionState {
 	unsafeSet(operation, name, ...values) {
 		const {template} = FilterOperations[operation] || {};
 		if (template === undefined) {
-			throw new Error(`Invalid operation: "${operation}". Please report`);
+			throw new Error(`Invalid operation: "${operation}". Please report this issue via a bug ticket.`);
 		}
 		const names = this.setName({}, name, name);
 		const valueExpressions = values.map(value => this.setValue(name, value));