electrodb 1.4.6 → 1.4.7

package/CHANGELOG.md

@@ -104,4 +104,11 @@ All notable changes to this project will be documented in this file. Breaking ch
 
 ## [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.
+- 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electrodb",
-  "version": "1.4.6",
+  "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/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(),