@abedmurrar/objection 0.0.0-stage → 4.0.0-alpha.0

package/lib/model/graph/ModelGraphNode.js

@@ -0,0 +1,240 @@
+'use strict';
+
+const { ModelGraphEdge } = require('./ModelGraphEdge');
+const { isNumber } = require('../../utils/objectUtils');
+
+const NOT_CALCULATED = {};
+
+class ModelGraphNode {
+  constructor(modelClass, obj) {
+    this.modelClass = modelClass;
+    this.obj = obj;
+    this.edges = [];
+    this.userData = {};
+    this.hasId = obj.$hasId();
+    this.uid = obj[modelClass.uidProp];
+
+    // These are also included in `edges`. These are simply
+    // shortcuts for commonly used edges.
+    this.refEdges = [];
+    this.parentEdge = null;
+
+    // These are calculated lazily.
+    this._relationPath = NOT_CALCULATED;
+    this._relationPathKey = NOT_CALCULATED;
+
+    this._dataPath = NOT_CALCULATED;
+    this._dataPathKey = NOT_CALCULATED;
+
+    this._idPath = NOT_CALCULATED;
+    this._idPathKey = NOT_CALCULATED;
+  }
+
+  get isReference() {
+    return this.reference !== undefined;
+  }
+
+  get isDbReference() {
+    return this.dbReference !== undefined;
+  }
+
+  get reference() {
+    return this.obj[this.modelClass.uidRefProp];
+  }
+
+  get dbReference() {
+    return this.obj[this.modelClass.dbRefProp];
+  }
+
+  get parentNode() {
+    if (this.parentEdge) {
+      return this.parentEdge.ownerNode;
+    } else {
+      return null;
+    }
+  }
+
+  get indexInRelation() {
+    if (this.parentEdge) {
+      return this.parentEdge.relationIndex;
+    } else {
+      return null;
+    }
+  }
+
+  get relationName() {
+    if (this.parentEdge) {
+      return this.parentEdge.relation.name;
+    } else {
+      return null;
+    }
+  }
+
+  get relationPath() {
+    if (this._relationPath === NOT_CALCULATED) {
+      this._relationPath = this._createRelationPath();
+    }
+
+    return this._relationPath;
+  }
+
+  get relationPathKey() {
+    if (this._relationPathKey === NOT_CALCULATED) {
+      this._relationPathKey = this._createRelationPathKey();
+    }
+
+    return this._relationPathKey;
+  }
+
+  get dataPath() {
+    if (this._dataPath === NOT_CALCULATED) {
+      this._dataPath = this._createDataPath();
+    }
+
+    return this._dataPath;
+  }
+
+  get dataPathKey() {
+    if (this._dataPathKey === NOT_CALCULATED) {
+      this._dataPathKey = this._createDataPathKey();
+    }
+
+    return this._dataPathKey;
+  }
+
+  get idPath() {
+    if (this._idPath === NOT_CALCULATED) {
+      this._idPath = this._createIdPath();
+    }
+
+    return this._idPath;
+  }
+
+  get idPathKey() {
+    if (this._idPathKey === NOT_CALCULATED) {
+      this._idPathKey = this._createIdPathKey();
+    }
+
+    return this._idPathKey;
+  }
+
+  /**
+   * If this node is a reference, returns the referred node.
+   */
+  get referencedNode() {
+    for (const edge of this.refEdges) {
+      if (edge.refType === ModelGraphEdge.ReferenceType.Object && edge.isOwnerNode(this)) {
+        return edge.relatedNode;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Returns all nodes that are references to this node.
+   */
+  get referencingNodes() {
+    const nodes = [];
+
+    for (const edge of this.refEdges) {
+      if (edge.refType === ModelGraphEdge.ReferenceType.Object && edge.isRelatedNode(this)) {
+        nodes.push(edge.ownerNode);
+      }
+    }
+
+    return nodes;
+  }
+
+  get descendantRelationNodes() {
+    return this._collectDescendantRelationNodes([]);
+  }
+
+  removeEdge(edge) {
+    // Don't allow removing parent edges for now. It would
+    // cause all kinds of cache invalidation.
+    if (edge === this.parentEdge) {
+      throw new Error('cannot remove parent edge');
+    }
+
+    this.edges = this.edges.filter((it) => it !== edge);
+    this.refEdges = this.refEdges.filter((it) => it !== edge);
+  }
+
+  _collectDescendantRelationNodes(nodes) {
+    for (const edge of this.edges) {
+      if (edge.type === ModelGraphEdge.Type.Relation && edge.isOwnerNode(this)) {
+        nodes.push(edge.relatedNode);
+        edge.relatedNode._collectDescendantRelationNodes(nodes);
+      }
+    }
+
+    return nodes;
+  }
+
+  _createRelationPath() {
+    if (this.parentNode === null) {
+      return [];
+    } else {
+      return [...this.parentNode.relationPath, this.relationName];
+    }
+  }
+
+  _createRelationPathKey() {
+    return this.relationPath.join('.');
+  }
+
+  _createDataPath() {
+    if (this.parentEdge === null) {
+      return [];
+    } else if (this.parentEdge.relation.isOneToOne()) {
+      return [...this.parentNode.dataPath, this.relationName];
+    } else {
+      return [...this.parentNode.dataPath, this.relationName, this.indexInRelation];
+    }
+  }
+
+  _createDataPathKey() {
+    const dataPathKey = this.dataPath.reduce((key, it) => {
+      if (isNumber(it)) {
+        return `${key}[${it}]`;
+      } else {
+        return key ? `${key}.${it}` : it;
+      }
+    }, '');
+
+    return dataPathKey ? '.' + dataPathKey : dataPathKey;
+  }
+
+  _createIdPath() {
+    if (!this.obj.$hasId()) {
+      return null;
+    }
+
+    if (this.parentEdge === null) {
+      return [this.obj.$idKey()];
+    } else {
+      const path = this.parentNode.idPath;
+
+      if (path === null) {
+        return null;
+      }
+
+      return [...path, this.relationName, this.obj.$idKey()];
+    }
+  }
+
+  _createIdPathKey() {
+    const idPath = this.idPath;
+
+    if (idPath) {
+      return this.idPath.join('.');
+    } else {
+      return null;
+    }
+  }
+}
+
+module.exports = {
+  ModelGraphNode,
+};

package/lib/model/inheritModel.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const cache = new Map();
+
+function inheritModel(modelClass) {
+  let inherit = cache.get(modelClass.name);
+
+  if (!inherit) {
+    inherit = createClassInheritor(modelClass.name);
+    cache.set(modelClass.name, inherit);
+  }
+
+  return inherit(modelClass);
+}
+
+function createClassInheritor(className) {
+  return new Function(
+    'BaseClass',
+    `
+    'use strict';
+    return class ${className} extends BaseClass {}
+  `,
+  );
+}
+
+module.exports = {
+  inheritModel,
+};

package/lib/model/modelBindKnex.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const { inheritModel } = require('./inheritModel');
+const { staticHiddenProps } = require('./modelUtils');
+const { defineNonEnumerableProperty } = require('./modelUtils');
+
+function bindKnex(modelClass, knex) {
+  let BoundModelClass = getBoundModelFromCache(modelClass, knex);
+
+  if (BoundModelClass === null) {
+    BoundModelClass = inheritModel(modelClass);
+    BoundModelClass = copyHiddenProperties(modelClass, BoundModelClass);
+
+    BoundModelClass.knex(knex);
+
+    BoundModelClass = putBoundModelToCache(modelClass, BoundModelClass, knex);
+    BoundModelClass = bindRelations(modelClass, BoundModelClass, knex);
+  }
+
+  return BoundModelClass;
+}
+
+function getBoundModelFromCache(modelClass, knex) {
+  const cache = getCache(knex);
+  const cacheKey = modelClass.uniqueTag();
+
+  return cache.get(cacheKey) || null;
+}
+
+function getCache(knex) {
+  if (!knex.$$objection) {
+    createCache(knex);
+  }
+
+  return knex.$$objection.boundModels;
+}
+
+function createCache(knex) {
+  defineNonEnumerableProperty(knex, '$$objection', {
+    boundModels: new Map(),
+  });
+}
+
+function copyHiddenProperties(modelClass, BoundModelClass) {
+  for (const prop of staticHiddenProps) {
+    // $$relations and $$relationArray are handled in separately.
+    if (modelClass.hasOwnProperty(prop) && prop !== '$$relations' && prop !== '$$relationArray') {
+      defineNonEnumerableProperty(BoundModelClass, prop, modelClass[prop]);
+    }
+  }
+
+  return BoundModelClass;
+}
+
+function putBoundModelToCache(modelClass, BoundModelClass, knex) {
+  const cache = getCache(knex);
+  const cacheKey = modelClass.uniqueTag();
+
+  cache.set(cacheKey, BoundModelClass);
+  return BoundModelClass;
+}
+
+function bindRelations(modelClass, BoundModelClass, knex) {
+  const boundRelations = Object.create(null);
+  const boundRelationArray = [];
+
+  for (const relationName of modelClass.getRelationNames()) {
+    const relation = modelClass.getRelation(relationName);
+    const boundRelation = relation.bindKnex(knex);
+
+    boundRelations[relation.name] = boundRelation;
+    boundRelationArray.push(boundRelation);
+  }
+
+  defineNonEnumerableProperty(BoundModelClass, '$$relations', boundRelations);
+  defineNonEnumerableProperty(BoundModelClass, '$$relationArray', boundRelationArray);
+
+  return BoundModelClass;
+}
+
+module.exports = {
+  bindKnex,
+};

package/lib/model/modelClone.js

@@ -0,0 +1,121 @@
+'use strict';
+
+const { isObject, cloneDeep } = require('../utils/objectUtils');
+const { hiddenProps } = require('./modelUtils');
+const { defineNonEnumerableProperty } = require('./modelUtils');
+const { isInternalProp } = require('../utils/internalPropUtils');
+
+function clone(model, shallow, stripInternal) {
+  let clone = null;
+
+  const omitFromJson = model.$omitFromJson();
+  const omitFromDatabaseJson = model.$omitFromDatabaseJson();
+
+  if (!shallow && !stripInternal) {
+    clone = cloneSimple(model);
+  } else {
+    clone = cloneWithOpt(model, shallow, stripInternal);
+  }
+
+  if (omitFromJson) {
+    clone.$omitFromJson(omitFromJson);
+  }
+
+  if (omitFromDatabaseJson) {
+    clone.$omitFromDatabaseJson(omitFromDatabaseJson);
+  }
+
+  clone = copyHiddenProps(model, clone);
+  return clone;
+}
+
+function cloneSimple(model) {
+  const clone = new model.constructor();
+  const keys = Object.keys(model);
+
+  for (let i = 0, l = keys.length; i < l; ++i) {
+    const key = keys[i];
+    const value = model[key];
+
+    if (isObject(value)) {
+      clone[key] = cloneObject(value);
+    } else {
+      clone[key] = value;
+    }
+  }
+
+  return clone;
+}
+
+function cloneWithOpt(model, shallow, stripInternal) {
+  const clone = new model.constructor();
+  const keys = Object.keys(model);
+  const relationNames = model.constructor.getRelationNames();
+
+  for (let i = 0, l = keys.length; i < l; ++i) {
+    const key = keys[i];
+    const value = model[key];
+
+    if (shallow && relationNames.includes(key)) {
+      // The constructor may have given default values for relations.
+      delete clone[key];
+      continue;
+    }
+
+    if (stripInternal && isInternalProp(key)) {
+      continue;
+    }
+
+    if (isObject(value)) {
+      clone[key] = cloneObject(value);
+    } else {
+      clone[key] = value;
+    }
+  }
+
+  return clone;
+}
+
+function cloneObject(value) {
+  if (Array.isArray(value)) {
+    return cloneArray(value);
+  } else if (value.$isObjectionModel) {
+    return clone(value, false, false);
+  } else if (Buffer.isBuffer(value)) {
+    return new Buffer(value);
+  } else {
+    return cloneDeep(value);
+  }
+}
+
+function cloneArray(value) {
+  const ret = new Array(value.length);
+
+  for (let i = 0, l = ret.length; i < l; ++i) {
+    const item = value[i];
+
+    if (isObject(item)) {
+      ret[i] = cloneObject(item);
+    } else {
+      ret[i] = item;
+    }
+  }
+
+  return ret;
+}
+
+function copyHiddenProps(model, clone) {
+  for (let i = 0, l = hiddenProps.length; i < l; ++i) {
+    const prop = hiddenProps[i];
+
+    if (model.hasOwnProperty(prop)) {
+      defineNonEnumerableProperty(clone, prop, model[prop]);
+    }
+  }
+
+  return clone;
+}
+
+module.exports = {
+  clone,
+};

package/lib/model/modelColPropMap.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const { difference } = require('../utils/objectUtils');
+
+function columnNameToPropertyName(modelClass, columnName) {
+  const model = new modelClass();
+  const addedProps = Object.keys(model.$parseDatabaseJson({}));
+
+  const row = {};
+  row[columnName] = null;
+
+  const props = Object.keys(model.$parseDatabaseJson(row));
+  const propertyName = difference(props, addedProps)[0];
+
+  return propertyName || columnName;
+}
+
+function propertyNameToColumnName(modelClass, propertyName) {
+  const model = new modelClass();
+  const addedCols = Object.keys(model.$formatDatabaseJson({}));
+
+  const obj = {};
+  obj[propertyName] = null;
+
+  const cols = Object.keys(model.$formatDatabaseJson(obj));
+  const columnName = difference(cols, addedCols)[0];
+
+  return columnName || propertyName;
+}
+
+module.exports = {
+  columnNameToPropertyName,
+  propertyNameToColumnName,
+};

package/lib/model/modelId.js

@@ -0,0 +1,62 @@
+'use strict';
+
+function getSetId(model, maybeId) {
+  if (maybeId !== undefined) {
+    return setId(model, maybeId);
+  } else {
+    return getId(model);
+  }
+}
+
+function hasId(model) {
+  return model.$hasProps(model.constructor.getIdPropertyArray());
+}
+
+function setId(model, id) {
+  const idProp = model.constructor.getIdProperty();
+  const isCompositeId = Array.isArray(idProp);
+
+  if (Array.isArray(id)) {
+    if (isCompositeId) {
+      if (id.length !== idProp.length) {
+        throw new Error('trying to set an invalid identifier for a model');
+      }
+
+      for (let i = 0; i < id.length; ++i) {
+        model[idProp[i]] = id[i];
+      }
+    } else {
+      if (id.length !== 1) {
+        throw new Error('trying to set an invalid identifier for a model');
+      }
+
+      model[idProp] = id[0];
+    }
+  } else {
+    if (isCompositeId) {
+      if (idProp.length > 1) {
+        throw new Error('trying to set an invalid identifier for a model');
+      }
+
+      model[idProp[0]] = id;
+    } else {
+      model[idProp] = id;
+    }
+  }
+}
+
+function getId(model) {
+  const idProp = model.constructor.getIdProperty();
+  const isCompositeId = Array.isArray(idProp);
+
+  if (isCompositeId) {
+    return model.$values(idProp);
+  } else {
+    return model[idProp];
+  }
+}
+
+module.exports = {
+  getSetId,
+  hasId,
+};

package/lib/model/modelJsonAttributes.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const { asArray, isObject, flatten, isString } = require('../utils/objectUtils');
+
+function parseJsonAttributes(json, modelClass) {
+  const jsonAttr = modelClass.getJsonAttributes();
+
+  if (jsonAttr.length) {
+    // JSON attributes may be returned as strings depending on the database and
+    // the database client. Convert them to objects here.
+    for (let i = 0, l = jsonAttr.length; i < l; ++i) {
+      const attr = jsonAttr[i];
+      const value = json[attr];
+
+      if (isString(value)) {
+        const parsed = tryParseJson(value);
+
+        // tryParseJson returns undefined if parsing failed.
+        if (parsed !== undefined) {
+          json[attr] = parsed;
+        }
+      }
+    }
+  }
+
+  return json;
+}
+
+function formatJsonAttributes(json, modelClass) {
+  const jsonAttr = modelClass.getJsonAttributes();
+
+  if (jsonAttr.length) {
+    // All database clients want JSON columns as strings. Do the conversion here.
+    for (let i = 0, l = jsonAttr.length; i < l; ++i) {
+      const attr = jsonAttr[i];
+      const value = json[attr];
+
+      if (value != null) {
+        json[attr] = JSON.stringify(value);
+      }
+    }
+  }
+
+  return json;
+}
+
+function getJsonAttributes(modelClass) {
+  let jsonAttributes = modelClass.jsonAttributes;
+
+  if (Array.isArray(jsonAttributes)) {
+    return jsonAttributes;
+  }
+
+  jsonAttributes = [];
+
+  if (modelClass.getJsonSchema()) {
+    const props = modelClass.getJsonSchema().properties || {};
+
+    for (const propName of Object.keys(props)) {
+      const prop = props[propName];
+      let types = asArray(prop.type).filter((it) => !!it);
+
+      if (types.length === 0 && Array.isArray(prop.anyOf)) {
+        types = flatten(prop.anyOf.map((it) => it.type));
+      }
+
+      if (types.length === 0 && Array.isArray(prop.oneOf)) {
+        types = flatten(prop.oneOf.map((it) => it.type));
+      }
+
+      if (types.indexOf('object') !== -1 || types.indexOf('array') !== -1) {
+        jsonAttributes.push(propName);
+      }
+    }
+  }
+
+  return jsonAttributes;
+}
+
+function tryParseJson(maybeJsonStr) {
+  try {
+    return JSON.parse(maybeJsonStr);
+  } catch (err) {
+    return undefined;
+  }
+}
+
+module.exports = {
+  parseJsonAttributes,
+  formatJsonAttributes,
+  getJsonAttributes,
+};