pure-orm 2.2.0 → 4.0.0-0

package/examples/order-more/bo/product-variant-images.js

@@ -1,9 +1,10 @@
-const { BaseBoCollection } = require('../../../src/index');
-
-class ProductVariantImages extends BaseBoCollection {
+class ProductVariantImages {
   static get Bo() {
     return require('./product-variant-image'); // eslint-disable-line
   }
+  constructor(props = {}) {
+    this.models = props.models || [];
+  }
 }
 
 module.exports = ProductVariantImages;

package/examples/order-more/bo/product-variant.js

@@ -1,4 +1,3 @@
-const Base = require('./base');
 const ProductVariants = require('./product-variants');
 const Product = require('./product');
 const ActualProductVariant = require('./actual-product-variant');
@@ -6,7 +5,11 @@ const Color = require('./color');
 const Gender = require('./gender');
 const Size = require('./size');
 
-class ProductVariant extends Base {
+class ProductVariant {
+  constructor(props) {
+    Object.assign(this, props);
+  }
+
   get BoCollection() {
     return ProductVariants;
   }

package/examples/order-more/bo/product-variants.js

@@ -1,9 +1,10 @@
-const { BaseBoCollection } = require('../../../src/index');
-
-class ProductVariants extends BaseBoCollection {
+class ProductVariants {
   static get Bo() {
     return require('./product-variant'); // eslint-disable-line
   }
+  constructor(props = {}) {
+    this.models = props.models || [];
+  }
 }
 
 module.exports = ProductVariants;

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

@@ -1,7 +1,10 @@
-const Base = require('./base');
 const Products = require('./products');
 
-class Product extends Base {
+class Product {
+  constructor(props) {
+    Object.assign(this, props);
+  }
+
   get BoCollection() {
     return Products;
   }

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

@@ -1,9 +1,10 @@
-const { BaseBoCollection } = require('../../../src/index');
-
-class Products extends BaseBoCollection {
+class Products {
   static get Bo() {
     return require('./product'); // eslint-disable-line
   }
+  constructor(props = {}) {
+    this.models = props.models || [];
+  }
 }
 
 module.exports = Products;

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

@@ -1,8 +1,11 @@
-const Base = require('./base');
 const Order = require('./order');
 const Refunds = require('./refunds');
 
-class Refund extends Base {
+class Refund {
+  constructor(props) {
+    Object.assign(this, props);
+  }
+
   get BoCollection() {
     return Refunds;
   }

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

@@ -1,9 +1,10 @@
-const { BaseBoCollection } = require('../../../src/index');
-
-class Refunds extends BaseBoCollection {
+class Refunds {
   static get Bo() {
     return require('./refund'); // eslint-disable-line
   }
+  constructor(props = {}) {
+    this.models = props.models || [];
+  }
 }
 
 module.exports = Refunds;

package/examples/order-more/bo/shipment-actual-product-variant.js

@@ -1,9 +1,12 @@
-const Base = require('./base');
 const ShipmentActualProductVariants = require('./shipment-actual-product-variants');
 const ActualProductVariant = require('./actual-product-variant');
 const Shipment = require('./shipment');
 
-class ShipmentActualProductVariant extends Base {
+class ShipmentActualProductVariant {
+  constructor(props) {
+    Object.assign(this, props);
+  }
+
   get BoCollection() {
     return ShipmentActualProductVariants;
   }

package/examples/order-more/bo/shipment-actual-product-variants.js

@@ -1,9 +1,10 @@
-const { BaseBoCollection } = require('../../../src/index');
-
-class ShipmentActualProductVariants extends BaseBoCollection {
+class ShipmentActualProductVariants {
   static get Bo() {
     return require('./shipment-actual-product-variant'); // eslint-disable-line
   }
+  constructor(props = {}) {
+    this.models = props.models || [];
+  }
 }
 
 module.exports = ShipmentActualProductVariants;

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

@@ -1,7 +1,10 @@
-const Base = require('./base');
 const Shipments = require('./shipments');
 
-class Shipment extends Base {
+class Shipment {
+  constructor(props) {
+    Object.assign(this, props);
+  }
+
   get BoCollection() {
     return Shipments;
   }

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

@@ -1,9 +1,10 @@
-const { BaseBoCollection } = require('../../../src/index');
-
-class Shipments extends BaseBoCollection {
+class Shipments {
   static get Bo() {
     return require('./shipment'); // eslint-disable-line
   }
+  constructor(props = {}) {
+    this.models = props.models || [];
+  }
 }
 
 module.exports = Shipments;

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

@@ -1,7 +1,10 @@
-const Base = require('./base');
 const Sizes = require('./sizes');
 
-class Size extends Base {
+class Size {
+  constructor(props) {
+    Object.assign(this, props);
+  }
+
   get BoCollection() {
     return Sizes;
   }

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

@@ -1,9 +1,10 @@
-const { BaseBoCollection } = require('../../../src/index');
-
-class Sizes extends BaseBoCollection {
+class Sizes {
   static get Bo() {
     return require('./size'); // eslint-disable-line
   }
+  constructor(props = {}) {
+    this.models = props.models || [];
+  }
 }
 
 module.exports = Sizes;

package/examples/order-more/bo/utm-medium.js

@@ -1,6 +1,8 @@
-const Base = require('./base');
+class UtmMedium {
+  constructor(props) {
+    Object.assign(this, props);
+  }
 
-class UtmMedium extends Base {
   static get tableName() {
     return 'utm_medium';
   }

package/examples/order-more/bo/utm-source.js

@@ -1,6 +1,8 @@
-const Base = require('./base');
+class UtmSource {
+  constructor(props) {
+    Object.assign(this, props);
+  }
 
-class UtmSource extends Base {
   static get tableName() {
     return 'utm_source';
   }

package/examples/order-more/orm.js

@@ -0,0 +1,49 @@
+const { create } = require('pure-orm');
+const InventoryLevel = require('./bo/inventory-level');
+const ActualProductVariant = require('./bo/actual-product-variant');
+const ProductVariant = require('./bo/product-variant');
+const ProductVariantImage = require('./bo/product-variant-image');
+const Product = require('./bo/product');
+const Size = require('./bo/size');
+const Color = require('./bo/color');
+const Gender = require('./bo/gender');
+const Shipment = require('./bo/shipment');
+const ShipmentActualProductVariant = require('./bo/shipment-actual-product-variant');
+const Refund = require('./bo/refund');
+const Order = require('./bo/order');
+const LineItem = require('./bo/line-item');
+const Customer = require('./bo/customer');
+const PhysicalAddress = require('./bo/physical-address');
+const UtmSource = require('./bo/utm-source');
+const UtmMedium = require('./bo/utm-medium');
+const ParcelLineItem = require('./bo/parcel-line-item');
+const Parcel = require('./bo/parcel');
+const ParcelEvent = require('./bo/parcel-event');
+const getBusinessObjects = () => [
+  InventoryLevel,
+  ActualProductVariant,
+  ProductVariant,
+  ProductVariantImage,
+  Product,
+  Size,
+  Color,
+  Gender,
+  Shipment,
+  ShipmentActualProductVariant,
+  Refund,
+  Order,
+  LineItem,
+  Customer,
+  PhysicalAddress,
+  UtmSource,
+  UtmMedium,
+  ParcelLineItem,
+  Parcel,
+  ParcelEvent
+];
+const orm = create({
+  getBusinessObjects,
+  db: void 0
+});
+module.exports = orm;
+module.exports.getBusinessObjects = getBusinessObjects;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pure-orm",
-  "version": "2.2.0",
+  "version": "4.0.0-0",
   "main": "src/index.js",
   "engines": {
     "node": ">=6"
@@ -12,12 +12,14 @@
     "test:unit:debug": "node --inspect-brk node_modules/.bin/jest --runInBand --verbose",
     "test:format": "prettier -l \"**/*.{js,json,md}\" \"!src/**/*.spec.js\" \"!coverage/**/*\"",
     "format": "prettier --write  \"**/*.{js,json,md}\" \"!src/**/*.spec.js\" \"!coverage/**/*\"",
+    "lint": "eslint .",
     "pub": "npm run test && np"
   },
   "dependencies": {
     "camelcase": "^5.0.0"
   },
   "devDependencies": {
+    "eslint": "^2.8.0",
     "jest": "^24.8.0",
     "np": "^5.0.1",
     "prettier": "^1.9.2"
@@ -46,6 +48,6 @@
     "pure",
     "toolkit",
     "business objects",
-    "data access objects"
+    "data access layer"
   ]
 }

package/src/bo.js

@@ -0,0 +1,393 @@
+const camelCase = require('camelcase');
+
+const getPrimaryKey = Bo => {
+  const primaryKey = Bo.sqlColumnsData.filter(x => x.primaryKey);
+  return primaryKey.length > 0 ? primaryKey : ['id'];
+};
+
+const getProperties = Bo => {
+  return Bo.sqlColumnsData.map(x => x.property || camelCase(x.column || x));
+};
+
+const getSqlColumns = Bo => {
+  return Bo.sqlColumnsData.map(x => x.column || x);
+};
+
+const getReferences = Bo => {
+  return Bo.sqlColumnsData
+    .filter(x => x.references)
+    .reduce(
+      (accum, item) =>
+        Object.assign({}, accum, {
+          [item.property || camelCase(item.column || item)]: item.references
+        }),
+      {}
+    );
+};
+
+const getDisplayName = Bo => {
+  return camelCase(Bo.tableName);
+};
+
+const getCollectionDisplayName = bo => {
+  return bo.BoCollection.displayName || `${getDisplayName(bo.constructor)}s`;
+};
+
+const getPrefixedColumnNames = Bo => {
+  return getSqlColumns(Bo).map(col => `${Bo.tableName}#${col}`);
+};
+
+const getColumns = Bo => {
+  return getPrefixedColumnNames(Bo)
+    .map(
+      (prefixed, index) =>
+        `"${Bo.tableName}".${getSqlColumns(Bo)[index]} as "${prefixed}"`
+    )
+    .join(', ');
+};
+
+// Returns unique identifier of bo (the values of the primary keys)
+const getId = bo => {
+  return getPrimaryKey(bo.constructor)
+    .map(key => bo[key])
+    .join('');
+};
+
+/*
+ * 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}]
+ */
+const 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 && getId(x) === getId(_bo)
+      );
+      const bo = nodeAlreadySeen || _bo;
+      const isNodeAlreadySeen = !!nodeAlreadySeen;
+      const nodePointingToIt = nodes.find(node => {
+        const indexes = Object.values(getReferences(node.constructor))
+          .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(getReferences(node.constructor))[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 = [
+        root,
+        ...nodes.slice(0, indexOfOldestParent + 1).reverse()
+      ];
+      const nodeItPointsTo = parentHeirarchy.find(parent => {
+        const index = Object.values(getReferences(bo.constructor)).indexOf(
+          parent.constructor
+        );
+        if (index === -1) {
+          return false;
+        }
+        const property = Object.keys(getReferences(bo.constructor))[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[getCollectionDisplayName(nodePointingToIt)];
+        if (ec && ec.models.find(m => m === nodePointingToIt)) {
+          nodes = [bo, ...nodes];
+          return;
+        }
+      }
+      if (nodePointingToIt) {
+        nodePointingToIt[getDisplayName(bo.constructor)] = bo;
+      } else if (nodeItPointsTo) {
+        let collection = nodeItPointsTo[getCollectionDisplayName(bo)];
+        if (collection) {
+          collection.models.push(bo);
+        } else {
+          nodeItPointsTo[getCollectionDisplayName(bo)] = new bo.BoCollection({
+            models: [bo]
+          });
+        }
+      } else {
+        if (!getId(bo)) {
+          // 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;
+};
+
+/*
+ * 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}]
+ *    ]
+ *  ]
+ */
+const clumpIntoGroups = processed => {
+  const rootBo = processed[0][0].constructor;
+  const clumps = processed.reduce((accum, item) => {
+    const id = getPrimaryKey(rootBo)
+      .map(key => item.find(x => x.constructor === rootBo)[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()];
+};
+
+const mapToBos = (objectified, getBusinessObjects) => {
+  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 = getProperties(Bo)[getSqlColumns(Bo).indexOf(column)];
+        if (!propertyName) {
+          if (column.startsWith('meta_')) {
+            propertyName = camelCase(column);
+          } else {
+            throw Error(
+              `No property name for "${column}" in business object "${getDisplayName(
+                Bo
+              )}". Non-spec'd columns must begin with "meta_".`
+            );
+          }
+        }
+        obj[propertyName] = objectified[tableName][column];
+        return obj;
+      },
+      {}
+    );
+    return new Bo(propified);
+  });
+};
+
+/*
+ * Make objects (based on special table#column names) from flat database
+ * return value.
+ */
+const objectifyDatabaseResult = result => {
+  return Object.keys(result).reduce((obj, text) => {
+    const tableName = text.split('#')[0];
+    const column = text.split('#')[1];
+    obj[tableName] = obj[tableName] || {};
+    obj[tableName][column] = result[text];
+    return obj;
+  }, {});
+};
+
+const createFromDatabase = (_result, getBusinessObjects) => {
+  const result = Array.isArray(_result) ? _result : [_result];
+  const objectified = result.map(objectifyDatabaseResult);
+  const boified = objectified.map(x => mapToBos(x, getBusinessObjects));
+  const clumps = clumpIntoGroups(boified);
+  const nested = clumps.map(nestClump);
+  const models = nested.map(n => Object.values(n)[0]);
+  return models.length ? new models[0].BoCollection({ models }) : void 0;
+};
+
+const createOneFromDatabase = (_result, getBusinessObjects) => {
+  const collection = createFromDatabase(_result, getBusinessObjects);
+  if (!collection || collection.models.length === 0) {
+    throw Error('Did not get one.');
+  } else if (collection.models.length > 1) {
+    throw Error('Got more than one.');
+  }
+  return collection.models[0];
+};
+
+const createOneOrNoneFromDatabase = (_result, getBusinessObjects) => {
+  if (!_result) {
+    return _result;
+  }
+  const collection = createFromDatabase(_result, getBusinessObjects);
+  if (collection && collection.models.length > 1) {
+    throw Error('Got more than one.');
+  }
+  return collection && collection.models[0];
+};
+
+const createManyFromDatabase = (_result, getBusinessObjects) => {
+  const collection = createFromDatabase(_result, getBusinessObjects);
+  if (!collection || collection.models.length === 0) {
+    throw Error('Did not get at least one.');
+  }
+  return collection;
+};
+
+const getSqlInsertParts = bo => {
+  const columns = getSqlColumns(bo.constructor)
+    .filter(
+      (column, index) => bo[getProperties(bo.constructor)[index]] !== void 0
+    )
+    .map(col => `"${col}"`)
+    .join(', ');
+  const values = getProperties(bo.constructor)
+    .map(property => bo[property])
+    .filter(value => value !== void 0);
+  const valuesVar = values.map((value, index) => `$${index + 1}`);
+  return { columns, values, valuesVar };
+};
+
+const getSqlUpdateParts = (bo, on = 'id') => {
+  const clauseArray = getSqlColumns(bo.constructor)
+    .filter(
+      (sqlColumn, index) => bo[getProperties(bo.constructor)[index]] !== void 0
+    )
+    .map((sqlColumn, index) => `"${sqlColumn}" = $${index + 1}`);
+  const clause = clauseArray.join(', ');
+  const idVar = `$${clauseArray.length + 1}`;
+  const _values = getProperties(bo.constructor)
+    .map(property => bo[property])
+    .filter(value => value !== void 0);
+  const values = [..._values, bo[on]];
+  return { clause, idVar, values };
+};
+
+const getMatchingParts = bo => {
+  const whereClause = getProperties(bo.constructor)
+    .map((property, index) =>
+      bo[property] != null
+        ? `"${bo.constructor.tableName}"."${
+            getSqlColumns(bo.constructor)[index]
+          }"`
+        : null
+    )
+    .filter(x => x != null)
+    .map((x, i) => `${x} = $${i + 1}`)
+    .join(' AND ');
+  const values = getProperties(bo.constructor)
+    .map(property => (bo[property] != null ? bo[property] : null))
+    .filter(x => x != null);
+  return { whereClause, values };
+};
+
+// This one returns an object, which allows it to be more versatile.
+// To-do: make this one even better and use it instead of the one above.
+const getMatchingPartsObject = bo => {
+  const whereClause = getProperties(bo.constructor)
+    .map((property, index) =>
+      bo[property] != null
+        ? `"${bo.constructor.tableName}"."${
+            getSqlColumns(bo.constructor)[index]
+          }"`
+        : null
+    )
+    .filter(x => x != null)
+    .map((x, i) => `${x} = $(${i + 1})`)
+    .join(' AND ');
+  const values = getProperties(bo.constructor)
+    .map(property => (bo[property] != null ? bo[property] : null))
+    .filter(x => x != null)
+    .reduce(
+      (accum, val, index) => Object.assign({}, accum, { [index + 1]: val }),
+      {}
+    );
+  return { whereClause, values };
+};
+
+const getNewWith = (bo, sqlColumns, values) => {
+  const Constructor = bo.constructor;
+  const boKeys = sqlColumns.map(
+    key => Constructor.properties[Constructor.sqlColumns.indexOf(key)]
+  );
+  const boData = boKeys.reduce((data, key, index) => {
+    data[key] = values[index];
+    return data;
+  }, {});
+  return new Constructor(boData);
+};
+
+const getValueBySqlColumn = (bo, sqlColumn) => {
+  return bo[
+    getProperties(bo.constructor)[
+      getSqlColumns(bo.constructor).indexOf(sqlColumn)
+    ]
+  ];
+};
+
+module.exports.getPrimaryKey = getPrimaryKey;
+module.exports.getProperties = getProperties;
+module.exports.getSqlColumns = getSqlColumns;
+module.exports.getReferences = getReferences;
+module.exports.getDisplayName = getDisplayName;
+module.exports.getPrefixedColumnNames = getPrefixedColumnNames;
+module.exports.getColumns = getColumns;
+module.exports.nestClump = nestClump;
+module.exports.clumpIntoGroups = clumpIntoGroups;
+module.exports.mapToBos = mapToBos;
+module.exports.objectifyDatabaseResult = objectifyDatabaseResult;
+module.exports.createFromDatabase = createFromDatabase;
+module.exports.createOneFromDatabase = createOneFromDatabase;
+module.exports.createOneOrNoneFromDatabase = createOneOrNoneFromDatabase;
+module.exports.createManyFromDatabase = createManyFromDatabase;
+module.exports.getSqlInsertParts = getSqlInsertParts;
+module.exports.getSqlUpdateParts = getSqlUpdateParts;
+module.exports.getMatchingParts = getMatchingParts;
+module.exports.getMatchingPartsObject = getMatchingPartsObject;
+module.exports.getNewWith = getNewWith;
+module.exports.getValueBySqlColumn = getValueBySqlColumn;
+module.exports.getId = getId;