electrodb 1.4.3 → 1.4.7

package/CHANGELOG.md

@@ -88,4 +88,27 @@ 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)
+
+## [1.4.5] = 2021-10-17
+### Fixed
+- Improved .npmignore to remove playground oriented files, and created official directory to keep playground in sync with library changes.
+
+## [1.4.6] = 2021-10-20
+### Added, Fixed
+- Adding Entity identifiers to all update operations. When primary index composite attributes were added in 1.4.4, entities were written properly but did not include the identifiers. This resulted in entities being written but not being readable without the query option `ignoreOwnership` being used.
+
+## [1.4.7] = 2021-10-20
+### Changed
+- Using `add()` update mutation now resolves to `ADD #prop :prop` update expression instead of a `SET #prop = #prop + :prop`
+
+### Fixed
+- Fixed param naming conflict during updates, when map attribute shares a name with another (separate) attribute.

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.7",
   "description": "A library to more easily create and interact with multiple entities and heretical relationships in dynamodb",
   "main": "index.js",
   "scripts": {
@@ -11,7 +11,8 @@
     "test-types": "node ./node_modules/tsd/dist/cli.js",
     "coverage": "nyc npm run test-all && nyc report --reporter=text-lcov | coveralls",
     "coverage-coveralls-local": "nyc npm run test-all-local && nyc report --reporter=text-lcov | coveralls",
-    "coverage-html-local": "nyc npm run test-all-local && nyc report --reporter=html"
+    "coverage-html-local": "nyc npm run test-all-local && nyc report --reporter=html",
+    "build:browser": "browserify playground/browser.js -o playground/bundle.js"
   },
   "repository": {
     "type": "git",
@@ -30,6 +31,7 @@
     "@types/node": "^15.6.0",
     "@types/uuid": "^8.3.0",
     "aws-sdk": "2.630.0",
+    "browserify": "^17.0.0",
     "chai": "4.2.0",
     "coveralls": "^3.1.0",
     "istanbul": "0.4.5",

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,27 @@ 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]);
+			}
+		}
+
+		update.set(this.identifiers.entity, this.getName());
+		update.set(this.identifiers.version, this.getVersion());
+
 		return {
 			UpdateExpression: update.build(),
 			ExpressionAttributeNames: update.getNames(),
@@ -1429,7 +1452,7 @@ class Entity {
 			{ ...keyAttributes },
 		);
 		const removedKeyImpact = this._expectIndexFacets(
-			{...removed},
+			{ ...removed },
 			{...keyAttributes}
 		)
 

package/src/filters.js

@@ -39,7 +39,7 @@ class FilterFactory {
 									);
 								}
 							}
-							let expression = template(attribute, prop, ...attrValues);
+							let expression = template({}, attribute, prop, ...attrValues);
 							return expression.trim();
 						};
 					},

package/src/operations.js

@@ -4,7 +4,7 @@ const v = require("./util");
 
 const deleteOperations = {
     canNest: false,
-    template: function del(attr, path, value) {
+    template: function del(options, attr, path, value) {
         let operation = "";
         let expression = "";
         switch(attr.type) {
@@ -23,19 +23,19 @@ const deleteOperations = {
 const UpdateOperations = {
     name: {
         canNest: true,
-        template: function name(attr, path) {
+        template: function name(options, attr, path) {
             return path;
         }
     },
     value: {
         canNest: true,
-        template: function value(attr, path, value) {
+        template: function value(options, attr, path, value) {
             return value;
         }
     },
     append: {
         canNest: false,
-        template: function append(attr, path, value) {
+        template: function append(options, attr, path, value) {
             let operation = "";
             let expression = "";
             switch(attr.type) {
@@ -52,7 +52,7 @@ const UpdateOperations = {
     },
     add: {
         canNest: false,
-        template: function add(attr, path, value) {
+        template: function add(options, attr, path, value) {
             let operation = "";
             let expression = "";
             switch(attr.type) {
@@ -62,8 +62,13 @@ const UpdateOperations = {
                     expression = `${path} ${value}`;
                     break;
                 case AttributeTypes.number:
-                    operation = ItemOperations.set;
-                    expression = `${path} = ${path} + ${value}`;
+                    if (options.nestedValue) {
+                        operation = ItemOperations.set;
+                        expression = `${path} = ${path} + ${value}`;
+                    } else {
+                        operation = ItemOperations.add;
+                        expression = `${path} ${value}`;
+                    }
                     break;
                 default:
                     throw new Error(`Invalid Update Attribute Operation: "ADD" Operation can only be performed on attributes with type "number", "set", or "any".`);
@@ -73,7 +78,7 @@ const UpdateOperations = {
     },
     subtract: {
         canNest: false,
-        template: function subtract(attr, path, value) {
+        template: function subtract(options, attr, path, value) {
             let operation = "";
             let expression = "";
             switch(attr.type) {
@@ -91,7 +96,7 @@ const UpdateOperations = {
     },
     set: {
         canNest: false,
-        template: function set(attr, path, value) {
+        template: function set(options, attr, path, value) {
             let operation = "";
             let expression = "";
             switch(attr.type) {
@@ -114,7 +119,7 @@ const UpdateOperations = {
     },
     remove: {
         canNest: false,
-        template: function remove(attr, ...paths) {
+        template: function remove(options, attr, ...paths) {
             let operation = "";
             let expression = "";
             switch(attr.type) {
@@ -142,86 +147,86 @@ const UpdateOperations = {
 
 const FilterOperations = {
     ne: {
-        template: function eq(attr, name, value) {
+        template: function eq(options, attr, name, value) {
             return `${name} <> ${value}`;
         },
         strict: false,
     },
     eq: {
-        template: function eq(attr, name, value) {
+        template: function eq(options, attr, name, value) {
             return `${name} = ${value}`;
         },
         strict: false,
     },
     gt: {
-        template: function gt(attr, name, value) {
+        template: function gt(options, attr, name, value) {
             return `${name} > ${value}`;
         },
         strict: false
     },
     lt: {
-        template: function lt(attr, name, value) {
+        template: function lt(options, attr, name, value) {
             return `${name} < ${value}`;
         },
         strict: false
     },
     gte: {
-        template: function gte(attr, name, value) {
+        template: function gte(options, attr, name, value) {
             return `${name} >= ${value}`;
         },
         strict: false
     },
     lte: {
-        template: function lte(attr, name, value) {
+        template: function lte(options, attr, name, value) {
             return `${name} <= ${value}`;
         },
         strict: false
     },
     between: {
-        template: function between(attr, name, value1, value2) {
+        template: function between(options, attr, name, value1, value2) {
             return `(${name} between ${value1} and ${value2})`;
         },
         strict: false
     },
     begins: {
-        template: function begins(attr, name, value) {
+        template: function begins(options, attr, name, value) {
             return `begins_with(${name}, ${value})`;
         },
         strict: false
     },
     exists: {
-        template: function exists(attr, name) {
+        template: function exists(options, attr, name) {
             return `attribute_exists(${name})`;
         },
         strict: false
     },
     notExists: {
-        template: function notExists(attr, name) {
+        template: function notExists(options, attr, name) {
             return `attribute_not_exists(${name})`;
         },
         strict: false
     },
     contains: {
-        template: function contains(attr, name, value) {
+        template: function contains(options, attr, name, value) {
             return `contains(${name}, ${value})`;
         },
         strict: false
     },
     notContains: {
-        template: function notContains(attr, name, value) {
+        template: function notContains(options, attr, name, value) {
             return `not contains(${name}, ${value})`;
         },
         strict: false
     },
     value: {
-        template: function(attr, name, value) {
+        template: function(options, attr, name, value) {
             return value;
         },
         strict: false,
         canNest: true,
     },
     name: {
-        template: function(attr, name) {
+        template: function(options, attr, name) {
             return name;
         },
         strict: false,
@@ -230,7 +235,7 @@ const FilterOperations = {
 };
 
 class ExpressionState {
-    constructor({prefix, singleOccurrence} = {}) {
+    constructor({prefix} = {}) {
         this.names = {};
         this.values = {};
         this.paths = {};
@@ -238,13 +243,9 @@ class ExpressionState {
         this.impacted = {};
         this.expression = "";
         this.prefix = prefix || "";
-        this.singleOccurrence = singleOccurrence;
     }
 
     incrementName(name) {
-        if (this.singleOccurrence) {
-            return `${this.prefix}${0}`
-        }
         if (this.counts[name] === undefined) {
             this.counts[name] = 0;
         }
@@ -372,12 +373,14 @@ class AttributeOperationProxy {
                         if (property.__is_clause__ === AttributeProxySymbol) {
                             const {paths, root, target} = property();
                             const attributeValues = [];
+                            let hasNestedValue = false;
                             for (let value of values) {
                                 value = target.format(value);
                                 // template.length is to see if function takes value argument
-                                if (template.length > 2) {
+                                if (template.length > 3) {
                                     if (seen.has(value)) {
                                         attributeValues.push(value);
+                                        hasNestedValue = true;
                                     } else {
                                         let attributeValueName = builder.setValue(target.name, value);
                                         builder.setPath(paths.json, {value, name: attributeValueName});
@@ -386,7 +389,11 @@ class AttributeOperationProxy {
                                 }
                             }
 
-                            const formatted = template(target, paths.expression, ...attributeValues);
+                            const options = {
+                                nestedValue: hasNestedValue
+                            }
+
+                            const formatted = template(options, target, paths.expression, ...attributeValues);
                             builder.setImpacted(operation, paths.json);
                             if (canNest) {
                                 seen.add(paths.expression);

package/src/update.js

@@ -3,7 +3,7 @@ const {ItemOperations, BuilderTypes} = require("./types");
 
 class UpdateExpression extends ExpressionState {
     constructor(props = {}) {
-        super({...props, singleOccurrence: true});
+        super({...props});
         this.operations = {
             set: new Set(),
             remove: new Set(),

package/.idea/aws.xml

@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="accountSettings">
-    <option name="activeProfile" value="profile:default" />
-    <option name="activeRegion" value="us-east-1" />
-    <option name="recentlyUsedProfiles">
-      <list>
-        <option value="profile:default" />
-      </list>
-    </option>
-    <option name="recentlyUsedRegions">
-      <list>
-        <option value="us-east-1" />
-      </list>
-    </option>
-  </component>
-</project>

package/.idea/electrodb.iml

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="WEB_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$">
-      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
-      <excludeFolder url="file://$MODULE_DIR$/temp" />
-      <excludeFolder url="file://$MODULE_DIR$/tmp" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

package/.idea/google-java-format.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="GoogleJavaFormatSettings">
-    <option name="enabled" value="false" />
-  </component>
-</project>

package/.idea/misc.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="JavaScriptSettings">
-    <option name="languageLevel" value="ES6" />
-  </component>
-</project>

package/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/electrodb.iml" filepath="$PROJECT_DIR$/.idea/electrodb.iml" />
-    </modules>
-  </component>
-</project>

package/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>

package/browser.js

@@ -1,53 +0,0 @@
-const ElectroDB = require("./index");
-window.Prism = window.Prism || {};
-const appDiv = document.getElementById('param-container');
-
-function printToScreen(val) {
-    const innerHtml = appDiv.innerHTML;
-    // if (window.Prism) {
-    //     console.log("fn", window.Prism.highlight, window.Prism.highlight.toString());
-    //     console.log("window.Prism.languages.json", Object.keys(window.Prism.languages), window.Prism.languages.JSON);
-    //     // appDiv.innerHTML = innerHtml + window.Prism.highlight(val, window.Prism.languages.json, 'json');
-    // } else {
-    //     console.log("FUUUU", window, window.Prism);
-    // }
-    // appDiv.innerHTML = innerHtml + Prism.highlight(val, Prism.languages.json, 'json');
-    appDiv.innerHTML = innerHtml + `<hr><pre><code class="language-json">${val}</code></pre>`;
-}
-
-function clearScreen() {
-    appDiv.innerHTML = '';
-}
-
-class Entity extends ElectroDB.Entity {
-    constructor(...params) {
-        super(...params);
-        this.client = {};
-    }
-    _queryParams(state, config) {
-        const params = super._queryParams(state, config);
-        printToScreen(JSON.stringify(params, null, 4));
-        return params;
-    }
-
-    _params(state, config) {
-        // @ts-ignore
-        const params = super._params(state, config);
-        printToScreen(JSON.stringify(params, null, 4));
-        return params;
-    }
-
-    go(type, params) {
-        printToScreen(JSON.stringify(params, null, 4));
-    }
-}
-
-class Service extends ElectroDB.Service {}
-
-
-window.ElectroDB = {
-    Entity,
-    Service,
-    printToScreen,
-    clearScreen
-};