electrodb 1.4.3 → 1.4.4

package/CHANGELOG.md

@@ -88,4 +88,12 @@ All notable changes to this project will be documented in this file. Breaking ch
 
 ## [1.4.3] - 2021-10-03
 ### Fixed
-- ElectroDB would throw when an `undefined` property was passed to query. This has been changed to not throw if a partial query on that index can be accomplished with the data provided.
+- ElectroDB would throw when an `undefined` property was passed to query. This has been changed to not throw if a partial query on that index can be accomplished with the data provided.
+
+## [1.4.4] - 2021-10-16
+### Added
+- Updates did not include composite attributes involved in primary index. Though these values cannot be changed, they should be `set` on update method calls in case the update results in an item insert. [[read more]](./README.md#updates-to-composite-attributes)
+
+## [0.11.1] - 2021-10-17
+### Patched
+- Updates did not include composite attributes involved in primary index. Though these values cannot be changed, they should be `set` on update method calls in case the update results in an item insert. [[read more]](./README.md#updates-to-composite-attributes)

package/README.md

@@ -176,6 +176,7 @@ tasks
     + [Put Record](#put-record)
     + [Batch Write Put Records](#batch-write-put-records)
     + [Update Record](#update-record)
+      - [Updates to Composite Attributes](#updates-to-composite-attributes)
       - [Update Method: Set](#update-method-set)
       - [Update Method: Remove](#update-method-remove)
       - [Update Method: Add](#update-method-add)
@@ -3129,6 +3130,99 @@ Update Method                          | Attribute Types
 [delete](#update-method-delete)        | `any` `set`                                                  | `object`
 [data](#update-method-data)            | `*`                                                          | `callback`
 
+#### Updates to Composite Attributes
+
+ElectroDB adds some constraints to update calls to prevent the accidental loss of data. If an access pattern is defined with multiple composite attributes, then ElectroDB ensure the attributes cannot be updated individually. If an attribute involved in an index composite is updated, then the index key also must be updated, and if the whole key cannot be formed by the attributes supplied to the update, then it cannot create a composite key without overwriting the old data. 
+
+This example shows why a partial update to a composite key is prevented by ElectroDB:
+
+```json
+{
+  "index": "my-gsi",
+  "pk": {
+    "field": "gsi1pk",
+    "composite": ["attr1"]
+  },
+  "sk": {
+    "field": "gsi1sk",
+    "composite": ["attr2", "attr3"]
+  }
+}
+```
+
+The above secondary index definition would generate the following index keys:
+
+```json
+{
+  "gsi1pk": "$service#attr1_value1",
+  "gsi1sk": "$entity_version#attr2_value2#attr3_value6"
+}
+```
+
+If a user attempts to update the attribute `attr2`, then ElectroDB has no way of knowing value of the attribute `attr3` or if forming the composite key without it would overwrite its value. The same problem exists if a user were to update `attr3`, ElectroDB cannot update the key without knowing each composite attribute's value. 
+
+In the event that a secondary index includes composite values from the table's primary index, ElectroDB will draw from the values supplied for the update key to address index gaps in the secondary index. For example:  
+
+For the defined indexes:
+
+```json
+{
+  "accessPattern1": {
+    "pk": {
+      "field": "pk",
+      "composite": ["attr1"]
+    },
+    "sk": {
+      "field": "sk",
+      "composite": ["attr2"]
+    }
+  },
+  "accessPattern2": {
+    "index": "my-gsi",
+    "pk": {
+      "field": "gsi1pk",
+      "composite": ["attr3"]
+    },
+    "sk": {
+      "field": "gsi1sk",
+      "composite": ["attr2", "attr4"]
+    }
+  }
+}
+```
+
+A user could update `attr4` alone because ElectroDB is able to leverage the value for `attr2` from values supplied to the `update()` method:
+
+```typescript
+entity.update({ attr1: "value1", attr2: "value2" })
+  .set({ attr4: "value4" })
+  .go();
+
+{
+  "UpdateExpression": "SET #attr4 = :attr4_u0, #gsi1sk = :gsi1sk_u0, #attr1 = :attr1_u0, #attr2 = :attr2_u0",
+  "ExpressionAttributeNames": {
+    "#attr4": "attr4",
+    "#gsi1sk": "gsi1sk",
+    "#attr1": "attr1",
+    "#attr2": "attr2"
+  },
+  "ExpressionAttributeValues": {
+    ":attr4_u0": "value6",
+    // This index was successfully built
+    ":gsi1sk_u0": "$update-edgecases_1#attr2_value2#attr4_value6",
+    ":attr1_u0": "value1",
+    ":attr2_u0": "value2"
+  },
+  "TableName": "test_table",
+  "Key": { 
+    "pk": "$service#attr1_value1", 
+    "sk": "$entity_version#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. 
+
 #### Update Method: Set
 
 The `set()` method will accept all attributes defined on the model. Provide a value to apply or replace onto the item.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electrodb",
-  "version": "1.4.3",
+  "version": "1.4.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

@@ -1003,6 +1003,7 @@ class Entity {
 	}
 
 	_makeUpdateParams(update = {}, pk = {}, sk = {}) {
+		let primaryIndexAttributes = {...pk, ...sk};
 		let modifiedAttributeValues = {};
 		let modifiedAttributeNames = {};
 		for (const path of Object.keys(update.paths)) {
@@ -1038,6 +1039,7 @@ class Entity {
 			const wasNotAlreadyModified = modifiedAttributeNames[indexKey] === undefined;
 			if (isNotTablePK && isNotTableSK && wasNotAlreadyModified) {
 				update.set(indexKey, updatedKeys[indexKey]);
+
 			}
 		}
 
@@ -1050,6 +1052,24 @@ class Entity {
 			}
 		}
 
+		// This loop adds the composite attributes to the Primary Index. This is important
+		// in the case an update results in an "upsert". We want to add the Primary Index
+		// composite attributes to the update so they will be included on the item when it
+		// is created. It is done after all of the above because it is not a true "update"
+		// so it should not be subject to the above "rules".
+		for (const primaryIndexAttribute of Object.keys(primaryIndexAttributes)) {
+			// isNotTablePK and isNotTableSK is important to check in case these properties
+			// are not also the name of the index (you cannot modify the PK or SK of an item
+			// after its creation)
+			const attribute = this.model.schema.attributes[primaryIndexAttribute];
+			const isNotTablePK = !!(attribute && attribute.field !== this.model.indexes[accessPattern].pk.field);
+			const isNotTableSK = !!(attribute && attribute.field !== this.model.indexes[accessPattern].sk.field);
+			const wasNotAlreadyModified = modifiedAttributeNames[primaryIndexAttribute] === undefined;
+			if (isNotTablePK && isNotTableSK && wasNotAlreadyModified) {
+				update.set(primaryIndexAttribute, primaryIndexAttributes[primaryIndexAttribute]);
+			}
+		}
+
 		return {
 			UpdateExpression: update.build(),
 			ExpressionAttributeNames: update.getNames(),
@@ -1429,7 +1449,7 @@ class Entity {
 			{ ...keyAttributes },
 		);
 		const removedKeyImpact = this._expectIndexFacets(
-			{...removed},
+			{ ...removed },
 			{...keyAttributes}
 		)