electrodb 2.9.3 → 2.10.1

package/src/update.js

@@ -1,107 +1,112 @@
-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) {
-        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.updates,
-            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

@@ -0,0 +1,197 @@
+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 };
+  },
+};
+
+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 };
+    },
+  },
+  name: {
+    canNest: true,
+    template: function name(options, attr, path) {
+      return path;
+    },
+  },
+  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 };
+    },
+  },
+  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 };
+    },
+  },
+  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 };
+    },
+  },
+  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,
+};
+
+module.exports = {
+  UpdateOperations,
+};

package/src/util.js

@@ -8,7 +8,7 @@ function parseJSONPath(path = "") {
   }
   path = path.replace(/\[/g, ".");
   path = path.replace(/\]/g, "");
-  return path.split(".");
+  return path.split(".").filter((part) => part !== "");
 }
 
 function genericizeJSONPath(path = "") {
@@ -34,9 +34,10 @@ function getInstanceType(instance = {}) {
 
 function getModelVersion(model = {}) {
   let nameOnRoot = model && v.isStringHasLength(model.entity);
-  let nameInModelNamespace = model && model.model && v.isStringHasLength(model.model.entity);
+  let nameInModelNamespace =
+    model && model.model && v.isStringHasLength(model.model.entity);
   if (nameInModelNamespace) {
-    return t.ModelVersions.v1
+    return t.ModelVersions.v1;
   } else if (nameOnRoot) {
     return t.ModelVersions.beta;
   } else {
@@ -44,7 +45,10 @@ function getModelVersion(model = {}) {
   }
 }
 
-function applyBetaModelOverrides(model = {}, {service = "", version = "", table = ""} = {}) {
+function applyBetaModelOverrides(
+  model = {},
+  { service = "", version = "", table = "" } = {},
+) {
   let type = getModelVersion(model);
   if (type !== t.ModelVersions.beta) {
     throw new Error("Invalid model");
@@ -76,7 +80,7 @@ function batchItems(arr = [], size) {
 }
 
 function commaSeparatedString(array = [], prefix = '"', postfix = '"') {
-  return array.map(value => `${prefix}${value}${postfix}`).join(", ");
+  return array.map((value) => `${prefix}${value}${postfix}`).join(", ");
 }
 
 function formatStringCasing(str, casing, defaultCase) {
@@ -85,9 +89,8 @@ function formatStringCasing(str, casing, defaultCase) {
   }
   let strCase = defaultCase;
   if (v.isStringHasLength(casing) && typeof t.KeyCasing[casing] === "string") {
-    strCase = t.KeyCasing.default === casing
-        ? defaultCase
-        : t.KeyCasing[casing];
+    strCase =
+      t.KeyCasing.default === casing ? defaultCase : t.KeyCasing[casing];
   }
   switch (strCase) {
     case t.KeyCasing.upper:
@@ -144,7 +147,12 @@ class BatchGetOrderMaintainer {
     if (this.enabled) {
       for (let i = 0; i < parameters.length; i++) {
         const batchParams = parameters[i];
-        const recordKeys = (batchParams && batchParams.RequestItems && batchParams.RequestItems[this.table] && batchParams.RequestItems[this.table].Keys) || [];
+        const recordKeys =
+          (batchParams &&
+            batchParams.RequestItems &&
+            batchParams.RequestItems[this.table] &&
+            batchParams.RequestItems[this.table].Keys) ||
+          [];
         for (const recordKey of recordKeys) {
           const indexMapKey = this.keyFormatter(recordKey);
           this.batchIndexMap.set(indexMapKey, this.currentSlot++);
@@ -155,40 +163,45 @@ class BatchGetOrderMaintainer {
 }
 
 function getUnique(arr1, arr2) {
-  return Array.from(new Set([
-      ...arr1,
-      ...arr2
-  ]));
+  return Array.from(new Set([...arr1, ...arr2]));
 }
 
 const cursorFormatter = {
   serialize: (key) => {
     if (!key) {
       return null;
-    } else if (typeof val !== 'string') {
+    } else if (typeof val !== "string") {
       key = JSON.stringify(key);
     }
-    return Buffer.from(key).toString('base64url');
+    return Buffer.from(key).toString("base64url");
   },
   deserialize: (cursor) => {
     if (!cursor) {
       return undefined;
-    } else if (typeof cursor !== 'string') {
-      throw new Error(`Invalid cursor provided, expected type 'string' recieved: ${JSON.stringify(cursor)}`);
+    } else if (typeof cursor !== "string") {
+      throw new Error(
+        `Invalid cursor provided, expected type 'string' recieved: ${JSON.stringify(
+          cursor,
+        )}`,
+      );
     }
     try {
-      return JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
-    } catch(err) {
-      throw new Error('Unable to parse cursor');
+      return JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+    } catch (err) {
+      throw new Error("Unable to parse cursor");
     }
-  }
-}
+  },
+};
 
-function removeFixings({prefix = '', postfix = '', value = ''} = {}) {
-  const start = value.toLowerCase().startsWith(prefix.toLowerCase()) ? prefix.length : 0;
-  const end = value.length - (value.toLowerCase().endsWith(postfix.toLowerCase()) ? postfix.length : 0);
+function removeFixings({ prefix = "", postfix = "", value = "" } = {}) {
+  const start = value.toLowerCase().startsWith(prefix.toLowerCase())
+    ? prefix.length
+    : 0;
+  const end =
+    value.length -
+    (value.toLowerCase().endsWith(postfix.toLowerCase()) ? postfix.length : 0);
 
-  let formatted = '';
+  let formatted = "";
   for (let i = start; i < end; i++) {
     formatted += value[i];
   }
@@ -196,16 +209,16 @@ function removeFixings({prefix = '', postfix = '', value = ''} = {}) {
   return formatted;
 }
 
-function addPadding({padding = {}, value = ''} = {}) {
+function addPadding({ padding = {}, value = "" } = {}) {
   return value.padStart(padding.length, padding.char);
 }
 
-function removePadding({padding = {}, value = ''} = {}) {
+function removePadding({ padding = {}, value = "" } = {}) {
   if (!padding.length || value.length >= padding.length) {
     return value;
   }
 
-  let formatted = '';
+  let formatted = "";
   let useRemaining = false;
   for (let i = 0; i < value.length; i++) {
     const char = value[i];
@@ -220,8 +233,8 @@ function removePadding({padding = {}, value = ''} = {}) {
   return formatted;
 }
 
-function shiftSortOrder(str = '', codePoint) {
-  let newString = '';
+function shiftSortOrder(str = "", codePoint) {
+  let newString = "";
   for (let i = 0; i < str.length; i++) {
     const isLast = i === str.length - 1;
     let char = str[i];
@@ -234,7 +247,7 @@ function shiftSortOrder(str = '', codePoint) {
 }
 
 function getFirstDefined(...params) {
-  return params.find(val => val !== undefined);
+  return params.find((val) => val !== undefined);
 }
 
 function regexpEscape(str) {