@abedmurrar/objection 4.0.0-alpha.0 → 4.0.0-beta.0

package/lib/model/graph/ModelGraphNode.js

@@ -1,240 +1,201 @@
 '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) {
+    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;
-      }
-
-      return [...path, this.relationName, this.obj.$idKey()];
-    }
-  }
-
-  _createIdPathKey() {
-    const idPath = this.idPath;
-
-    if (idPath) {
-      return this.idPath.join('.');
-    } else {
-      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,
+    ModelGraphNode,
 };

package/lib/model/inheritModel.js

@@ -1,28 +1,19 @@
 '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);
+    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',
-    `
+    return new Function('BaseClass', `
     'use strict';
     return class ${className} extends BaseClass {}
-  `,
-  );
+  `);
 }
-
 module.exports = {
-  inheritModel,
+    inheritModel,
 };

package/lib/model/modelBindKnex.js

@@ -1,83 +1,69 @@
 '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;
+    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;
+    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;
+    if (!knex.$$objection) {
+        createCache(knex);
+    }
+    return knex.$$objection.boundModels;
 }
-
 function createCache(knex) {
-  defineNonEnumerableProperty(knex, '$$objection', {
-    boundModels: new Map(),
-  });
+    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]);
+    // Bound classes share the validator of the class they are bound from, which
+    // is copied below. Create it first, so that a class bound to a new knex
+    // instance, like every transaction, doesn't create and compile a validator
+    // of its own.
+    if (!Object.hasOwn(modelClass, '$$validator')) {
+        modelClass.getValidator();
     }
-  }
-
-  return BoundModelClass;
+    for (const prop of staticHiddenProps) {
+        // $$relations and $$relationArray are handled in separately.
+        if (Object.hasOwn(modelClass, 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;
+    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;
+    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,
+    bindKnex,
 };