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

package/lib/queryBuilder/graph/patch/GraphPatchAction.js

@@ -0,0 +1,205 @@
+'use strict';
+const { getModel } = require('../../../model/getModel');
+const { GraphAction } = require('../GraphAction');
+const { isInternalProp } = require('../../../utils/internalPropUtils');
+const { difference, isObject, jsonEquals } = require('../../../utils/objectUtils');
+const promiseUtils = require('../../../utils/promiseUtils');
+class GraphPatchAction extends GraphAction {
+    constructor(graphData, { nodes }) {
+        super(graphData);
+        // Nodes to patch.
+        this.nodes = nodes;
+    }
+    run(builder) {
+        return promiseUtils.map(this.nodes, (node) => this._runForNode(builder, node), {
+            concurrency: this._getConcurrency(builder, this.nodes),
+        });
+    }
+    _runForNode(builder, node) {
+        const shouldPatch = this.graphOptions.shouldPatch(node, this.graphData);
+        const shouldUpdate = this.graphOptions.shouldUpdate(node, this.graphData);
+        // BelongsToOneRelation inserts and relates change the parent object's
+        // properties. That's why we handle them here.
+        const changedPropsBecauseOfBelongsToOneInsert = this._handleBelongsToOneInserts(node);
+        // BelongsToOneRelation deletes and unrelates change the parent object's
+        // properties. That's why we handle them here.
+        const changePropsBecauseOfBelongsToOneDelete = this._handleBelongsToOneDeletes(node);
+        const handleUpdate = () => {
+            const { changedProps, unchangedProps } = this._findChanges(node);
+            const allProps = [...changedProps, ...unchangedProps];
+            const propsToUpdate = difference(shouldPatch || shouldUpdate
+                ? changedProps
+                : [...changedPropsBecauseOfBelongsToOneInsert, ...changePropsBecauseOfBelongsToOneDelete], 
+            // Remove id properties from the props to update. With upsertGraph
+            // it never makes sense to change the id.
+            node.modelClass.getIdPropertyArray());
+            const update = propsToUpdate.length > 0;
+            if (update) {
+                // Don't update the fields that we know not to change.
+                node.obj.$omitFromDatabaseJson(difference(allProps, propsToUpdate));
+                node.userData.updated = true;
+            }
+            return update;
+        };
+        const Model = getModel();
+        // See if the model defines a beforeUpdate or $beforeUpdate hook. If it does
+        // not, we can check for updated properties now and drop out immediately if
+        // there is nothing to update. Otherwise, we need to wait for the hook to be
+        // called before calling handleUpdate, but only if the node contains changes
+        // that aren't id properties (relates). See issues #2233, #2605.
+        const hasBeforeUpdate = node.obj.constructor.beforeUpdate !== Model.beforeUpdate ||
+            node.obj.$beforeUpdate !== Model.prototype.$beforeUpdate;
+        if ((hasBeforeUpdate && !this._hasNonIdPropertyChanges(node)) ||
+            (!hasBeforeUpdate && !handleUpdate())) {
+            return null;
+        }
+        delete node.obj[node.modelClass.uidProp];
+        delete node.obj[node.modelClass.uidRefProp];
+        delete node.obj[node.modelClass.dbRefProp];
+        node.obj.$validate(null, {
+            dataPath: node.dataPathKey,
+            patch: shouldPatch || (!shouldPatch && !shouldUpdate),
+        });
+        const updateBuilder = this._createBuilder(node)
+            .childQueryOf(builder, childQueryOptions())
+            .copyFrom(builder, GraphAction.ReturningAllSelector);
+        if (hasBeforeUpdate) {
+            updateBuilder.internalContext().runBefore.push((result, builder) => {
+                // Call handleUpdate in the runBefore hook which runs after the
+                // $beforeUpdate hook, allowing it to modify the object before the
+                // updated properties are determined. See issue #2233.
+                if (hasBeforeUpdate && !handleUpdate()) {
+                    builder.internalOptions().returnImmediatelyValue = null;
+                }
+                return result;
+            });
+        }
+        if (shouldPatch) {
+            updateBuilder.patch(node.obj);
+        }
+        else {
+            updateBuilder.update(node.obj);
+        }
+        return updateBuilder.execute().then((result) => {
+            if (isObject(result) && result.$isObjectionModel) {
+                // Handle returning('*').
+                node.obj.$set(result);
+            }
+            return result;
+        });
+    }
+    _handleBelongsToOneInserts(node) {
+        const currentNode = this.currentGraph.nodeForNode(node);
+        const updatedProps = [];
+        for (const edge of node.edges) {
+            if (edge.isOwnerNode(node) &&
+                edge.relation &&
+                edge.relation.isObjectionBelongsToOneRelation &&
+                edge.relation.relatedProp.hasProps(edge.relatedNode.obj)) {
+                const { relation } = edge;
+                relation.ownerProp.forEach((i) => {
+                    const currentValue = currentNode && relation.ownerProp.getProp(currentNode.obj, i);
+                    const relatedValue = relation.relatedProp.getProp(edge.relatedNode.obj, i);
+                    if (currentValue != relatedValue) {
+                        relation.ownerProp.setProp(node.obj, i, relatedValue);
+                        updatedProps.push(relation.ownerProp.props[i]);
+                    }
+                });
+            }
+        }
+        return updatedProps;
+    }
+    _handleBelongsToOneDeletes(node) {
+        const currentNode = this.currentGraph.nodeForNode(node);
+        const updatedProps = [];
+        if (!currentNode) {
+            return updatedProps;
+        }
+        for (const edge of currentNode.edges) {
+            if (edge.isOwnerNode(currentNode) &&
+                edge.relation.isObjectionBelongsToOneRelation &&
+                node.obj[edge.relation.name] === null &&
+                this.graphOptions.shouldDeleteOrUnrelate(edge.relatedNode, this.graphData)) {
+                const { relation } = edge;
+                relation.ownerProp.forEach((i) => {
+                    const currentValue = relation.ownerProp.getProp(currentNode.obj, i);
+                    if (currentValue != null) {
+                        relation.ownerProp.setProp(node.obj, i, null);
+                        updatedProps.push(relation.ownerProp.props[i]);
+                    }
+                });
+            }
+        }
+        return updatedProps;
+    }
+    _findChanges(node) {
+        const obj = node.obj;
+        const currentNode = this.currentGraph.nodeForNode(node);
+        const currentObj = (currentNode && currentNode.obj) || {};
+        const relationNames = node.modelClass.getRelationNames();
+        const unchangedProps = [];
+        const changedProps = [];
+        for (const prop of Object.keys(obj)) {
+            if (isInternalProp(prop) || relationNames.includes(prop)) {
+                continue;
+            }
+            const value = obj[prop];
+            const currentValue = currentObj[prop];
+            // If the current object doesn't have the property, we have to assume
+            // it changes (we cannot know if it will). If the object does have the
+            // property, we test non-strict equality. See issue #732.
+            if (currentValue === undefined || !nonStrictEquals(currentValue, value)) {
+                changedProps.push(prop);
+            }
+            else {
+                unchangedProps.push(prop);
+            }
+        }
+        // We cannot know if the query properties cause changes to the values.
+        // We must assume that they do.
+        if (obj.$$queryProps) {
+            changedProps.push(...Object.keys(obj.$$queryProps));
+        }
+        return {
+            changedProps,
+            unchangedProps,
+        };
+    }
+    _hasNonIdPropertyChanges(node) {
+        const idProps = node.modelClass.getIdPropertyArray();
+        return this._findChanges(node).changedProps.some((prop) => !idProps.includes(prop));
+    }
+    _createBuilder(node) {
+        if (node.parentEdge && !node.parentEdge.relation.isObjectionHasManyRelation) {
+            return this._createRelatedBuilder(node);
+        }
+        else {
+            return this._createRootBuilder(node);
+        }
+    }
+    _createRelatedBuilder(node) {
+        return node.parentNode.obj
+            .$relatedQuery(node.parentEdge.relation.name)
+            .findById(node.obj.$id());
+    }
+    _createRootBuilder(node) {
+        const currentNode = this.currentGraph.nodeForNode(node);
+        const currentObj = currentNode && currentNode.obj;
+        return currentObj ? currentObj.$query() : node.obj.$query();
+    }
+}
+function childQueryOptions() {
+    return {
+        fork: true,
+        isInternalQuery: true,
+    };
+}
+function nonStrictEquals(val1, val2) {
+    if (val1 == val2) {
+        return true;
+    }
+    return jsonEquals(val1, val2);
+}
+module.exports = {
+    GraphPatchAction,
+};

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

@@ -0,0 +1,26 @@
+'use strict';
+const { GraphOperation } = require('../GraphOperation');
+const { GraphRecursiveUpsertAction } = require('./GraphRecursiveUpsertAction');
+class GraphRecursiveUpsert extends GraphOperation {
+    createActions() {
+        return [
+            new GraphRecursiveUpsertAction(this.graphData, {
+                nodes: this.graph.nodes.filter((node) => {
+                    const shouldRelate = this.graphOptions.shouldRelate(node, this.graphData);
+                    return shouldRelate && hasRelations(node.obj);
+                }),
+            }),
+        ];
+    }
+}
+function hasRelations(obj) {
+    for (const relationName of obj.constructor.getRelationNames()) {
+        if (obj[relationName] !== undefined) {
+            return true;
+        }
+    }
+    return false;
+}
+module.exports = {
+    GraphRecursiveUpsert,
+};

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

@@ -0,0 +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;
+        }
+        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];
+    }
+    _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;
+}
+function getParent(node) {
+    return node.parentNode;
+}
+module.exports = {
+    GraphRecursiveUpsertAction,
+};

package/lib/queryBuilder/join/JoinResultColumn.js

@@ -0,0 +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),
+        });
+    }
+}
+module.exports = {
+    JoinResultColumn,
+};

package/lib/queryBuilder/join/JoinResultParser.js

@@ -0,0 +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.rootModelsById = null;
+        this.rootModels = null;
+    }
+    static create(args) {
+        return new JoinResultParser(args);
+    }
+    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;
+    }
+    // `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 (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;
+    }
+    _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);
+    }
+}
+function getTableNode(column) {
+    return column.tableNode;
+}
+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,
+};