objection 3.9.1 → 4.0.0-rc.2

package/lib/.eslintrc.json

@@ -1,8 +0,0 @@
-{
-  "parserOptions": {
-    "sourceType": "script"
-  },
-  "rules": {
-    "strict": "error"
-  }
-}

package/lib/model/graph/ModelGraph.js

@@ -1,80 +0,0 @@
-'use strict';
-
-const { ModelGraphBuilder } = require('./ModelGraphBuilder');
-const NOT_CALCULATED = {};
-
-class ModelGraph {
-  constructor(nodes, edges) {
-    this.nodes = nodes;
-    this.edges = edges;
-
-    // These are calculated lazily.
-    this._nodesByObjects = NOT_CALCULATED;
-    this._nodesByIdPathKeys = NOT_CALCULATED;
-  }
-
-  static create(rootModelClass, roots) {
-    const builder = ModelGraphBuilder.buildGraph(rootModelClass, roots);
-    return new ModelGraph(builder.nodes, builder.edges);
-  }
-
-  static createEmpty() {
-    return new ModelGraph([], []);
-  }
-
-  get rootObjects() {
-    return this.nodes.filter((node) => !node.parentEdge).map((node) => node.obj);
-  }
-
-  nodeForObject(obj) {
-    if (!obj) {
-      return null;
-    }
-
-    if (this._nodesByObjects === NOT_CALCULATED) {
-      this._nodesByObjects = createNodesByObjectsMap(this.nodes);
-    }
-
-    return this._nodesByObjects.get(obj) || null;
-  }
-
-  nodeForNode(node) {
-    if (!node) {
-      return null;
-    }
-
-    if (this._nodesByIdPathKeys === NOT_CALCULATED) {
-      this._nodesByIdPathKeys = createNodesByIdPathKeysMap(this.nodes);
-    }
-
-    return this._nodesByIdPathKeys.get(node.idPathKey) || null;
-  }
-}
-
-function createNodesByObjectsMap(nodes) {
-  const nodesByObjects = new Map();
-
-  for (const node of nodes) {
-    nodesByObjects.set(node.obj, node);
-  }
-
-  return nodesByObjects;
-}
-
-function createNodesByIdPathKeysMap(nodes) {
-  const nodesByIdPathKeys = new Map();
-
-  for (const node of nodes) {
-    const idPathKey = node.idPathKey;
-
-    if (idPathKey !== null) {
-      nodesByIdPathKeys.set(idPathKey, node);
-    }
-  }
-
-  return nodesByIdPathKeys;
-}
-
-module.exports = {
-  ModelGraph,
-};

package/lib/model/graph/ModelGraphBuilder.js

@@ -1,241 +0,0 @@
-'use strict';
-
-const { isObject, isString, asArray, asSingle } = require('../../utils/objectUtils');
-const { ValidationErrorType } = require('../../model/ValidationError');
-const { ModelGraphNode } = require('./ModelGraphNode');
-const { ModelGraphEdge } = require('./ModelGraphEdge');
-
-class ModelGraphBuilder {
-  constructor() {
-    this.nodes = [];
-    this.edges = [];
-  }
-
-  static buildGraph(rootModelClass, roots) {
-    const builder = new this();
-    builder._buildGraph(rootModelClass, roots);
-
-    return builder;
-  }
-
-  _buildGraph(rootModelClass, roots) {
-    if (roots) {
-      if (Array.isArray(roots)) {
-        this._buildNodes(rootModelClass, roots);
-      } else if (isObject(roots)) {
-        this._buildNode(rootModelClass, roots);
-      } else {
-        throw createNotModelError(rootModelClass, roots);
-      }
-    }
-
-    this._buildReferences();
-  }
-
-  _buildNodes(modelClass, objs, parentNode = null, relation = null) {
-    objs = asArray(objs);
-
-    objs.forEach((obj, index) => {
-      this._buildNode(modelClass, obj, parentNode, relation, index);
-    });
-  }
-
-  _buildNode(modelClass, obj, parentNode = null, relation = null, index = null) {
-    obj = asSingle(obj);
-
-    if (!isObject(obj) || !obj.$isObjectionModel) {
-      throw createNotModelError(modelClass, obj);
-    }
-
-    const node = new ModelGraphNode(modelClass, obj);
-    this.nodes.push(node);
-
-    if (parentNode) {
-      const edge = new ModelGraphEdge(
-        ModelGraphEdge.Type.Relation,
-        parentNode,
-        node,
-        relation,
-        index,
-      );
-
-      node.parentEdge = edge;
-      this._addEdge(parentNode, node, edge);
-    }
-
-    this._buildRelationNodes(node);
-  }
-
-  _buildRelationNodes(node) {
-    for (const relationName of node.modelClass.getRelationNames()) {
-      const relatedObjects = node.obj[relationName];
-
-      if (!relatedObjects) {
-        continue;
-      }
-
-      const relation = node.modelClass.getRelation(relationName);
-
-      if (relation.isOneToOne()) {
-        this._buildNode(relation.relatedModelClass, relatedObjects, node, relation);
-      } else {
-        this._buildNodes(relation.relatedModelClass, relatedObjects, node, relation);
-      }
-    }
-  }
-
-  _buildReferences() {
-    const nodesByUid = this._nodesByUid();
-
-    this._buildObjectReferences(nodesByUid);
-    this._buildPropertyReferences(nodesByUid);
-  }
-
-  _nodesByUid() {
-    const nodesByUid = new Map();
-
-    for (const node of this.nodes) {
-      const uid = node.uid;
-
-      if (uid === undefined) {
-        continue;
-      }
-
-      nodesByUid.set(uid, node);
-    }
-
-    return nodesByUid;
-  }
-
-  _buildObjectReferences(nodesByUid) {
-    for (const node of this.nodes) {
-      const ref = node.reference;
-
-      if (ref === undefined) {
-        continue;
-      }
-
-      const refNode = nodesByUid.get(ref);
-
-      if (!refNode) {
-        throw createReferenceNotFoundError(ref);
-      }
-
-      const edge = new ModelGraphEdge(ModelGraphEdge.Type.Reference, node, refNode);
-      edge.refType = ModelGraphEdge.ReferenceType.Object;
-
-      this._addEdge(node, refNode, edge);
-    }
-  }
-
-  _buildPropertyReferences(nodesByUid) {
-    for (const node of this.nodes) {
-      forEachPropertyReference(node.obj, ({ path, refMatch, ref, refPath }) => {
-        const refNode = nodesByUid.get(ref);
-
-        if (!refNode) {
-          throw createReferenceNotFoundError(ref);
-        }
-
-        const edge = new ModelGraphEdge(ModelGraphEdge.Type.Reference, node, refNode);
-
-        edge.refType = ModelGraphEdge.ReferenceType.Property;
-        edge.refMatch = refMatch;
-        edge.refOwnerDataPath = path.slice();
-        edge.refRelatedDataPath = refPath;
-
-        this._addEdge(node, refNode, edge);
-      });
-    }
-  }
-
-  _addEdge(ownerNode, relatedNode, edge) {
-    this.edges.push(edge);
-
-    ownerNode.edges.push(edge);
-    relatedNode.edges.push(edge);
-
-    if (edge.type === ModelGraphEdge.Type.Reference) {
-      ownerNode.refEdges.push(edge);
-      relatedNode.refEdges.push(edge);
-    }
-  }
-}
-
-function forEachPropertyReference(obj, callback) {
-  const modelClass = obj.constructor;
-  const relationNames = modelClass.getRelationNames();
-
-  for (const prop of Object.keys(obj)) {
-    if (relationNames.includes(prop)) {
-      continue;
-    }
-
-    visitStrings(obj[prop], [prop], (str, path) => {
-      forEachMatch(modelClass.propRefRegex, str, (match) => {
-        const [refMatch, ref, refPath] = match;
-        callback({ path, refMatch, ref, refPath: refPath.trim().split('.') });
-      });
-    });
-  }
-}
-
-function visitStrings(value, path, visit) {
-  if (Array.isArray(value)) {
-    visitStringsInArray(value, path, visit);
-  } else if (isObject(value) && !Buffer.isBuffer(value)) {
-    visitStringsInObject(value, path, visit);
-  } else if (isString(value)) {
-    visit(value, path);
-  }
-}
-
-function visitStringsInArray(value, path, visit) {
-  for (let i = 0; i < value.length; ++i) {
-    path.push(i);
-    visitStrings(value[i], path, visit);
-    path.pop();
-  }
-}
-
-function visitStringsInObject(value, path, visit) {
-  for (const prop of Object.keys(value)) {
-    path.push(prop);
-    visitStrings(value[prop], path, visit);
-    path.pop();
-  }
-}
-
-function forEachMatch(regex, str, cb) {
-  let matchResult = regex.exec(str);
-
-  while (matchResult) {
-    cb(matchResult);
-    matchResult = regex.exec(str);
-  }
-}
-
-function createReferenceNotFoundError(ref) {
-  return new Error(
-    [
-      `could not resolve reference ${ref} in a graph.`,
-      `If you are sure the #id exist in the same graph,`,
-      `this may be due to a limitation that a subgraph under a related item`,
-      `cannot reference an item in a subgraph under another related item.`,
-      `If you run into this limitation, please open an issue in objection github.`,
-    ].join(' '),
-  );
-}
-
-function createNotModelError(modelClass, value) {
-  throw modelClass.createValidationError({
-    type: ValidationErrorType.InvalidGraph,
-    message: `expected value "${value}" to be an instance of ${modelClass.name}`,
-  });
-}
-
-module.exports = {
-  ModelGraphBuilder,
-  createNotModelError,
-  forEachPropertyReference,
-};

package/lib/model/graph/ModelGraphEdge.js

@@ -1,52 +0,0 @@
-'use strict';
-
-const Type = {
-  Relation: 'Relation',
-  Reference: 'Reference',
-};
-
-const ReferenceType = {
-  Object: 'Object',
-  Property: 'Property',
-};
-
-class ModelGraphEdge {
-  constructor(type, ownerNode, relatedNode, relation = null, relationIndex = null) {
-    this.type = type;
-
-    this.ownerNode = ownerNode;
-    this.relatedNode = relatedNode;
-    this.relation = relation;
-    this.relationIndex = relationIndex;
-
-    this.refType = null;
-    this.refMatch = null;
-
-    this.refOwnerDataPath = null;
-    this.refRelatedDataPath = null;
-  }
-
-  static get Type() {
-    return Type;
-  }
-
-  static get ReferenceType() {
-    return ReferenceType;
-  }
-
-  getOtherNode(node) {
-    return this.isOwnerNode(node) ? this.relatedNode : this.ownerNode;
-  }
-
-  isOwnerNode(node) {
-    return node === this.ownerNode;
-  }
-
-  isRelatedNode(node) {
-    return node === this.relatedNode;
-  }
-}
-
-module.exports = {
-  ModelGraphEdge,
-};

package/lib/model/graph/ModelGraphNode.js

@@ -1,238 +0,0 @@
-'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 toBeUnrelated() {
-    return this.obj[this.modelClass.graphUnrelateProp] === true;
-  }
-
-  get toBeDeleted() {
-    return this.obj[this.modelClass.graphDeleteProp] === true;
-  }
-
-  get toBeUnrelatedOrDeleted() {
-    return this.toBeUnrelated || this.toBeDeleted;
-  }
-
-  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;
-  }
-
-  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) {
-      // JSON keeps the ids and relation names apart, whatever they contain.
-      return JSON.stringify(idPath);
-    } else {
-      return null;
-    }
-  }
-}
-
-module.exports = {
-  ModelGraphNode,
-};

package/lib/queryBuilder/graph/GraphAction.js

@@ -1,69 +0,0 @@
-'use strict';
-
-const { isPostgres } = require('../../utils/knexUtils');
-
-const POSTGRES_MAX_INSERT_BATCH_SIZE = 100;
-const MAX_CONCURRENCY = 100;
-
-class GraphAction {
-  constructor(graphData) {
-    this.graphData = graphData;
-  }
-
-  static get ReturningAllSelector() {
-    return (op) => {
-      // Only select `returning('*')` operation.
-      return op.name === 'returning' && op.args.includes('*');
-    };
-  }
-
-  static getConcurrency(builder, nodes) {
-    return nodes.reduce((minConcurrency, node) => {
-      return Math.min(minConcurrency, node.modelClass.getConcurrency(builder.unsafeKnex()));
-    }, MAX_CONCURRENCY);
-  }
-
-  get graph() {
-    return this.graphData.graph;
-  }
-
-  get currentGraph() {
-    return this.graphData.currentGraph;
-  }
-
-  get graphOptions() {
-    return this.graphData.graphOptions;
-  }
-
-  run(builder) {
-    return null;
-  }
-
-  _getConcurrency(builder, nodes) {
-    return GraphAction.getConcurrency(builder, nodes);
-  }
-
-  _getBatchSize(builder) {
-    return isPostgres(builder.unsafeKnex()) ? POSTGRES_MAX_INSERT_BATCH_SIZE : 1;
-  }
-
-  _resolveReferences(node) {
-    if (node.isReference) {
-      this._resolveReference(node);
-    }
-  }
-
-  _resolveReference(node) {
-    const refNode = node.referencedNode;
-
-    for (const prop of Object.keys(refNode.obj)) {
-      if (!node.obj.hasOwnProperty(prop)) {
-        node.obj[prop] = refNode.obj[prop];
-      }
-    }
-  }
-}
-
-module.exports = {
-  GraphAction,
-};