electrodb 2.9.3 → 2.10.1

package/src/errors.js

@@ -65,31 +65,31 @@ const ErrorCodes = {
     code: 1009,
     section: "invalid-model",
     name: "InvalidModel",
-    sym: ErrorCode
+    sym: ErrorCode,
   },
   InvalidOptions: {
     code: 1010,
     section: "invalid-options",
     name: "InvalidOptions",
-    sym: ErrorCode
+    sym: ErrorCode,
   },
   InvalidFilter: {
     code: 1011,
     section: "filters",
     name: "InvalidFilter",
-    sym: ErrorCode
+    sym: ErrorCode,
   },
   InvalidWhere: {
     code: 1012,
     section: "where",
     name: "InvalidWhere",
-    sym: ErrorCode
+    sym: ErrorCode,
   },
   InvalidJoin: {
     code: 1013,
     section: "join",
     name: "InvalidJoin",
-    sym: ErrorCode
+    sym: ErrorCode,
   },
   DuplicateIndexFields: {
     code: 1014,
@@ -107,7 +107,7 @@ const ErrorCodes = {
     code: 1016,
     section: "invalid-attribute-watch-definition",
     name: "InvalidAttributeWatchDefinition",
-    sym: ErrorCode
+    sym: ErrorCode,
   },
   IncompatibleKeyCompositeAttributeTemplate: {
     code: 1017,
@@ -167,13 +167,13 @@ const ErrorCodes = {
     code: 2003,
     section: "missing-table",
     name: "MissingTable",
-    sym: ErrorCode
+    sym: ErrorCode,
   },
   InvalidConcurrencyOption: {
     code: 2004,
     section: "invalid-concurrency-option",
     name: "InvalidConcurrencyOption",
-    sym: ErrorCode
+    sym: ErrorCode,
   },
   InvalidPagesOption: {
     code: 2005,
@@ -215,7 +215,7 @@ const ErrorCodes = {
     code: 3001,
     section: "invalid-attribute",
     name: "InvalidAttribute",
-    sym: ErrorCode
+    sym: ErrorCode,
   },
   AWSError: {
     code: 4001,
@@ -233,7 +233,7 @@ const ErrorCodes = {
     code: 5002,
     section: "",
     name: "GeneralError",
-    sym: ErrorCode
+    sym: ErrorCode,
   },
   LastEvaluatedKey: {
     code: 5003,
@@ -258,19 +258,21 @@ const ErrorCodes = {
     section: "pager-not-unique",
     name: "NoOwnerForPager",
     sym: ErrorCode,
-  }
+  },
 };
 
 function makeMessage(message, section) {
-  return `${message} - For more detail on this error reference: ${getHelpLink(section)}`
+  return `${message} - For more detail on this error reference: ${getHelpLink(
+    section,
+  )}`;
 }
 
 class ElectroError extends Error {
-  constructor(code, message) {
-    super(message);
+  constructor(code, message, cause) {
+    super(message, { cause });
     let detail = ErrorCodes.UnknownError;
     if (code && code.sym === ErrorCode) {
-      detail = code
+      detail = code;
     }
     this._message = message;
     // this.message = `${message} - For more detail on this error reference: ${getHelpLink(detail.section)}`;
@@ -279,7 +281,7 @@ class ElectroError extends Error {
       Error.captureStackTrace(this, ElectroError);
     }
 
-    this.name = 'ElectroError';
+    this.name = "ElectroError";
     this.ref = code;
     this.code = detail.code;
     this.date = Date.now();
@@ -293,7 +295,7 @@ class ElectroValidationError extends ElectroError {
     const messages = [];
     for (let i = 0; i < errors.length; i++) {
       const error = errors[i];
-      const message = error ? (error._message || error.message) : undefined;
+      const message = error ? error._message || error.message : undefined;
       messages.push(message);
       if (error instanceof ElectroUserValidationError) {
         fields.push({
@@ -301,7 +303,7 @@ class ElectroValidationError extends ElectroError {
           index: error.index,
           reason: message,
           cause: error.cause,
-          type: 'validation'
+          type: "validation",
         });
       } else if (error instanceof ElectroAttributeValidationError) {
         fields.push({
@@ -309,22 +311,23 @@ class ElectroValidationError extends ElectroError {
           index: error.index,
           reason: message,
           cause: error.cause || error, // error | undefined
-          type: 'validation'
+          type: "validation",
         });
       } else if (message) {
         fields.push({
-          field: '',
+          field: "",
           index: error.index,
           reason: message,
           cause: error !== undefined ? error.cause || error : undefined,
-          type: 'fatal'
+          type: "fatal",
         });
       }
     }
 
-    const message = messages
-        .filter(message => typeof message === "string" && message.length)
-        .join(', ') || `Invalid value(s) provided`;
+    const message =
+      messages
+        .filter((message) => typeof message === "string" && message.length)
+        .join(", ") || `Invalid value(s) provided`;
 
     super(ErrorCodes.InvalidAttribute, message);
     this.fields = fields;
@@ -338,14 +341,22 @@ class ElectroUserValidationError extends ElectroError {
     let hasCause = false;
     if (typeof cause === "string") {
       message = cause;
-    } else if (cause !== undefined && typeof cause._message === "string" && cause._message.length) {
+    } else if (
+      cause !== undefined &&
+      typeof cause._message === "string" &&
+      cause._message.length
+    ) {
       message = cause._message;
       hasCause = true;
-    } else if (cause !== undefined && typeof cause.message === "string" && cause.message.length) {
+    } else if (
+      cause !== undefined &&
+      typeof cause.message === "string" &&
+      cause.message.length
+    ) {
       message = cause.message;
       hasCause = true;
     } else {
-        message = "Invalid value provided";
+      message = "Invalid value provided";
     }
     super(ErrorCodes.InvalidAttribute, message);
     this.field = field;
@@ -368,5 +379,5 @@ module.exports = {
   ElectroError,
   ElectroValidationError,
   ElectroUserValidationError,
-  ElectroAttributeValidationError
+  ElectroAttributeValidationError,
 };

package/src/events.js

@@ -1,42 +1,52 @@
 const e = require("./errors");
-const v = require('./validations');
+const v = require("./validations");
 
 class EventManager {
   static createSafeListener(listener) {
     if (listener === undefined) {
       return undefined;
-    } if (!v.isFunction(listener)) {
-      throw new e.ElectroError(e.ErrorCodes.InvalidListenerProvided, `Provided listener is not of type 'function'`);
+    }
+    if (!v.isFunction(listener)) {
+      throw new e.ElectroError(
+        e.ErrorCodes.InvalidListenerProvided,
+        `Provided listener is not of type 'function'`,
+      );
     } else {
       return (...params) => {
         try {
           listener(...params);
-        } catch(err) {
+        } catch (err) {
           console.error(`Error invoking user supplied listener`, err);
         }
-      }
+      };
     }
   }
 
   static normalizeListeners(listeners = []) {
     if (!Array.isArray(listeners)) {
-      throw new e.ElectroError(e.ErrorCodes.InvalidListenerProvided, `Listeners must be provided as an array of functions`);
+      throw new e.ElectroError(
+        e.ErrorCodes.InvalidListenerProvided,
+        `Listeners must be provided as an array of functions`,
+      );
     }
     return listeners
-      .map(listener => EventManager.createSafeListener(listener))
-      .filter(listener => {
+      .map((listener) => EventManager.createSafeListener(listener))
+      .filter((listener) => {
         switch (typeof listener) {
-          case 'function':
+          case "function":
             return true;
-          case 'undefined':
+          case "undefined":
             return false;
           default:
-            throw new e.ElectroError(e.ErrorCodes.InvalidListenerProvided, `Provided listener is not of type 'function`);
+            throw new e.ElectroError(
+              e.ErrorCodes.InvalidListenerProvided,
+              `Provided listener is not of type 'function`,
+            );
         }
       });
   }
 
-  constructor({listeners = []} = {}) {
+  constructor({ listeners = [] } = {}) {
     this.listeners = EventManager.normalizeListeners(listeners);
   }
 
@@ -46,14 +56,14 @@ class EventManager {
     }
 
     this.listeners = this.listeners.concat(
-      EventManager.normalizeListeners(listeners)
+      EventManager.normalizeListeners(listeners),
     );
   }
 
   trigger(event, adHocListeners = []) {
     const allListeners = [
       ...this.listeners,
-      ...EventManager.normalizeListeners(adHocListeners)
+      ...EventManager.normalizeListeners(adHocListeners),
     ];
 
     for (const listener of allListeners) {
@@ -63,5 +73,5 @@ class EventManager {
 }
 
 module.exports = {
-  EventManager
-};
+  EventManager,
+};

package/src/filterOperations.js

@@ -0,0 +1,124 @@
+const FilterOperations = {
+  escape: {
+    template: function escape(options, attr) {
+      return `${attr}`;
+    },
+    rawValue: true,
+  },
+  size: {
+    template: function size(options, attr, name) {
+      return `size(${name})`;
+    },
+    strict: false,
+  },
+  type: {
+    template: function attributeType(options, attr, name, value) {
+      return `attribute_type(${name}, ${value})`;
+    },
+    strict: false,
+  },
+  ne: {
+    template: function ne(options, attr, name, value) {
+      return `${name} <> ${value}`;
+    },
+    strict: false,
+  },
+  eq: {
+    template: function eq(options, attr, name, value) {
+      return `${name} = ${value}`;
+    },
+    strict: false,
+  },
+  gt: {
+    template: function gt(options, attr, name, value) {
+      return `${name} > ${value}`;
+    },
+    strict: false,
+  },
+  lt: {
+    template: function lt(options, attr, name, value) {
+      return `${name} < ${value}`;
+    },
+    strict: false,
+  },
+  gte: {
+    template: function gte(options, attr, name, value) {
+      return `${name} >= ${value}`;
+    },
+    strict: false,
+  },
+  lte: {
+    template: function lte(options, attr, name, value) {
+      return `${name} <= ${value}`;
+    },
+    strict: false,
+  },
+  between: {
+    template: function between(options, attr, name, value1, value2) {
+      return `(${name} between ${value1} and ${value2})`;
+    },
+    strict: false,
+  },
+  begins: {
+    template: function begins(options, attr, name, value) {
+      return `begins_with(${name}, ${value})`;
+    },
+    strict: false,
+  },
+  exists: {
+    template: function exists(options, attr, name) {
+      return `attribute_exists(${name})`;
+    },
+    strict: false,
+  },
+  notExists: {
+    template: function notExists(options, attr, name) {
+      return `attribute_not_exists(${name})`;
+    },
+    strict: false,
+  },
+  contains: {
+    template: function contains(options, attr, name, value) {
+      return `contains(${name}, ${value})`;
+    },
+    strict: false,
+  },
+  notContains: {
+    template: function notContains(options, attr, name, value) {
+      return `not contains(${name}, ${value})`;
+    },
+    strict: false,
+  },
+  value: {
+    template: function (options, attr, name, value) {
+      return value;
+    },
+    strict: false,
+    canNest: true,
+  },
+  name: {
+    template: function (options, attr, name) {
+      return name;
+    },
+    strict: false,
+    canNest: true,
+  },
+  eqOrNotExists: {
+    template: function eq(options, attr, name, value) {
+      return `(${name} = ${value} OR attribute_not_exists(${name}))`;
+    },
+    strict: false,
+  },
+  field: {
+    template: function (options, _, fieldName) {
+      return fieldName !== undefined ? `${fieldName}` : "";
+    },
+    strict: false,
+    canNest: true,
+    rawField: true,
+  },
+};
+
+module.exports = {
+  FilterOperations,
+};

package/src/filters.js

@@ -1,111 +1,109 @@
 const e = require("./errors");
-const {MethodTypes, ExpressionTypes} = require("./types");
+const { MethodTypes, ExpressionTypes } = require("./types");
 
 class FilterFactory {
-	constructor(attributes = {}, filterTypes = {}) {
-		this.attributes = { ...attributes };
-		this.filters = {
-			...filterTypes,
-		};
-	}
+  constructor(attributes = {}, filterTypes = {}) {
+    this.attributes = { ...attributes };
+    this.filters = {
+      ...filterTypes,
+    };
+  }
 
-	getExpressionType(methodType) {
-		switch (methodType) {
-			case MethodTypes.put:
-			case MethodTypes.create:
-			case MethodTypes.update:
-			case MethodTypes.patch:
-			case MethodTypes.delete:
-			case MethodTypes.get:
-			case MethodTypes.upsert:
-				return ExpressionTypes.ConditionExpression
-			default:
-				return ExpressionTypes.FilterExpression
-		}
-	}
+  getExpressionType(methodType) {
+    switch (methodType) {
+      case MethodTypes.put:
+      case MethodTypes.create:
+      case MethodTypes.update:
+      case MethodTypes.patch:
+      case MethodTypes.delete:
+      case MethodTypes.get:
+      case MethodTypes.upsert:
+        return ExpressionTypes.ConditionExpression;
+      default:
+        return ExpressionTypes.FilterExpression;
+    }
+  }
 
-	_buildFilterAttributes(setName, setValue) {
-		let attributes = {};
-		for (let [name, attribute] of Object.entries(this.attributes)) {
-			let filterAttribute = {};
-			for (let [type, {template}] of Object.entries(this.filters)) {
-				Object.defineProperty(filterAttribute, type, {
-					get: () => {
-						return (...values) => {
-							let {prop} = setName({}, name, attribute.field);
-							let attrValues = [];
-							for (let value of values) {
-								if (template.length > 1) {
-									attrValues.push(
-										setValue(name, value, name)
-									);
-								}
-							}
-							let expression = template({}, attribute, prop, ...attrValues);
-							return expression.trim();
-						};
-					},
-				});
-			}
-			attributes[name] = filterAttribute;
-		}
-		return attributes;
-	}
+  _buildFilterAttributes(setName, setValue) {
+    let attributes = {};
+    for (let [name, attribute] of Object.entries(this.attributes)) {
+      let filterAttribute = {};
+      for (let [type, { template }] of Object.entries(this.filters)) {
+        Object.defineProperty(filterAttribute, type, {
+          get: () => {
+            return (...values) => {
+              let { prop } = setName({}, name, attribute.field);
+              let attrValues = [];
+              for (let value of values) {
+                if (template.length > 1) {
+                  attrValues.push(setValue(name, value, name));
+                }
+              }
+              let expression = template({}, attribute, prop, ...attrValues);
+              return expression.trim();
+            };
+          },
+        });
+      }
+      attributes[name] = filterAttribute;
+    }
+    return attributes;
+  }
 
-	buildClause(filterFn) {
-		return (entity, state, ...params) => {
-			const type = this.getExpressionType(state.query.method);
-			const builder = state.query.filter[type];
-			let setName = (paths, name, value) => builder.setName(paths, name, value);
-			let setValue = (name, value, path) => builder.setValue(name, value, path);
-			let attributes = this._buildFilterAttributes(
-				setName,
-				setValue,
-			);
-			const expression = filterFn(attributes, ...params);
-			if (typeof expression !== "string") {
-				throw new e.ElectroError(e.ErrorCodes.InvalidFilter, "Invalid filter response. Expected result to be of type string");
-			}
-			builder.add(expression);
-			return state;
-		};
-	}
+  buildClause(filterFn) {
+    return (entity, state, ...params) => {
+      const type = this.getExpressionType(state.query.method);
+      const builder = state.query.filter[type];
+      let setName = (paths, name, value) => builder.setName(paths, name, value);
+      let setValue = (name, value, path) => builder.setValue(name, value, path);
+      let attributes = this._buildFilterAttributes(setName, setValue);
+      const expression = filterFn(attributes, ...params);
+      if (typeof expression !== "string") {
+        throw new e.ElectroError(
+          e.ErrorCodes.InvalidFilter,
+          "Invalid filter response. Expected result to be of type string",
+        );
+      }
+      builder.add(expression);
+      return state;
+    };
+  }
 
-	injectFilterClauses(clauses = {}, filters = {}) {
-		let injected = { ...clauses };
-		let filterParents = Object.entries(injected)
-			.filter(clause => {
-				let [name, { children }] = clause;
-				return children.find(child => ['go', 'commit'].includes(child));
-			})
-			.map(([name]) => name);
-		let modelFilters = Object.keys(filters);
-		let filterChildren = [];
-		for (let [name, filter] of Object.entries(filters)) {
-			filterChildren.push(name);
-			injected[name] = {
-				name: name,
-				action: this.buildClause(filter),
-				children: ["params", "go", "commit", "filter", ...modelFilters],
-			};
-		}
-		filterChildren.push("filter");
-		injected["filter"] = {
-			name: "filter",
-			action: (entity, state, fn) => {
-				return this.buildClause(fn)(entity, state);
-			},
-			children: ["params", "go", "commit", "filter", ...modelFilters],
-		};
-		for (let parent of filterParents) {
-			injected[parent] = { ...injected[parent] };
-			injected[parent].children = [
-				...filterChildren,
-				...injected[parent].children,
-			];
-		}
-		return injected;
-	}
+  injectFilterClauses(clauses = {}, filters = {}) {
+    let injected = { ...clauses };
+    let filterParents = Object.entries(injected)
+      .filter((clause) => {
+        let [name, { children }] = clause;
+        return children.find((child) => ["go", "commit"].includes(child));
+      })
+      .map(([name]) => name);
+    let modelFilters = Object.keys(filters);
+    let filterChildren = [];
+    for (let [name, filter] of Object.entries(filters)) {
+      filterChildren.push(name);
+      injected[name] = {
+        name: name,
+        action: this.buildClause(filter),
+        children: ["params", "go", "commit", "filter", ...modelFilters],
+      };
+    }
+    filterChildren.push("filter");
+    injected["filter"] = {
+      name: "filter",
+      action: (entity, state, fn) => {
+        return this.buildClause(fn)(entity, state);
+      },
+      children: ["params", "go", "commit", "filter", ...modelFilters],
+    };
+    for (let parent of filterParents) {
+      injected[parent] = { ...injected[parent] };
+      injected[parent].children = [
+        ...filterChildren,
+        ...injected[parent].children,
+      ];
+    }
+    return injected;
+  }
 }
 
 module.exports = { FilterFactory };