electrodb 1.8.1 → 1.8.4

package/CHANGELOG.md

@@ -170,4 +170,16 @@ All notable changes to this project will be documented in this file. Breaking ch
 
 ## [1.8.1] - 2022-03-29
 ### Fixed
-- Solidifying default application methodology: default values for nested properties will be applied up until an undefined default occurs or default callback returns undefined
+- Solidifying default application methodology: default values for nested properties will be applied up until an undefined default occurs or default callback returns undefined
+
+## [1.8.2] - 2022-05-13
+### Fixed
+- Issue impacting the successful propagation loggers and listeners from a Service definition to Entity children
+
+## [1.8.3] - 2022-05-14
+### Changed
+- Removing validation that requires at least one attribute to be provided in a PK composite. This opens the door to static PKs if the user so chooses
+
+## [1.8.4] - 2022-05-18
+### Changed
+- Removing validation that an attribute used for one index cannot be used by another. ElectroDB will now simply validate that all composite attributes associated with an indexed field are identical, and that a field is not used as both a PK and SK in separate indexes. This change allows for LSIs to be used with ElectroDB

package/README.md

@@ -1071,7 +1071,7 @@ When using ElectroDB, indexes are referenced by their `AccessPatternName`. This
 
 All DynamoDB table start with at least a PartitionKey with an optional SortKey, this can be referred to as the _"Table Index"_. The `indexes` object requires at least the definition of this _Table Index_ **Partition Key** and (if applicable) **Sort Key**.
 
-In your model, the _Table Index_ this is expressed as an _Access Pattern_ *without* an `index` property. For Secondary Indexes, use the `index` property to define the name of the index as defined on your DynamoDB table.
+In your model, the _Table Index_ this is expressed as an _Access Pattern_ *without* an `index` property. For Secondary Indexes (both GSIs and LSIs), use the `index` property to define the name of the index as defined on your DynamoDB table.
 
 Within these _AccessPatterns_, you define the PartitionKey and (optionally) SortKeys that are present on your DynamoDB table and map the key's name on the table with the `field` property.
 
@@ -2739,7 +2739,7 @@ const MallStore = new Entity(schema, {table: "StoreDirectory"});
 #### Partition Key Composite Attributes
 All queries require (*at minimum*) the **Composite Attributes** included in its defined **Partition Key**. **Composite Attributes** you define on the **Sort Key** can be partially supplied, but must be supplied in the order they are defined.
 
-> *Important: Composite Attributes must be supplied in the order they are composed when invoking the **Access Pattern***. This is because composite attributes are used to form a concatenated key string, and if attributes supplied out of order, it is not possible to fill the gaps in that concatenation.
+> *IMPORTANT: Composite Attributes must be supplied in the order they are composed when invoking the **Access Pattern***. This is because composite attributes are used to form a concatenated key string, and if attributes supplied out of order, it is not possible to fill the gaps in that concatenation.
 
 ```javascript
 const MallStore = new Entity({
@@ -3245,7 +3245,7 @@ entity.update({ attr1: "value1", attr2: "value2" })
 }
 ```
 
-> Note: Included in the update are all attributes from the table's primary index. These values are automatically included on all updates in the event an update results in an insert. 
+> _NOTE: Included in the update are all attributes from the table's primary index. These values are automatically included on all updates in the event an update results in an insert.__
 
 #### Update Method: Set
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electrodb",
-  "version": "1.8.1",
+  "version": "1.8.4",
   "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

@@ -899,6 +899,18 @@ class Entity {
 		return {parameters, config};
 	}
 
+	addListeners(logger) {
+		this.eventManager.add(logger);
+	}
+
+	_addLogger(logger) {
+		if (validations.isFunction(logger)) {
+			this.addListeners(logger);
+		} else {
+			throw new e.ElectroError(e.ErrorCodes.InvalidLoggerProvided, `Logger must be of type function`);
+		}
+	}
+
 	_getPrimaryIndexFieldNames() {
 		let hasSortKey = this.model.lookup.indexHasSortKeys[TableIndex];
 		let accessPattern = this.model.translations.indexes.fromIndexToAccessPattern[TableIndex];
@@ -2245,22 +2257,6 @@ class Entity {
 				facets.fields.push(sk.field);
 			}
 
-			if (seenIndexFields[pk.field] !== undefined) {
-				throw new e.ElectroError(e.ErrorCodes.DuplicateIndexFields, `Partition Key (pk) on Access Pattern '${accessPattern}' references the field '${pk.field}' which is already referenced by the Access Pattern '${seenIndexFields[pk.field]}'. Fields used for indexes need to be unique to avoid conflicts.`);
-			} else {
-				seenIndexFields[pk.field] = accessPattern;
-			}
-
-			if (sk.field) {
-				if (sk.field === pk.field) {
-					throw new e.ElectroError(e.ErrorCodes.DuplicateIndexFields, `The Access Pattern '${accessPattern}' references the field '${sk.field}' as the field name for both the PK and SK. Fields used for indexes need to be unique to avoid conflicts.`);
-				} else if (seenIndexFields[sk.field] !== undefined) {
-					throw new e.ElectroError(e.ErrorCodes.DuplicateIndexFields, `Sort Key (sk) on Access Pattern '${accessPattern}' references the field '${sk.field}' which is already referenced by the Access Pattern '${seenIndexFields[sk.field]}'. Fields used for indexes need to be unique to avoid conflicts.`);
-				}else {
-					seenIndexFields[sk.field] = accessPattern;
-				}
-			}
-
 			if (Array.isArray(sk.facets)) {
 				let duplicates = pk.facets.filter(facet => sk.facets.includes(facet));
 				if (duplicates.length !== 0) {
@@ -2350,6 +2346,37 @@ class Entity {
 				facets.byField[sk.field][indexName] = sk;
 			}
 
+			if (seenIndexFields[pk.field] !== undefined) {
+				const definition = Object.values(facets.byField[pk.field]).find(definition => definition.index !== indexName)
+				const definitionsMatch = validations.stringArrayMatch(pk.facets, definition.facets);
+				if (!definitionsMatch) {
+					throw new e.ElectroError(e.ErrorCodes.InconsistentIndexDefinition, `Partition Key (pk) on Access Pattern '${u.formatIndexNameForDisplay(accessPattern)}' is defined with the composite attribute(s) ${u.commaSeparatedString(pk.facets)}, but the accessPattern '${u.formatIndexNameForDisplay(definition.index)}' defines this field with the composite attributes ${u.commaSeparatedString(definition.facets)}'. Key fields must have the same composite attribute definitions across all indexes they are involved with`);
+				}
+				seenIndexFields[pk.field].push({accessPattern, type: 'pk'});
+			} else {
+				seenIndexFields[pk.field] = [];
+				seenIndexFields[pk.field].push({accessPattern, type: 'pk'});
+			}
+
+			if (sk.field) {
+				if (sk.field === pk.field) {
+					throw new e.ElectroError(e.ErrorCodes.DuplicateIndexFields, `The Access Pattern '${u.formatIndexNameForDisplay(accessPattern)}' references the field '${sk.field}' as the field name for both the PK and SK. Fields used for indexes need to be unique to avoid conflicts.`);
+				} else if (seenIndexFields[sk.field] !== undefined) {
+					const isAlsoDefinedAsPK = seenIndexFields[sk.field].find(field => field.type === "pk");
+					if (isAlsoDefinedAsPK) {
+						throw new e.ElectroError(e.ErrorCodes.InconsistentIndexDefinition, `The Sort Key (sk) on Access Pattern '${u.formatIndexNameForDisplay(accessPattern)}' references the field '${pk.field}' which is already referenced by the Access Pattern(s) '${u.formatIndexNameForDisplay(isAlsoDefinedAsPK.accessPattern)}' as a Partition Key. Fields mapped to Partition Keys cannot be also mapped to Sort Keys.`);
+					}
+					const definition = Object.values(facets.byField[sk.field]).find(definition => definition.index !== indexName)
+					const definitionsMatch = validations.stringArrayMatch(sk.facets, definition.facets);
+					if (!definitionsMatch) {
+						throw new e.ElectroError(e.ErrorCodes.DuplicateIndexFields, `Sort Key (sk) on Access Pattern '${u.formatIndexNameForDisplay(accessPattern)}' is defined with the composite attribute(s) ${u.commaSeparatedString(sk.facets)}, but the accessPattern '${u.formatIndexNameForDisplay(definition.index)}' defines this field with the composite attributes ${u.commaSeparatedString(definition.facets)}'. Key fields must have the same composite attribute definitions across all indexes they are involved with`);
+					}
+					seenIndexFields[sk.field].push({accessPattern, type: 'sk'});
+				} else {
+					seenIndexFields[sk.field] = [];
+					seenIndexFields[sk.field].push({accessPattern, type: 'sk'});
+				}
+			}
 
 			attributes.forEach(({index, type, name}, j) => {
 				let next = attributes[j + 1] !== undefined ? attributes[j + 1].name : "";

package/src/errors.js

@@ -139,6 +139,12 @@ const ErrorCodes = {
     name: "InvalidClientProvided",
     sym: ErrorCode,
   },
+  InconsistentIndexDefinition: {
+    code: 1022,
+    section: "inconsistent-index-definition",
+    name: "InvalidClientProvided",
+    sym: ErrorCode,
+  },
   MissingAttribute: {
     code: 2001,
     section: "missing-attribute",

package/src/service.js

@@ -191,6 +191,14 @@ class Service {
 			entity._setClient(options.client);
 		}
 
+		if (options.logger) {
+			entity._addLogger(options.logger);
+		}
+
+		if (options.listeners) {
+			entity.addListeners(options.listeners);
+		}
+
 		if (this._modelVersion === ModelVersions.beta && this.service.version) {
 			entity.model.version = this.service.version;
 		}

package/src/util.js

@@ -75,8 +75,8 @@ function batchItems(arr = [], size) {
   return batched;
 }
 
-function commaSeparatedString(array = []) {
-  return array.map(value => `"${value}"`).join(", ");
+function commaSeparatedString(array = [], prefix = '"', postfix = '"') {
+  return array.map(value => `${prefix}${value}${postfix}`).join(", ");
 }
 
 function formatStringCasing(str, casing, defaultCase) {

package/src/validations.js

@@ -81,7 +81,6 @@ const Index = {
 				},
 				facets: {
 					type: ["array", "string"],
-					minItems: 1,
 					items: {
 						type: "string",
 					},
@@ -89,7 +88,6 @@ const Index = {
 				},
 				composite: {
 					type: ["array"],
-					minItems: 1,
 					items: {
 						type: "string",
 					},