electrodb 2.10.0 → 2.10.2

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

@@ -1,126 +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,
-    }
+  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
-}
+  FilterOperations,
+};