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

package/lib/queryBuilder/graph/recursiveUpsert/GraphRecursiveUpsertAction.js

@@ -1,126 +1,96 @@
 'use strict';
-
 const { GraphAction } = require('../GraphAction');
 const { groupBy, get, set } = require('../../../utils/objectUtils');
 const { forEachPropertyReference } = require('../../../model/graph/ModelGraphBuilder');
 const promiseUtils = require('../../../utils/promiseUtils');
-
 class GraphRecursiveUpsertAction extends GraphAction {
-  constructor(graphData, { nodes }) {
-    super(graphData);
-    // Nodes to upsert.
-    this.nodes = nodes;
-  }
-
-  run(builder) {
-    const builders = this._createUpsertBuilders(builder, this.nodes);
-
-    return promiseUtils.map(builders, (builder) => builder.execute(), {
-      concurrency: this._getConcurrency(builder, this.nodes),
-    });
-  }
-
-  _createUpsertBuilders(parentBuilder, nodesToUpsert) {
-    const nodesByRelation = groupBy(nodesToUpsert, getRelation);
-    const builders = [];
-
-    nodesByRelation.forEach((nodes) => {
-      const nodesByParent = groupBy(nodes, getParent);
-
-      nodesByParent.forEach((nodes) => {
-        for (const node of nodes) {
-          this._resolveReferences(node);
-          node.userData.upserted = true;
-        }
-
-        builders.push(
-          nodes[0].modelClass
-            .query()
-            .childQueryOf(parentBuilder)
-            .copyFrom(parentBuilder, GraphAction.ReturningAllSelector)
-            .upsertGraph(
-              nodes.map((node) => node.obj),
-              this.graphOptions.rebasedOptions(nodes[0]),
-            ),
-        );
-      });
-    });
-
-    return builders;
-  }
-
-  /**
-   * The nodes inside the subgraph we are about to recursively upsert may
-   * have references outside that graph that won't be available during the
-   * recursive upsertGraph call. This method resolves the references.
-   *
-   * TODO: This doesn't work if a recursively upserted node refers to
-   *       a node inside another recursively upsertable graph.
-   */
-  _resolveReferences(node) {
-    node.obj.$traverse((obj) => this._resolveReferencesForObject(obj));
-  }
-
-  _resolveReferencesForObject(obj) {
-    this._resolveObjectReference(obj);
-    this._resolvePropertyReferences(obj);
-  }
-
-  _resolveObjectReference(obj) {
-    const modelClass = obj.constructor;
-    const ref = obj[modelClass.uidRefProp];
-
-    if (!ref) {
-      return;
+    constructor(graphData, { nodes }) {
+        super(graphData);
+        // Nodes to upsert.
+        this.nodes = nodes;
+    }
+    run(builder) {
+        const builders = this._createUpsertBuilders(builder, this.nodes);
+        return promiseUtils.map(builders, (builder) => builder.execute(), {
+            concurrency: this._getConcurrency(builder, this.nodes),
+        });
+    }
+    _createUpsertBuilders(parentBuilder, nodesToUpsert) {
+        const nodesByRelation = groupBy(nodesToUpsert, getRelation);
+        const builders = [];
+        nodesByRelation.forEach((nodes) => {
+            const nodesByParent = groupBy(nodes, getParent);
+            nodesByParent.forEach((nodes) => {
+                for (const node of nodes) {
+                    this._resolveReferences(node);
+                    node.userData.upserted = true;
+                }
+                builders.push(nodes[0].modelClass
+                    .query()
+                    .childQueryOf(parentBuilder)
+                    .copyFrom(parentBuilder, GraphAction.ReturningAllSelector)
+                    .upsertGraph(nodes.map((node) => node.obj), this.graphOptions.rebasedOptions(nodes[0])));
+            });
+        });
+        return builders;
+    }
+    /**
+     * The nodes inside the subgraph we are about to recursively upsert may
+     * have references outside that graph that won't be available during the
+     * recursive upsertGraph call. This method resolves the references.
+     *
+     * TODO: This doesn't work if a recursively upserted node refers to
+     *       a node inside another recursively upsertable graph.
+     */
+    _resolveReferences(node) {
+        node.obj.$traverse((obj) => this._resolveReferencesForObject(obj));
     }
-
-    const referencedNode = this.graph.nodes.find((it) => it.uid === ref);
-
-    if (!referencedNode) {
-      return;
+    _resolveReferencesForObject(obj) {
+        this._resolveObjectReference(obj);
+        this._resolvePropertyReferences(obj);
+    }
+    _resolveObjectReference(obj) {
+        const modelClass = obj.constructor;
+        const ref = obj[modelClass.uidRefProp];
+        if (!ref) {
+            return;
+        }
+        const referencedNode = this.graph.nodes.find((it) => it.uid === ref);
+        if (!referencedNode) {
+            return;
+        }
+        const relationNames = referencedNode.modelClass.getRelationNames();
+        for (const prop of Object.keys(referencedNode.obj)) {
+            if (relationNames.includes(prop)) {
+                continue;
+            }
+            obj[prop] = referencedNode.obj[prop];
+        }
+        delete obj[modelClass.uidRefProp];
     }
-
-    const relationNames = referencedNode.modelClass.getRelationNames();
-
-    for (const prop of Object.keys(referencedNode.obj)) {
-      if (relationNames.includes(prop)) {
-        continue;
-      }
-
-      obj[prop] = referencedNode.obj[prop];
+    _resolvePropertyReferences(obj) {
+        forEachPropertyReference(obj, ({ path, refMatch, ref, refPath }) => {
+            const referencedNode = this.graph.nodes.find((it) => it.uid === ref);
+            if (!referencedNode) {
+                return;
+            }
+            const referencedValue = get(referencedNode.obj, refPath);
+            const value = get(obj, path);
+            if (value === refMatch) {
+                set(obj, path, referencedValue);
+            }
+            else {
+                set(obj, path, value.replace(refMatch, referencedValue));
+            }
+        });
     }
-
-    delete obj[modelClass.uidRefProp];
-  }
-
-  _resolvePropertyReferences(obj) {
-    forEachPropertyReference(obj, ({ path, refMatch, ref, refPath }) => {
-      const referencedNode = this.graph.nodes.find((it) => it.uid === ref);
-
-      if (!referencedNode) {
-        return;
-      }
-
-      const referencedValue = get(referencedNode.obj, refPath);
-      const value = get(obj, path);
-
-      if (value === refMatch) {
-        set(obj, path, referencedValue);
-      } else {
-        set(obj, path, value.replace(refMatch, referencedValue));
-      }
-    });
-  }
 }
-
 function getRelation(node) {
-  return node.parentEdge.relation;
+    return node.parentEdge.relation;
 }
-
 function getParent(node) {
-  return node.parentNode;
+    return node.parentNode;
 }
-
 module.exports = {
-  GraphRecursiveUpsertAction,
+    GraphRecursiveUpsertAction,
 };

package/lib/queryBuilder/join/JoinResultColumn.js

@@ -1,23 +1,19 @@
 'use strict';
-
 class JoinResultColumn {
-  constructor({ columnAlias, tableNode, name }) {
-    this.columnAlias = columnAlias;
-    this.tableNode = tableNode;
-    this.name = name;
-  }
-
-  static create({ tableTree, columnAlias }) {
-    const tableNode = tableTree.getNodeForColumnAlias(columnAlias);
-
-    return new JoinResultColumn({
-      columnAlias,
-      tableNode,
-      name: tableNode.getColumnForColumnAlias(columnAlias),
-    });
-  }
+    constructor({ columnAlias, tableNode, name }) {
+        this.columnAlias = columnAlias;
+        this.tableNode = tableNode;
+        this.name = name;
+    }
+    static create({ tableTree, columnAlias }) {
+        const tableNode = tableTree.getNodeForColumnAlias(columnAlias);
+        return new JoinResultColumn({
+            columnAlias,
+            tableNode,
+            name: tableNode.getColumnForColumnAlias(columnAlias),
+        });
+    }
 }
-
 module.exports = {
-  JoinResultColumn,
+    JoinResultColumn,
 };

package/lib/queryBuilder/join/JoinResultParser.js

@@ -1,119 +1,106 @@
 'use strict';
-
 const { JoinResultColumn } = require('./JoinResultColumn');
 const { groupBy } = require('../../utils/objectUtils');
-
 class JoinResultParser {
-  constructor({ tableTree, omitColumnAliases = [] }) {
-    this.tableTree = tableTree;
-    this.omitColumnAliases = new Set(omitColumnAliases);
-
-    this.columnsByTableNode = null;
-    this.parentMap = null;
-    this.rootModels = null;
-  }
-
-  static create(args) {
-    return new JoinResultParser(args);
-  }
-
-  parse(flatRows) {
-    if (!Array.isArray(flatRows) || flatRows.length === 0) {
-      return flatRows;
+    constructor({ tableTree, omitColumnAliases = [] }) {
+        this.tableTree = tableTree;
+        this.omitColumnAliases = new Set(omitColumnAliases);
+        this.columnsByTableNode = null;
+        this.rootModelsById = null;
+        this.rootModels = null;
     }
-
-    this.columnsByTableNode = this._createColumns(flatRows[0]);
-    this.parentMap = new Map();
-    this.rootModels = [];
-
-    for (const flatRow of flatRows) {
-      this._parseNode(this.tableTree.rootNode, flatRow);
+    static create(args) {
+        return new JoinResultParser(args);
     }
-
-    return this.rootModels;
-  }
-
-  _parseNode(tableNode, flatRow, parentModel = null, parentKey = null) {
-    const id = tableNode.getIdFromFlatRow(flatRow);
-
-    if (id === null) {
-      return;
-    }
-
-    const key = getKey(parentKey, id, tableNode);
-    let model = this.parentMap.get(key);
-
-    if (!model) {
-      model = this._createModel(tableNode, flatRow);
-
-      this._addToParent(tableNode, model, parentModel);
-      this.parentMap.set(key, model);
+    parse(flatRows) {
+        if (!Array.isArray(flatRows) || flatRows.length === 0) {
+            return flatRows;
+        }
+        this.columnsByTableNode = this._createColumns(flatRows[0]);
+        this.rootModelsById = new Map();
+        this.rootModels = [];
+        for (const flatRow of flatRows) {
+            this._parseNode(this.tableTree.rootNode, flatRow, null, this.rootModelsById);
+        }
+        return this.rootModels;
     }
-
-    for (const childNode of tableNode.childNodes) {
-      this._parseNode(childNode, flatRow, model, key);
+    // `modelsById` holds the models of `tableNode` that were already created
+    // under `parentModel`. Every created model gets a map like it for each of
+    // its child nodes.
+    _parseNode(tableNode, flatRow, parentModel, modelsById) {
+        const id = tableNode.getIdFromFlatRow(flatRow);
+        if (id === null) {
+            return;
+        }
+        let entry = modelsById.get(id);
+        if (entry === undefined) {
+            const model = this._createModel(tableNode, flatRow);
+            this._addToParent(tableNode, model, parentModel);
+            entry = { model, childModelsById: createChildMaps(tableNode) };
+            modelsById.set(id, entry);
+        }
+        const childNodes = tableNode.childNodes;
+        for (let i = 0, l = childNodes.length; i < l; ++i) {
+            this._parseNode(childNodes[i], flatRow, entry.model, entry.childModelsById[i]);
+        }
     }
-  }
-
-  _createModel(tableNode, flatRow) {
-    const row = {};
-    const columns = this.columnsByTableNode.get(tableNode);
-
-    if (columns) {
-      for (const column of columns) {
-        if (!this.omitColumnAliases.has(column.columnAlias)) {
-          row[column.name] = flatRow[column.columnAlias];
+    _createModel(tableNode, flatRow) {
+        const row = {};
+        const columns = this.columnsByTableNode.get(tableNode);
+        if (columns) {
+            for (let i = 0, l = columns.length; i < l; ++i) {
+                const column = columns[i];
+                row[column.name] = flatRow[column.columnAlias];
+            }
         }
-      }
+        const model = tableNode.modelClass.fromDatabaseJson(row);
+        for (const childNode of tableNode.childNodes) {
+            if (childNode.relation.isOneToOne()) {
+                model[childNode.relationProperty] = null;
+            }
+            else {
+                model[childNode.relationProperty] = [];
+            }
+        }
+        return model;
     }
-
-    const model = tableNode.modelClass.fromDatabaseJson(row);
-
-    for (const childNode of tableNode.childNodes) {
-      if (childNode.relation.isOneToOne()) {
-        model[childNode.relationProperty] = null;
-      } else {
-        model[childNode.relationProperty] = [];
-      }
+    _addToParent(tableNode, model, parentModel) {
+        if (tableNode.parentNode) {
+            if (tableNode.relation.isOneToOne()) {
+                parentModel[tableNode.relationProperty] = model;
+            }
+            else {
+                parentModel[tableNode.relationProperty].push(model);
+            }
+        }
+        else {
+            // Root model. Add to root list.
+            this.rootModels.push(model);
+        }
     }
-
-    return model;
-  }
-
-  _addToParent(tableNode, model, parentModel) {
-    if (tableNode.parentNode) {
-      if (tableNode.relation.isOneToOne()) {
-        parentModel[tableNode.relationProperty] = model;
-      } else {
-        parentModel[tableNode.relationProperty].push(model);
-      }
-    } else {
-      // Root model. Add to root list.
-      this.rootModels.push(model);
+    _createColumns(row) {
+        const columns = Object.keys(row)
+            .map((columnAlias) => JoinResultColumn.create({ tableTree: this.tableTree, columnAlias }))
+            // The omitted columns are filtered here once instead of for every model.
+            .filter((column) => !this.omitColumnAliases.has(column.columnAlias));
+        return groupBy(columns, getTableNode);
     }
-  }
-
-  _createColumns(row) {
-    const columns = Object.keys(row).map((columnAlias) =>
-      JoinResultColumn.create({ tableTree: this.tableTree, columnAlias }),
-    );
-
-    return groupBy(columns, getTableNode);
-  }
 }
-
 function getTableNode(column) {
-  return column.tableNode;
+    return column.tableNode;
 }
-
-function getKey(parentKey, id, tableNode) {
-  if (parentKey !== null) {
-    return `${parentKey}/${tableNode.relationProperty}/${id}`;
-  } else {
-    return `/${id}`;
-  }
+const NO_CHILD_MAPS = [];
+function createChildMaps(tableNode) {
+    const childNodes = tableNode.childNodes;
+    if (childNodes.length === 0) {
+        return NO_CHILD_MAPS;
+    }
+    const maps = new Array(childNodes.length);
+    for (let i = 0, l = childNodes.length; i < l; ++i) {
+        maps[i] = new Map();
+    }
+    return maps;
 }
-
 module.exports = {
-  JoinResultParser,
+    JoinResultParser,
 };