electrodb 2.9.3 → 2.10.1

package/src/set.js

@@ -1,37 +1,33 @@
 const memberTypeToSetType = {
-    'String': 'String',
-    'Number': 'Number',
-    'NumberValue': 'Number',
-    'Binary': 'Binary',
-    'string': 'String',
-    'number': 'Number'
+  String: "String",
+  Number: "Number",
+  NumberValue: "Number",
+  Binary: "Binary",
+  string: "String",
+  number: "Number",
 };
 
 class DynamoDBSet {
-    constructor(list, type) {
-        this.wrapperName = 'Set';
-        this.type = memberTypeToSetType[type];
-        if (this.type === undefined) {
-            new Error(`Invalid Set type: ${type}`);
-        }
-        this.values = Array.from(new Set([].concat(list)));
+  constructor(list, type) {
+    this.wrapperName = "Set";
+    this.type = memberTypeToSetType[type];
+    if (this.type === undefined) {
+      new Error(`Invalid Set type: ${type}`);
     }
+    this.values = Array.from(new Set([].concat(list)));
+  }
 
-    initialize(list, validate) {
+  initialize(list, validate) {}
 
-    }
-
-    detectType() {
-        return memberTypeToSetType[typeof (this.values[0])];
-    }
+  detectType() {
+    return memberTypeToSetType[typeof this.values[0]];
+  }
 
-    validate() {
+  validate() {}
 
-    }
-
-    toJSON() {
-        return this.values;
-    }
+  toJSON() {
+    return this.values;
+  }
 }
 
-module.exports = {DynamoDBSet};
+module.exports = { DynamoDBSet };

package/src/transaction.js

@@ -1,179 +1,205 @@
-const { TableIndex, TransactionMethods } = require('./types');
-const { getEntityIdentifiers, matchToEntityAlias } = require('./entity');
-
-function cleanseCanceledData(index = TableIndex, entities, data = {}, config = {}) {
-    if (config.raw) {
-        return data;
+const { TableIndex, TransactionMethods } = require("./types");
+const { getEntityIdentifiers, matchToEntityAlias } = require("./entity");
+
+function cleanseCanceledData(
+  index = TableIndex,
+  entities,
+  data = {},
+  config = {},
+) {
+  if (config.raw) {
+    return data;
+  }
+  const identifiers = getEntityIdentifiers(entities);
+  const canceled = data.canceled || [];
+  const paramItems = config._paramItems || [];
+  const results = [];
+  for (let i = 0; i < canceled.length; i++) {
+    const { Item, Code, Message } = canceled[i] || {};
+    const paramItem = paramItems[i];
+    const code = Code || "None";
+    const rejected = code !== "None";
+    const result = {
+      rejected,
+      code,
+      message: Message,
+    };
+
+    if (Item) {
+      const entityAlias = matchToEntityAlias({
+        record: Item,
+        paramItem,
+        identifiers,
+      });
+      result.item = entities[entityAlias].formatResponse({ Item }, index, {
+        ...config,
+        pager: false,
+        parse: undefined,
+      }).data;
+    } else {
+      result.item = null;
     }
-    const identifiers = getEntityIdentifiers(entities);
-    const canceled = data.canceled || [];
-    const paramItems = config._paramItems || [];
-    const results = [];
-    for (let i = 0; i < canceled.length; i++) {
-        const { Item, Code, Message } = canceled[i] || {};
-        const paramItem = paramItems[i];
-        const code = Code || 'None';
-        const rejected = code !== 'None';
-        const result = {
-            rejected,
-            code,
-            message: Message,
-        }
-
-        if (Item) {
-            const entityAlias = matchToEntityAlias({
-                record: Item,
-                paramItem,
-                identifiers
-            });
-            result.item = entities[entityAlias].formatResponse({Item}, index, {
-                ...config,
-                pager: false,
-                parse: undefined,
-            }).data;
-        } else {
-            result.item = null;
-        }
 
-        results.push(result);
-    }
+    results.push(result);
+  }
 
-    return results;
+  return results;
 }
 
-function cleanseTransactionData(index = TableIndex, entities, data = {}, config = {}) {
-    if (config.raw) {
-        return data;
+function cleanseTransactionData(
+  index = TableIndex,
+  entities,
+  data = {},
+  config = {},
+) {
+  if (config.raw) {
+    return data;
+  }
+  const identifiers = getEntityIdentifiers(entities);
+  data.Items = data.Items || [];
+  const paramItems = config._paramItems || [];
+  const results = [];
+  for (let i = 0; i < data.Items.length; i++) {
+    const record = data.Items[i];
+    if (!record) {
+      results.push(null);
+      continue;
     }
-    const identifiers = getEntityIdentifiers(entities);
-    data.Items = data.Items || [];
-    const paramItems = config._paramItems || [];
-    const results = [];
-    for (let i = 0; i < data.Items.length; i++) {
-        const record = data.Items[i];
-        if (!record) {
-            results.push(null);
-            continue;
-        }
-
-        const paramItem = paramItems[i];
-        const entityAlias = matchToEntityAlias({paramItem, identifiers, record});
-        if (!entityAlias) {
-            continue;
-        }
-
-        // pager=false because we don't want the entity trying to parse the lastEvaluatedKey
-        let formatted = entities[entityAlias].formatResponse({ Item: record }, index, {
-            ...config,
-            pager: false,
-            parse: undefined
-        });
 
-        results.push(formatted.data);
+    const paramItem = paramItems[i];
+    const entityAlias = matchToEntityAlias({ paramItem, identifiers, record });
+    if (!entityAlias) {
+      continue;
     }
 
-    return results.map(item => ({
-        rejected: false,
-        item,
-    }));
+    // pager=false because we don't want the entity trying to parse the lastEvaluatedKey
+    let formatted = entities[entityAlias].formatResponse(
+      { Item: record },
+      index,
+      {
+        ...config,
+        pager: false,
+        parse: undefined,
+      },
+    );
+
+    results.push(formatted.data);
+  }
+
+  return results.map((item) => ({
+    rejected: false,
+    item,
+  }));
 }
 
 function createTransaction(options) {
-    const { fn, method, getEntities } = options;
-    const operations = {
-        params: (options = {}) => {
-            const paramItems = fn(getEntities());
-            const params = {
-                TransactItems: paramItems,
-            };
-
-            if (typeof options.token === 'string' && options.token.length) {
-                params['ClientRequestToken'] = options.token;
-            }
-            if (options._returnParamItems) {
-                return { params, paramItems };
-            }
-            return params;
-        },
-        go: async (options) => {
-            const driver = Object.values(getEntities())[0];
-
-            if (!driver) {
-                throw new Error('At least one entity must exist to perform a transaction');
-            }
-
-            const { params, paramItems } = operations.params({
-                ...options,
-                _returnParamItems: true
+  const { fn, method, getEntities } = options;
+  const operations = {
+    params: (options = {}) => {
+      const paramItems = fn(getEntities());
+      const params = {
+        TransactItems: paramItems,
+      };
+
+      if (typeof options.token === "string" && options.token.length) {
+        params["ClientRequestToken"] = options.token;
+      }
+      if (options._returnParamItems) {
+        return { params, paramItems };
+      }
+      return params;
+    },
+    go: async (options) => {
+      const driver = Object.values(getEntities())[0];
+
+      if (!driver) {
+        throw new Error(
+          "At least one entity must exist to perform a transaction",
+        );
+      }
+
+      const { params, paramItems } = operations.params({
+        ...options,
+        _returnParamItems: true,
+      });
+
+      let canceled = false;
+      if (paramItems.length === 0) {
+        return {
+          canceled,
+          data: [],
+        };
+      }
+      if (options && options.logger) {
+        if (!options.listeners) {
+          options.listeners = [];
+        }
+        options.listeners.push(options.logger);
+      }
+      const response = await driver.go(method, params, {
+        ...options,
+        parse: (options, data) => {
+          if (options.raw) {
+            return data;
+          } else if (data.canceled) {
+            canceled = true;
+            return cleanseCanceledData(TableIndex, getEntities(), data, {
+              ...options,
+              _isTransaction: true,
+              _paramItems: paramItems,
             });
-
-            let canceled = false;
-            if (paramItems.length === 0) {
-                return {
-                    canceled,
-                    data: [],
-                }
-            }
-
-            const response = await driver.go(method, params, {
+          } else if (data.Responses) {
+            return cleanseTransactionData(
+              TableIndex,
+              getEntities(),
+              {
+                Items: data.Responses.map((response) => response.Item),
+              },
+              {
                 ...options,
-                parse: (options, data) => {
-                    if (options.raw) {
-                        return data;
-                    } else if (data.canceled) {
-                        canceled = true;
-                        return cleanseCanceledData(TableIndex, getEntities(), data, {
-                            ...options,
-                            _isTransaction: true,
-                            _paramItems: paramItems,
-                        });
-                    } else if (data.Responses) {
-                        return cleanseTransactionData(TableIndex, getEntities(), {
-                            Items: data.Responses.map(response => response.Item)
-                        }, {
-                            ...options,
-                            _isTransaction: true,
-                            _paramItems: paramItems,
-                        });
-                    } else {
-                        return new Array(paramItems ? paramItems.length : 0).fill({
-                            item: null,
-                            code: 'None',
-                            rejected: false,
-                            message: undefined,
-                        });
-                    }
-                }
+                _isTransaction: true,
+                _paramItems: paramItems,
+              },
+            );
+          } else {
+            return new Array(paramItems ? paramItems.length : 0).fill({
+              item: null,
+              code: "None",
+              rejected: false,
+              message: undefined,
             });
+          }
+        },
+      });
 
-            return {
-                ...response,
-                canceled,
-            }
-        }
-    }
+      return {
+        ...response,
+        canceled,
+      };
+    },
+  };
 
-    return operations;
+  return operations;
 }
 
 function createWriteTransaction(entities, fn) {
-    return createTransaction({
-        fn,
-        method: TransactionMethods.transactWrite,
-        getEntities: () => entities,
-    });
+  return createTransaction({
+    fn,
+    method: TransactionMethods.transactWrite,
+    getEntities: () => entities,
+  });
 }
 
 function createGetTransaction(entities, fn) {
-    return createTransaction({
-        fn,
-        method: TransactionMethods.transactGet,
-        getEntities: () => entities,
-    });
+  return createTransaction({
+    fn,
+    method: TransactionMethods.transactGet,
+    getEntities: () => entities,
+  });
 }
 
 module.exports = {
-    createTransaction,
-    createWriteTransaction,
-    createGetTransaction,
-}
+  createTransaction,
+  createWriteTransaction,
+  createGetTransaction,
+};