electrodb 2.10.0 → 2.10.2

package/src/update.js

@@ -1,108 +1,112 @@
-const { UpdateOperations } = require('./updateOperations');
-const {AttributeOperationProxy, ExpressionState} = require("./operations");
-const {ItemOperations, BuilderTypes} = require("./types");
+const { UpdateOperations } = require("./updateOperations");
+const { AttributeOperationProxy, ExpressionState } = require("./operations");
+const { ItemOperations, BuilderTypes } = require("./types");
 
 class UpdateExpression extends ExpressionState {
-    constructor(props = {}) {
-        super({...props});
-        this.operations = {
-            set: new Set(),
-            remove: new Set(),
-            add: new Set(),
-            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;
+  constructor(props = {}) {
+    super({ ...props });
+    this.operations = {
+      set: new Set(),
+      remove: new Set(),
+      add: new Set(),
+      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);
-    }
+  add(type, expression) {
+    this.operations[type].add(expression);
+  }
 
-    unadd(type, expression) {
-        this.operations[type].delete(expression);
-    }
+  unadd(type, expression) {
+    this.operations[type].delete(expression);
+  }
 
-    set(name, value, operation = ItemOperations.set, attribute) {
-        let operationToApply = operation;
-        if (operation === ItemOperations.ifNotExists) {
-            operationToApply = ItemOperations.set;
-        }
-        const seen = this.seen.get(name);
-        let n;
-        let v;
-        if (seen) {
-            n = seen.name;
-            v = seen.value;
-            this.unadd(operationToApply, seen.expression);
-
-        } else {
-            n = this.setName({}, name, name);
-            v = this.setValue(name, value);
-        }
-        let expression = `${n.prop} = ${v}`;
-        if (operation === ItemOperations.ifNotExists) {
-            expression = `${n.prop} = if_not_exists(${n.prop}, ${v})`;
-        }
-        this.seen.set(name, {
-            name: n,
-            value: v,
-            expression,
-        });
-        this.add(operationToApply, expression);
+  set(name, value, operation = ItemOperations.set, attribute) {
+    let operationToApply = operation;
+    if (operation === ItemOperations.ifNotExists) {
+      operationToApply = ItemOperations.set;
     }
-
-    remove(name) {
-        const n = this.setName({}, name, name);
-        this.add(ItemOperations.remove, `${n.prop}`);
+    const seen = this.seen.get(name);
+    let n;
+    let v;
+    if (seen) {
+      n = seen.name;
+      v = seen.value;
+      this.unadd(operationToApply, seen.expression);
+    } else {
+      n = this.setName({}, name, name);
+      v = this.setValue(name, value);
     }
+    let expression = `${n.prop} = ${v}`;
+    if (operation === ItemOperations.ifNotExists) {
+      expression = `${n.prop} = if_not_exists(${n.prop}, ${v})`;
+    }
+    this.seen.set(name, {
+      name: n,
+      value: v,
+      expression,
+    });
+    this.add(operationToApply, expression);
+  }
+
+  remove(name) {
+    const n = this.setName({}, name, name);
+    this.add(ItemOperations.remove, `${n.prop}`);
+  }
 
-    build() {
-        let expressions = [];
-        for (const type of Object.keys(this.operations)) {
-            const operations = this.operations[type];
-            if (operations.size > 0) {
-                expressions.push(`${type.toUpperCase()} ${Array.from(operations).join(", ")}`);
-            }
-        }
-        return expressions.join(" ");
+  build() {
+    let expressions = [];
+    for (const type of Object.keys(this.operations)) {
+      const operations = this.operations[type];
+      if (operations.size > 0) {
+        expressions.push(
+          `${type.toUpperCase()} ${Array.from(operations).join(", ")}`,
+        );
+      }
     }
+    return expressions.join(" ");
+  }
 }
 
 class UpdateEntity {
-    constructor(attributes = {}, operations = {}) {
-        this.attributes = {...attributes};
-        this.operations = {...operations};
-    }
+  constructor(attributes = {}, operations = {}) {
+    this.attributes = { ...attributes };
+    this.operations = { ...operations };
+  }
 
-    buildCallbackHandler(entity, state) {
-        const proxy = new AttributeOperationProxy({
-            builder: state.query.update,
-            attributes: this.attributes,
-            operations: this.operations,
-        });
+  buildCallbackHandler(entity, state) {
+    const proxy = new AttributeOperationProxy({
+      builder: state.query.update,
+      attributes: this.attributes,
+      operations: this.operations,
+    });
 
-        return (cb, ...params) => {
-            if (typeof cb !== "function") {
-                throw new Error('Update Callback must be of type "function"');
-            }
-            proxy.invokeCallback(cb, ...params);
-        }
-    }
+    return (cb, ...params) => {
+      if (typeof cb !== "function") {
+        throw new Error('Update Callback must be of type "function"');
+      }
+      proxy.invokeCallback(cb, ...params);
+    };
+  }
 }
 
 module.exports = {
-    UpdateEntity,
-    UpdateExpression
-}
+  UpdateEntity,
+  UpdateExpression,
+};

package/src/updateOperations.js

@@ -1,178 +1,197 @@
-const {AttributeTypes, ItemOperations} = require("./types");
+const { AttributeTypes, ItemOperations } = require("./types");
 
 const deleteOperations = {
-    canNest: false,
-    template: function del(options, attr, path, value) {
-        let operation = "";
-        let expression = "";
-        switch(attr.type) {
-            case AttributeTypes.any:
-            case AttributeTypes.set:
-                operation = ItemOperations.delete;
-                expression = `${path} ${value}`;
-                break;
-            default:
-                throw new Error(`Invalid Update Attribute Operation: "DELETE" Operation can only be performed on attributes with type "set" or "any".`);
-        }
-        return { operation, expression };
-    },
+  canNest: false,
+  template: function del(options, attr, path, value) {
+    let operation = "";
+    let expression = "";
+    switch (attr.type) {
+      case AttributeTypes.any:
+      case AttributeTypes.set:
+        operation = ItemOperations.delete;
+        expression = `${path} ${value}`;
+        break;
+      default:
+        throw new Error(
+          `Invalid Update Attribute Operation: "DELETE" Operation can only be performed on attributes with type "set" or "any".`,
+        );
+    }
+    return { operation, expression };
+  },
 };
 
 const UpdateOperations = {
-    ifNotExists: {
-        template: function if_not_exists(options, attr, path, value) {
-            const operation = ItemOperations.set;
-            const expression = `${path} = if_not_exists(${path}, ${value})`;
-            return {operation, expression};
-        }
+  ifNotExists: {
+    template: function if_not_exists(options, attr, path, value) {
+      const operation = ItemOperations.set;
+      const expression = `${path} = if_not_exists(${path}, ${value})`;
+      return { operation, expression };
     },
-    name: {
-        canNest: true,
-        template: function name(options, attr, path) {
-            return path;
-        }
+  },
+  name: {
+    canNest: true,
+    template: function name(options, attr, path) {
+      return path;
     },
-    value: {
-        canNest: true,
-        template: function value(options, attr, path, value) {
-            return value;
-        }
+  },
+  value: {
+    canNest: true,
+    template: function value(options, attr, path, value) {
+      return value;
     },
-    append: {
-        canNest: false,
-        template: function append(options, attr, path, value) {
-            let operation = "";
-            let expression = "";
-            switch(attr.type) {
-                case AttributeTypes.any:
-                case AttributeTypes.list:
-                    const defaultValue = options.createValue('default_value', []);
-                    expression = `${path} = list_append(if_not_exists(${path}, ${defaultValue}), ${value})`;
-                    operation = ItemOperations.set;
-                    break;
-                default:
-                    throw new Error(`Invalid Update Attribute Operation: "APPEND" Operation can only be performed on attributes with type "list" or "any".`);
-            }
-            return {operation, expression};
-        }
+  },
+  append: {
+    canNest: false,
+    template: function append(options, attr, path, value) {
+      let operation = "";
+      let expression = "";
+      switch (attr.type) {
+        case AttributeTypes.any:
+        case AttributeTypes.list:
+          const defaultValue = options.createValue("default_value", []);
+          expression = `${path} = list_append(if_not_exists(${path}, ${defaultValue}), ${value})`;
+          operation = ItemOperations.set;
+          break;
+        default:
+          throw new Error(
+            `Invalid Update Attribute Operation: "APPEND" Operation can only be performed on attributes with type "list" or "any".`,
+          );
+      }
+      return { operation, expression };
     },
-    add: {
-        canNest: false,
-        template: function add(options, attr, path, value, defaultValue) {
-            let operation = "";
-            let expression = "";
-            let type = attr.type;
-            if (type === AttributeTypes.any) {
-                type = typeof value === 'number'
-                    ? AttributeTypes.number
-                    : AttributeTypes.any;
-            }
-            switch(type) {
-                case AttributeTypes.any:
-                case AttributeTypes.set: {
-                    operation = ItemOperations.add;
-                    expression = `${path} ${value}`;
-                    break;
-                }
-                case AttributeTypes.number: {
-                    if (options.nestedValue) {
-                        operation = ItemOperations.set;
-                        expression = `${path} = ${path} + ${value}`;
-                    } else if (defaultValue !== undefined) {
-                        // const defaultValueName = options.createValue(`default_value`, defaultValue)
-                        operation = ItemOperations.set;
-                        expression = `${path} = (if_not_exists(${path}, ${defaultValue}) + ${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".`);
-            }
-            return { operation, expression };
+  },
+  add: {
+    canNest: false,
+    template: function add(options, attr, path, value, defaultValue) {
+      let operation = "";
+      let expression = "";
+      let type = attr.type;
+      if (type === AttributeTypes.any) {
+        type =
+          typeof value === "number"
+            ? AttributeTypes.number
+            : AttributeTypes.any;
+      }
+      switch (type) {
+        case AttributeTypes.any:
+        case AttributeTypes.set: {
+          operation = ItemOperations.add;
+          expression = `${path} ${value}`;
+          break;
         }
-    },
-    subtract: {
-        canNest: false,
-        template: function subtract(options, attr, path, value, defaultValue = 0) {
-            let operation = "";
-            let expression = "";
-            switch(attr.type) {
-                case AttributeTypes.any:
-                case AttributeTypes.number: {
-                    let resolvedDefaultValue;
-                    if (typeof defaultValue === 'string' && defaultValue.startsWith(':')) {
-                        resolvedDefaultValue = defaultValue;
-                    } else if (defaultValue !== undefined) {
-                        resolvedDefaultValue = options.createValue('default_value', defaultValue);
-                    } else {
-                        resolvedDefaultValue = options.createValue('default_value', 0);
-                    }
-                    // const defaultValuePath = options.createValue('default_value', resolvedDefaultValue);
-                    operation = ItemOperations.set;
-                    expression = `${path} = (if_not_exists(${path}, ${resolvedDefaultValue}) - ${value})`;
-                    break;
-                }
-                default:
-                    throw new Error(`Invalid Update Attribute Operation: "SUBTRACT" Operation can only be performed on attributes with type "number" or "any".`);
-            }
-
-            return {operation, expression};
+        case AttributeTypes.number: {
+          if (options.nestedValue) {
+            operation = ItemOperations.set;
+            expression = `${path} = ${path} + ${value}`;
+          } else if (defaultValue !== undefined) {
+            // const defaultValueName = options.createValue(`default_value`, defaultValue)
+            operation = ItemOperations.set;
+            expression = `${path} = (if_not_exists(${path}, ${defaultValue}) + ${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".`,
+          );
+      }
+      return { operation, expression };
     },
-    set: {
-        canNest: false,
-        template: function set(options, attr, path, value) {
-            let operation = "";
-            let expression = "";
-            switch(attr.type) {
-                case AttributeTypes.set:
-                case AttributeTypes.list:
-                case AttributeTypes.map:
-                case AttributeTypes.enum:
-                case AttributeTypes.string:
-                case AttributeTypes.number:
-                case AttributeTypes.boolean:
-                case AttributeTypes.any:
-                    operation = ItemOperations.set;
-                    expression = `${path} = ${value}`;
-                    break;
-                default:
-                    throw new Error(`Invalid Update Attribute Operation: "SET" Operation can only be performed on attributes with type "list", "map", "string", "number", "boolean", or "any".`);
-            }
-            return {operation, expression};
+  },
+  subtract: {
+    canNest: false,
+    template: function subtract(options, attr, path, value, defaultValue = 0) {
+      let operation = "";
+      let expression = "";
+      switch (attr.type) {
+        case AttributeTypes.any:
+        case AttributeTypes.number: {
+          let resolvedDefaultValue;
+          if (
+            typeof defaultValue === "string" &&
+            defaultValue.startsWith(":")
+          ) {
+            resolvedDefaultValue = defaultValue;
+          } else if (defaultValue !== undefined) {
+            resolvedDefaultValue = options.createValue(
+              "default_value",
+              defaultValue,
+            );
+          } else {
+            resolvedDefaultValue = options.createValue("default_value", 0);
+          }
+          // const defaultValuePath = options.createValue('default_value', resolvedDefaultValue);
+          operation = ItemOperations.set;
+          expression = `${path} = (if_not_exists(${path}, ${resolvedDefaultValue}) - ${value})`;
+          break;
         }
+        default:
+          throw new Error(
+            `Invalid Update Attribute Operation: "SUBTRACT" Operation can only be performed on attributes with type "number" or "any".`,
+          );
+      }
+
+      return { operation, expression };
     },
-    remove: {
-        canNest: false,
-        template: function remove(options, attr, ...paths) {
-            let operation = "";
-            let expression = "";
-            switch(attr.type) {
-                case AttributeTypes.set:
-                case AttributeTypes.any:
-                case AttributeTypes.list:
-                case AttributeTypes.map:
-                case AttributeTypes.string:
-                case AttributeTypes.number:
-                case AttributeTypes.boolean:
-                case AttributeTypes.enum:
-                    operation = ItemOperations.remove;
-                    expression = paths.join(", ");
-                    break;
-                default: {
-                    throw new Error(`Invalid Update Attribute Operation: "REMOVE" Operation can only be performed on attributes with type "map", "list", "string", "number", "boolean", or "any".`);
-                }
-            }
-            return {operation, expression};
+  },
+  set: {
+    canNest: false,
+    template: function set(options, attr, path, value) {
+      let operation = "";
+      let expression = "";
+      switch (attr.type) {
+        case AttributeTypes.set:
+        case AttributeTypes.list:
+        case AttributeTypes.map:
+        case AttributeTypes.enum:
+        case AttributeTypes.string:
+        case AttributeTypes.number:
+        case AttributeTypes.boolean:
+        case AttributeTypes.any:
+          operation = ItemOperations.set;
+          expression = `${path} = ${value}`;
+          break;
+        default:
+          throw new Error(
+            `Invalid Update Attribute Operation: "SET" Operation can only be performed on attributes with type "list", "map", "string", "number", "boolean", or "any".`,
+          );
+      }
+      return { operation, expression };
+    },
+  },
+  remove: {
+    canNest: false,
+    template: function remove(options, attr, ...paths) {
+      let operation = "";
+      let expression = "";
+      switch (attr.type) {
+        case AttributeTypes.set:
+        case AttributeTypes.any:
+        case AttributeTypes.list:
+        case AttributeTypes.map:
+        case AttributeTypes.string:
+        case AttributeTypes.number:
+        case AttributeTypes.boolean:
+        case AttributeTypes.enum:
+          operation = ItemOperations.remove;
+          expression = paths.join(", ");
+          break;
+        default: {
+          throw new Error(
+            `Invalid Update Attribute Operation: "REMOVE" Operation can only be performed on attributes with type "map", "list", "string", "number", "boolean", or "any".`,
+          );
         }
+      }
+      return { operation, expression };
     },
-    del: deleteOperations,
-    delete: deleteOperations
-}
+  },
+  del: deleteOperations,
+  delete: deleteOperations,
+};
 
 module.exports = {
-    UpdateOperations
-}
+  UpdateOperations,
+};