pure-orm 2.2.0 → 4.0.0-0

package/examples/order/business-objects.js

@@ -1,11 +0,0 @@
-/* eslint-disable global-require */
-const getBusinessObjects = () => [
-  // These need to be imported here to get around circular dependencies
-  require('./bo/utm-source'),
-  require('./bo/order'),
-  require('./bo/line-item'),
-  require('./bo/product-variant'),
-  require('./bo/product')
-];
-
-module.exports = getBusinessObjects;

package/examples/order-more/bo/base.js

@@ -1,5 +0,0 @@
-const { createBaseBO } = require('pure-orm');
-const getBusinessObjects = require('../business-objects');
-
-const constructor = createBaseBO({ getBusinessObjects });
-module.exports = constructor;

package/examples/order-more/business-objects.js

@@ -1,26 +0,0 @@
-/* eslint-disable global-require */
-const getBusinessObjects = () => [
-  // These need to be imported here to get around circular dependencies
-  require('./bo/inventory-level'),
-  require('./bo/actual-product-variant'),
-  require('./bo/product-variant'),
-  require('./bo/product-variant-image'),
-  require('./bo/product'),
-  require('./bo/size'),
-  require('./bo/color'),
-  require('./bo/gender'),
-  require('./bo/shipment'),
-  require('./bo/shipment-actual-product-variant'),
-  require('./bo/refund'),
-  require('./bo/order'),
-  require('./bo/line-item'),
-  require('./bo/customer'),
-  require('./bo/physical-address'),
-  require('./bo/utm-source'),
-  require('./bo/utm-medium'),
-  require('./bo/parcel-line-item'),
-  require('./bo/parcel'),
-  require('./bo/parcel-event')
-];
-
-module.exports = getBusinessObjects;

package/src/bo/base-bo-collection.js

@@ -1,15 +0,0 @@
-class BaseBoCollection {
-  constructor(props = {}) {
-    this.models = props.models || [];
-  }
-
-  static get displayName() {
-    return `${this.Bo.displayName}s`;
-  }
-
-  filter(predicate) {
-    return new this.constructor({ models: this.models.filter(predicate) });
-  }
-}
-
-module.exports = BaseBoCollection;

package/src/bo/base-bo.js

@@ -1,379 +0,0 @@
-const camelCase = require('camelcase');
-
-module.exports = ({ getBusinessObjects }) =>
-  class Base {
-    constructor(props) {
-      Object.assign(this, props);
-    }
-
-    static primaryKey() {
-      const primaryKey = this.sqlColumnsData.filter(x => x.primaryKey);
-      return primaryKey.length > 0 ? primaryKey : ['id'];
-    }
-
-    static get columns() {
-      return this.sqlColumnsData.map(
-        x => x.property || camelCase(x.column || x)
-      );
-    }
-
-    static get sqlColumns() {
-      return this.sqlColumnsData.map(x => x.column || x);
-    }
-
-    static get references() {
-      return this.sqlColumnsData
-        .filter(x => x.references)
-        .reduce(
-          (accum, item) =>
-            Object.assign({}, accum, {
-              [item.property || camelCase(item.column || item)]: item.references
-            }),
-          {}
-        );
-    }
-
-    static get displayName() {
-      return camelCase(this.tableName);
-    }
-
-    static getPrefixedColumnNames() {
-      return this.sqlColumns.map(col => `${this.tableName}#${col}`);
-    }
-
-    static getSQLSelectClause() {
-      return this.getPrefixedColumnNames()
-        .map(
-          (prefixed, index) =>
-            `"${this.tableName}".${this.sqlColumns[index]} as "${prefixed}"`
-        )
-        .join(', ');
-    }
-
-    /*
-     * Make objects (based on special table#column names) from flat database
-     * return value.
-     */
-    static objectifyDatabaseResult(result) {
-      return Object.keys(result).reduce((obj, text) => {
-        const tableName =
-          text.indexOf('#') > -1 ? text.split('#')[0] : this.tableName;
-        const column = text.indexOf('#') > -1 ? text.split('#')[1] : text;
-        obj[tableName] = obj[tableName] || {};
-        obj[tableName][column] = result[text];
-        return obj;
-      }, {});
-    }
-
-    static mapToBos(objectified) {
-      return Object.keys(objectified).map(tableName => {
-        const Bo = getBusinessObjects().find(bo => bo.tableName === tableName);
-        if (!Bo) {
-          throw Error(`No business object with table name "${tableName}"`);
-        }
-        const propified = Object.keys(objectified[tableName]).reduce(
-          (obj, column) => {
-            let propertyName = Bo.columns[Bo.sqlColumns.indexOf(column)];
-            if (!propertyName) {
-              if (column.startsWith('meta_')) {
-                propertyName = camelCase(column);
-              } else {
-                throw Error(
-                  `No property name for "${column}" in business object "${
-                    Bo.displayName
-                  }". Non-spec'd columns must begin with "meta_".`
-                );
-              }
-            }
-            obj[propertyName] = objectified[tableName][column];
-            return obj;
-          },
-          {}
-        );
-        return new Bo(propified);
-      });
-    }
-
-    /*
-     * Clump array of flat objects into groups based on id of root
-     * In:
-     *  [
-     *    [Article {id: 32}, ArticleTag {id: 54}]
-     *    [Article {id: 32}, ArticleTag {id: 55}]
-     *    [Article {id: 33}, ArticleTag {id: 56}]
-     *  ]
-     * Out:
-     *  [
-     *    [
-     *      [Article {id: 32}, ArticleTag {id: 54}]
-     *      [Article {id: 32}, ArticleTag {id: 55}]
-     *    ]
-     *    [
-     *      [Article {id: 33}, ArticleTag {id: 56}]
-     *    ]
-     *  ]
-     */
-    static clumpIntoGroups(processed) {
-      const clumps = processed.reduce((accum, item) => {
-        const id = this.primaryKey()
-          .map(key => item.find(x => x.constructor === this)[key])
-          .join('@');
-        if (accum.has(id)) {
-          accum.set(id, [...accum.get(id), item]);
-        } else {
-          accum.set(id, [item]);
-        }
-        return accum;
-      }, new Map());
-      return [...clumps.values()];
-    }
-
-    /*
-     * In:
-     *  [
-     *    [Article {id: 32}, ArticleTag {id: 54}]
-     *    [Article {id: 32}, ArticleTag {id: 55}]
-     *  ]
-     * Out:
-     *  Article {id: 32, ArticleTags articleTags: [ArticleTag {id: 54}, ArticleTag {id: 55}]
-     */
-    static nestClump(clump) {
-      clump = clump.map(x => Object.values(x)); // clump wasn't actually what I have documented
-      const root = clump[0][0];
-      clump = clump.map(row => row.filter((item, index) => index !== 0));
-      const built = { [root.constructor.displayName]: root };
-
-      let nodes = [root];
-
-      // Wowzer is this both CPU and Memory inefficient
-      clump.forEach(array => {
-        array.forEach(_bo => {
-          const nodeAlreadySeen = nodes.find(
-            x =>
-              x.constructor.name === _bo.constructor.name &&
-              x.getId() === _bo.getId()
-          );
-          const bo = nodeAlreadySeen || _bo;
-          const isNodeAlreadySeen = !!nodeAlreadySeen;
-          const nodePointingToIt = nodes.find(node => {
-            const indexes = Object.values(node.constructor.references)
-              .map((x, i) => (x === bo.constructor ? i : null))
-              .filter(x => x != null);
-            if (!indexes.length) {
-              return false;
-            }
-            for (const index of indexes) {
-              const property = Object.keys(node.constructor.references)[index];
-              if (node[property] === bo.id) {
-                return true;
-              }
-            }
-            return false;
-          });
-          // For first obj type which is has an instance in nodes array,
-          // get its index in nodes array
-          const indexOfOldestParent = array.reduce((answer, obj) => {
-            if (answer != null) {
-              return answer;
-            }
-            const index = nodes.findIndex(
-              n => n.constructor === obj.constructor
-            );
-            if (index !== -1) {
-              return index;
-            }
-            return null;
-          }, null);
-          const parentHeirarchy = [
-            ...nodes.slice(0, indexOfOldestParent + 1).reverse(),
-            root
-          ];
-          const nodeItPointsTo = parentHeirarchy.find(parent => {
-            const index = Object.values(bo.constructor.references).indexOf(
-              parent.constructor
-            );
-            if (index === -1) {
-              return false;
-            }
-            const property = Object.keys(bo.constructor.references)[index];
-            return bo[property] === parent.id;
-          });
-          if (isNodeAlreadySeen) {
-            if (nodeItPointsTo && !nodePointingToIt) {
-              nodes = [bo, ...nodes];
-              return;
-            }
-            // If the nodePointingToIt (eg, parcel_event) is part of an
-            // existing collection on this node (eg, parcel) which is a
-            // nodeAlreadySeen, early return so we don't create it (parcel) on
-            // the nodePointingToIt (parcel_event), since it (parcel) has been
-            // shown to be the parent (of parcel_events).
-            const ec = bo[nodePointingToIt.BoCollection.displayName];
-            if (ec && ec.models.find(m => m === nodePointingToIt)) {
-              nodes = [bo, ...nodes];
-              return;
-            }
-          }
-          if (nodePointingToIt) {
-            nodePointingToIt[bo.constructor.displayName] = bo;
-          } else if (nodeItPointsTo) {
-            let collection = nodeItPointsTo[bo.BoCollection.displayName];
-            if (collection) {
-              collection.models.push(bo);
-            } else {
-              nodeItPointsTo[bo.BoCollection.displayName] = new bo.BoCollection(
-                { models: [bo] }
-              );
-            }
-          } else {
-            if (!bo.getId()) {
-              // If the join is fruitless; todo: add a test for this path
-              return;
-            }
-            throw Error(
-              `Could not find how this BO fits: ${JSON.stringify(bo)}`
-            );
-          }
-          nodes = [bo, ...nodes];
-        });
-      });
-
-      return built;
-    }
-
-    static createFromDatabase(_result) {
-      const result = Array.isArray(_result) ? _result : [_result];
-      const objectified = result.map(this.objectifyDatabaseResult.bind(this));
-      const boified = objectified.map(this.mapToBos.bind(this));
-      const clumps = this.clumpIntoGroups(boified);
-      const nested = clumps.map(this.nestClump.bind(this));
-      const models = nested.map(n => Object.values(n)[0]);
-      return new new this().BoCollection({ models });
-    }
-
-    static createOneFromDatabase(_result) {
-      const collection = this.createFromDatabase(_result);
-      if (collection.models.length > 1) {
-        throw Error('Got more than one.');
-      } else if (collection.models.length === 0) {
-        throw Error('Did not get one.');
-      }
-      return collection.models[0];
-    }
-
-    static createOneOrNoneFromDatabase(_result) {
-      if (!_result) {
-        return _result;
-      }
-      const collection = this.createFromDatabase(_result);
-      if (collection.models.length > 1) {
-        throw Error('Got more than one.');
-      }
-      return collection.models[0];
-    }
-
-    static createManyFromDatabase(_result) {
-      const collection = this.createFromDatabase(_result);
-      if (collection.models.length === 0) {
-        throw Error('Did not get at least one.');
-      }
-      return collection;
-    }
-
-    getSqlInsertParts() {
-      const columns = this.constructor.sqlColumns
-        .filter(
-          (column, index) => this[this.constructor.columns[index]] != null
-        )
-        .map(col => `"${col}"`)
-        .join(', ');
-      const values = this.constructor.columns
-        .map(column => this[column])
-        .filter(value => value != null);
-      const valuesVar = values.map((value, index) => `$${index + 1}`);
-      return { columns, values, valuesVar };
-    }
-
-    getSqlUpdateParts(on = 'id') {
-      const clauseArray = this.constructor.sqlColumns
-        .filter(
-          (sqlColumn, index) => this[this.constructor.columns[index]] != null
-        )
-        .map((sqlColumn, index) => `"${sqlColumn}" = $${index + 1}`);
-      const clause = clauseArray.join(', ');
-      const idVar = `$${clauseArray.length + 1}`;
-      const _values = this.constructor.columns
-        .map(column => this[column])
-        .filter(value => value != null);
-      const values = [..._values, this[on]];
-      return { clause, idVar, values };
-    }
-
-    getMatchingParts() {
-      const whereClause = this.constructor.columns
-        .map((col, index) =>
-          this[col] != null
-            ? `"${this.constructor.tableName}"."${
-                this.constructor.sqlColumns[index]
-              }"`
-            : null
-        )
-        .filter(x => x != null)
-        .map((x, i) => `${x} = $${i + 1}`)
-        .join(' AND ');
-      const values = this.constructor.columns
-        .map(col => (this[col] != null ? this[col] : null))
-        .filter(x => x != null);
-      return { whereClause, values };
-    }
-
-    // This one returns an object, which allows it to be more versatile.
-    // Todo: make this one even better and use it instead of the one above.
-    getMatchingPartsObject() {
-      const whereClause = this.constructor.columns
-        .map((col, index) =>
-          this[col] != null
-            ? `"${this.constructor.tableName}"."${
-                this.constructor.sqlColumns[index]
-              }"`
-            : null
-        )
-        .filter(x => x != null)
-        .map((x, i) => `${x} = $(${i + 1})`)
-        .join(' AND ');
-      const values = this.constructor.columns
-        .map(col => (this[col] != null ? this[col] : null))
-        .filter(x => x != null)
-        .reduce(
-          (accum, val, index) => Object.assign({}, accum, { [index + 1]: val }),
-          {}
-        );
-      return { whereClause, values };
-    }
-
-    getNewWith(sqlColumns, values) {
-      const Constructor = this.constructor;
-      const boKeys = sqlColumns.map(
-        key => Constructor.columns[Constructor.sqlColumns.indexOf(key)]
-      );
-      const boData = boKeys.reduce((data, key, index) => {
-        data[key] = values[index];
-        return data;
-      }, {});
-      return new Constructor(boData);
-    }
-
-    getValueBySqlColumn(sqlColumn) {
-      return this[
-        this.constructor.columns[this.constructor.sqlColumns.indexOf(sqlColumn)]
-      ];
-    }
-
-    // Returns unique identifier of bo (the values of the primary keys)
-    getId() {
-      return this.constructor
-        .primaryKey()
-        .map(key => this[key])
-        .join('');
-    }
-  };

package/src/dao/base-dao.js

@@ -1,146 +0,0 @@
-/*
- * A wrapper function returning the base data access abstraction.
- */
-module.exports = ({ db: closureDB, logError: closureLogError }) =>
-  class BaseDAO {
-    constructor({ db, logError } = {}) {
-      this.db = db || closureDB;
-      this.logError = logError || closureLogError;
-      this.ensureExists = this.getOrCreate; // alias
-      this.manyOrNone = this.any; // alias
-      this.errorHandler = this.errorHandler.bind(this);
-    }
-
-    /* Nice abstractions over this.db ---------------------------------------*/
-    /* ----------------------------------------------------------------------*/
-
-    one(query, values, errorHandler = this.errorHandler) {
-      return this.db
-        .many(query, values)
-        .then(rows => this.Bo.createOneFromDatabase(rows))
-        .catch(errorHandler);
-    }
-
-    oneOrNone(query, values, errorHandler = this.errorHandler) {
-      return this.db
-        .any(query, values)
-        .then(rows => this.Bo.createOneOrNoneFromDatabase(rows))
-        .catch(errorHandler);
-    }
-
-    many(query, values, errorHandler = this.errorHandler) {
-      return this.db
-        .any(query, values)
-        .then(rows => this.Bo.createManyFromDatabase(rows))
-        .catch(errorHandler);
-    }
-
-    any(query, values, errorHandler = this.errorHandler) {
-      return this.db
-        .any(query, values)
-        .then(rows => this.Bo.createFromDatabase(rows))
-        .catch(errorHandler);
-    }
-
-    none(query, values, errorHandler = this.errorHandler) {
-      return this.db
-        .none(query, values)
-        .then(() => null)
-        .catch(errorHandler);
-    }
-
-    /* Piecemeal endings if using this.db directly --------------------------*/
-    /* ----------------------------------------------------------------------*/
-
-    errorHandler(err) {
-      if (!err.name === 'QueryResultError') {
-        this.logError(err);
-      }
-      throw err;
-    }
-
-    /* Built-in basic DAO methods -------------------------------------------*/
-    /* ----------------------------------------------------------------------*/
-
-    // Standard create
-    create(bo) {
-      const { columns, values, valuesVar } = bo.getSqlInsertParts();
-      const query = `
-        INSERT INTO "${bo.constructor.tableName}" ( ${columns} )
-        VALUES ( ${valuesVar} )
-        RETURNING ${bo.constructor.getSQLSelectClause()};
-      `;
-      return this.one(query, values);
-    }
-
-    // Standard update
-    update(bo, { on = 'id' } = {}) {
-      const { clause, idVar, values } = bo.getSqlUpdateParts(on);
-      const query = `
-        UPDATE "${bo.constructor.tableName}"
-        SET ${clause}
-        WHERE "${bo.constructor.tableName}".${on} = ${idVar}
-        RETURNING ${bo.constructor.getSQLSelectClause()};
-      `;
-      return this.one(query, values);
-    }
-
-    // Standard delete
-    delete(bo) {
-      const id = bo.id;
-      const query = `
-        DELETE FROM "${bo.constructor.tableName}"
-        WHERE "${bo.constructor.tableName}".id = ${id}
-      `;
-      return this.none(query);
-    }
-
-    deleteMatching(bo) {
-      const { whereClause, values } = bo.getMatchingParts();
-      const query = `
-        DELETE FROM "${bo.constructor.tableName}"
-        WHERE ${whereClause};
-      `;
-      return this.none(query, values);
-    }
-
-    getMatching(bo) {
-      const { whereClause, values } = bo.getMatchingParts();
-      const query = `
-        SELECT ${bo.constructor.getSQLSelectClause()}
-        FROM "${bo.constructor.tableName}"
-        WHERE ${whereClause};
-      `;
-      return this.one(query, values);
-    }
-
-    getOneOrNoneMatching(bo) {
-      const { whereClause, values } = bo.getMatchingParts();
-      const query = `
-        SELECT ${bo.constructor.getSQLSelectClause()}
-        FROM "${bo.constructor.tableName}"
-        WHERE ${whereClause};
-      `;
-      return this.oneOrNone(query, values);
-    }
-
-    getAnyMatching(bo) {
-      const { whereClause, values } = bo.getMatchingParts();
-      const query = `
-        SELECT ${bo.constructor.getSQLSelectClause()}
-        FROM "${bo.constructor.tableName}"
-        WHERE ${whereClause};
-      `;
-      return this.any(query, values);
-    }
-
-    getAllMatching(bo) {
-      const { whereClause, values } = bo.getMatchingParts();
-      const query = `
-        SELECT ${bo.constructor.getSQLSelectClause()}
-        FROM "${bo.constructor.tableName}"
-        WHERE ${whereClause};
-      `;
-      return this.many(query, values);
-    }
-  };

package/src/dao/base-dao.spec.js

@@ -1,6 +0,0 @@
-const createBaseDAO = require('./base-dao');
-
-test('TODO: Add DAO tests', () => {
-  void createBaseDAO;
-  expect(1).toBe(1);
-});

package/src/util/helpers.js

@@ -1,28 +0,0 @@
-// Previously keys and values were parsed from the error string, but the
-// presence of commas in the values section messed it up.  So now, it
-// returns just gets the keys from the error message and gets the values
-// from the business object (previously did not accept a business object).
-const getColumnsValuesFromInsertErrorOLD = (error = '') => {
-  let keys, values;
-  try {
-    const results = /.*Key.*\((.*)\)=.*\((.*)\).*/g.exec(error);
-    const [, keyString, valueString] = results;
-    keys = keyString.split(', ');
-    values = valueString.split(', ');
-  } catch (_err) {}
-  return [keys, values];
-};
-void getColumnsValuesFromInsertErrorOLD;
-
-const getColumnsValuesFromInsertError = (error = '', bo) => {
-  let keys, values;
-  try {
-    const results = /.*Key.*\((.*)\)=.*\((.*)\).*/g.exec(error);
-    const [, keyString] = results;
-    keys = keyString.split(', ');
-    values = keys.map(key => bo.getValueBySqlColumn(key));
-  } catch (_err) {}
-  return [keys, values];
-};
-
-module.exports.getColumnsValuesFromInsertError = getColumnsValuesFromInsertError;

package/src/util/helpers.spec.js

@@ -1,6 +0,0 @@
-const { getColumnsValuesFromInsertError } = require('./helpers');
-
-test('TODO: Add helpers tests', () => {
-  void getColumnsValuesFromInsertError;
-  expect(1).toBe(1);
-});

package/test-utils/five/business-objects.js

@@ -1,11 +0,0 @@
-/* eslint-disable global-require */
-const getBusinessObjects = () => [
-  // These need to be imported here to get around circular dependencies
-  require('./bo/order'),
-  require('./bo/line-item'),
-  require('./bo/parcel-line-item'),
-  require('./bo/parcel'),
-  require('./bo/parcel-event')
-];
-
-module.exports = getBusinessObjects;

package/test-utils/nine/business-objects.js

@@ -1,7 +0,0 @@
-/* eslint-disable global-require */
-const getBusinessObjects = () => [
-  // These need to be imported here to get around circular dependencies
-  require('./bo/feature-switch')
-];
-
-module.exports = getBusinessObjects;

package/test-utils/six/business-objects.js

@@ -1,11 +0,0 @@
-/* eslint-disable global-require */
-const getBusinessObjects = () => [
-  // These need to be imported here to get around circular dependencies
-  require('./bo/parcel'),
-  require('./bo/parcel-line-item'),
-  require('./bo/line-item'),
-  require('./bo/order'),
-  require('./bo/customer')
-];
-
-module.exports = getBusinessObjects;

package/test-utils/twelve/business-objects.js

@@ -1,8 +0,0 @@
-/* eslint-disable global-require */
-const getBusinessObjects = () => [
-  // These need to be imported here to get around circular dependencies
-  require('./bo/prompt'),
-  require('./bo/member')
-];
-
-module.exports = getBusinessObjects;