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

package/lib/queryBuilder/graph/GraphAction.js

@@ -0,0 +1,54 @@
+'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 (!Object.hasOwn(node.obj, prop)) {
+                node.obj[prop] = refNode.obj[prop];
+            }
+        }
+    }
+}
+module.exports = {
+    GraphAction,
+};

package/lib/queryBuilder/graph/GraphData.js

@@ -0,0 +1,12 @@
+'use strict';
+class GraphData {
+    constructor({ graph, currentGraph, graphOptions, nodeDbExistence }) {
+        this.graph = graph;
+        this.currentGraph = currentGraph;
+        this.graphOptions = graphOptions;
+        this.nodeDbExistence = nodeDbExistence;
+    }
+}
+module.exports = {
+    GraphData,
+};

package/lib/queryBuilder/graph/GraphFetcher.js

@@ -0,0 +1,155 @@
+'use strict';
+const { asArray, groupBy } = require('../../utils/objectUtils');
+const { ModelGraph } = require('../../model/graph/ModelGraph');
+const { FetchStrategy } = require('./GraphOptions');
+const { RelationExpression } = require('../RelationExpression');
+class GraphFetcher {
+    /**
+     * Given a graph and options, fetches the current state of that graph
+     * from the database and returns it as a ModelGraph instance.
+     */
+    static async fetchCurrentGraph({ builder, graph, graphOptions }) {
+        const { rootObjects } = graph;
+        const rootIds = getRootIds(rootObjects);
+        const modelClass = builder.modelClass();
+        if (rootIds.length === 0) {
+            return Promise.resolve(ModelGraph.create(modelClass, []));
+        }
+        const eagerExpr = RelationExpression.fromModelGraph(rootObjects);
+        const models = await modelClass
+            .query()
+            .childQueryOf(builder, childQueryOptions())
+            .modify(propagateMethodCallsFromQuery(builder))
+            .modify(buildFetchQuerySelects(graph, graphOptions, eagerExpr))
+            .findByIds(rootIds)
+            .withGraphFetched(eagerExpr)
+            .internalOptions(fetchQueryInternalOptions());
+        return ModelGraph.create(modelClass, models);
+    }
+}
+function getRootIds(rootObjects) {
+    return asArray(rootObjects)
+        .filter((it) => it.$hasId())
+        .map((root) => root.$id());
+}
+function propagateMethodCallsFromQuery(builder) {
+    return (fetchBuilder) => {
+        // Propagate some method calls from the root query.
+        for (const method of ['forUpdate', 'forShare', 'forNoKeyUpdate', 'forKeyShare']) {
+            if (builder.has(method)) {
+                fetchBuilder[method]();
+            }
+        }
+    };
+}
+function buildFetchQuerySelects(graph, graphOptions, eagerExpr) {
+    return (builder) => {
+        const nodesByRelationPath = groupNodesByRelationPath(graph, eagerExpr);
+        for (const [relationPath, nodes] of nodesByRelationPath.entries()) {
+            const selectModifier = createFetchSelectModifier(nodes, graphOptions);
+            if (!relationPath) {
+                builder.modify(selectModifier);
+            }
+            else {
+                builder.modifyGraph(relationPath, selectModifier);
+            }
+        }
+    };
+}
+function groupNodesByRelationPath(graph, eagerExpr) {
+    const nodesByRelationPath = groupBy(graph.nodes, (node) => node.relationPathKey);
+    // Not all relation paths have nodes. Relations with nulls or empty arrays
+    // don't have nodes, but will still need to be fetched. Add these to the
+    // map as empty arrays.
+    forEachPath(eagerExpr.node, (relationPath) => {
+        if (!nodesByRelationPath.has(relationPath)) {
+            nodesByRelationPath.set(relationPath, []);
+        }
+    });
+    return nodesByRelationPath;
+}
+function createFetchSelectModifier(nodes, graphOptions) {
+    if (graphOptions.isFetchStrategy(FetchStrategy.OnlyIdentifiers)) {
+        return createIdentifierSelector();
+    }
+    else if (graphOptions.isFetchStrategy(FetchStrategy.OnlyNeeded)) {
+        return createInputColumnSelector(nodes);
+    }
+    else {
+        return () => { };
+    }
+}
+// Returns a function that only selects the id column.
+function createIdentifierSelector() {
+    return (builder) => {
+        builder.select(builder.fullIdColumn());
+    };
+}
+// Returns a function that only selects the columns that exist in the input.
+function createInputColumnSelector(nodes) {
+    return (builder) => {
+        const selects = new Map();
+        for (const node of nodes) {
+            const databaseJson = node.obj.$toDatabaseJson(builder);
+            for (const column of Object.keys(databaseJson)) {
+                if (!shouldSelectColumn(column, selects, node)) {
+                    continue;
+                }
+                const selection = createManyToManyExtraSelectionIfNeeded(builder, column, node) ||
+                    createSelection(builder, column, node);
+                selects.set(column, selection);
+            }
+        }
+        const selectArr = Array.from(selects.values());
+        const idColumns = asArray(builder.fullIdColumn());
+        for (const idColumn of idColumns) {
+            if (!selectArr.includes(idColumn)) {
+                // Always select the identifers.
+                selectArr.push(idColumn);
+            }
+        }
+        builder.select(selectArr);
+    };
+}
+function shouldSelectColumn(column, selects, node) {
+    const modelClass = node.modelClass;
+    return (!selects.has(column) &&
+        column !== modelClass.propertyNameToColumnName(modelClass.dbRefProp) &&
+        column !== modelClass.propertyNameToColumnName(modelClass.uidRefProp) &&
+        column !== modelClass.propertyNameToColumnName(modelClass.uidProp));
+}
+function createManyToManyExtraSelectionIfNeeded(builder, column, node) {
+    if (node.parentEdge && node.parentEdge.relation.isObjectionManyToManyRelation) {
+        const relation = node.parentEdge.relation;
+        const extra = relation.joinTableExtras.find((extra) => extra.aliasCol === column);
+        if (extra) {
+            return `${builder.tableRefFor(relation.joinModelClass)}.${extra.joinTableCol} as ${extra.aliasCol}`;
+        }
+    }
+    return null;
+}
+function createSelection(builder, column, node) {
+    return `${builder.tableRefFor(node.modelClass)}.${column}`;
+}
+function childQueryOptions() {
+    return {
+        fork: true,
+        isInternalQuery: true,
+    };
+}
+function fetchQueryInternalOptions() {
+    return {
+        keepImplicitJoinProps: true,
+    };
+}
+function forEachPath(eagerExprNode, cb, path = []) {
+    for (const relation of eagerExprNode.$childNames) {
+        path.push(relation);
+        cb(path.join('.'));
+        forEachPath(eagerExprNode[relation], cb, path);
+        path.pop();
+    }
+}
+module.exports = {
+    GraphFetcher,
+};

package/lib/queryBuilder/graph/GraphNodeDbExistence.js

@@ -0,0 +1,146 @@
+'use strict';
+const { GraphData } = require('./GraphData');
+const { GraphAction } = require('./GraphAction');
+const promiseUtils = require('../../utils/promiseUtils');
+/**
+ * This weird little class is responsible for checking (and maintaining information)
+ * whether certain nodes exist in the database.
+ *
+ * Note that this information is only calculated for nodes for which `insertMissing`
+ * option is true.
+ */
+class GraphNodeDbExistence {
+    static createEveryNodeExistsExistence() {
+        return new GraphNodeDbExistence(new Map());
+    }
+    /**
+     * Goes through the graphs and identifies nodes that may not exist in the db
+     * (nodes that have an id, but are not found in `currentGraph`) and
+     * creates an instance of GraphNodeDbExistence that can be used to
+     * synchronously check if a node exist in the database.
+     */
+    static async create({ builder, graph, graphOptions, currentGraph }) {
+        if (graphOptions.isInsertOnly()) {
+            // With insertGraph, we never want to do anything but inserts.
+            return GraphNodeDbExistence.createEveryNodeExistsExistence();
+        }
+        const graphData = new GraphData({
+            graph,
+            graphOptions,
+            currentGraph,
+            // We don't yet have an instance of GraphNodeDbExistence since we are
+            // creating one. We can (and should) safely use an instance that
+            // assumes that all nodes exist in the db for the purposes of this
+            // method.
+            nodeDbExistence: GraphNodeDbExistence.createEveryNodeExistsExistence(),
+        });
+        const { mayNotExist, mayNotExistNodes } = createMayNotExistMap(graphData);
+        if (mayNotExist.size == 0) {
+            // Early exit if we found no items for which we should check their
+            // existence in the db.
+            return GraphNodeDbExistence.createEveryNodeExistsExistence();
+        }
+        const dontExist = await createDontExistMap({ builder, mayNotExist, mayNotExistNodes });
+        return new GraphNodeDbExistence(dontExist);
+    }
+    constructor(dontExist) {
+        this.dontExist = dontExist;
+    }
+    doesNodeExistInDb(node) {
+        const idMap = this.dontExist.get(node.modelClass);
+        if (!idMap) {
+            return true;
+        }
+        return !idMap.has(node.obj.$idKey());
+    }
+}
+function createMayNotExistMap(graphData) {
+    const { graph, currentGraph, graphOptions } = graphData;
+    const mayNotExist = new Map();
+    const mayNotExistNodes = [];
+    for (const node of graph.nodes) {
+        if (
+        // As an optimization, only consider nodes for which `insertMissing` is true.
+        // We only need the information for those nodes.
+        graphOptions.shouldInsertMissing(node) &&
+            // Only consider nodes that will be related. We don't consider nodes that
+            // would get inserted with an id. Those will still result in a unique
+            // constraint error.
+            graphOptions.shouldRelate(node, graphData) &&
+            // Relate nodes may not have an id if they are `#ref` nodes. Only consider
+            // nodes that have an id so that we can check the existence.
+            node.hasId &&
+            // We can ignore nodes if they are found anywhere in the graph. `shouldRelate`
+            // only checks if the node is found in the same relation.
+            !hasNodeById(currentGraph, node)) {
+            if (!mayNotExist.has(node.modelClass)) {
+                mayNotExist.set(node.modelClass, new Map());
+            }
+            mayNotExist.get(node.modelClass).set(node.obj.$idKey(), node.obj.$id());
+            mayNotExistNodes.push(node);
+        }
+    }
+    return {
+        mayNotExist,
+        mayNotExistNodes,
+    };
+}
+function hasNodeById(currentGraph, nodeToFind) {
+    const { modelClass } = nodeToFind;
+    const tableToFind = modelClass.getTableName();
+    const idProps = modelClass.getIdPropertyArray();
+    return currentGraph.nodes.some((node) => {
+        return (node.modelClass.getTableName() === tableToFind &&
+            idProps.every((idProp) => node.obj[idProp] === nodeToFind.obj[idProp]));
+    });
+}
+async function createDontExistMap({ builder, mayNotExist, mayNotExistNodes }) {
+    const dontExist = cloneExistenceMap(mayNotExist);
+    const existenceCheckQueries = createExistenceCheckQueries({ builder, mayNotExist });
+    const results = await promiseUtils.map(existenceCheckQueries, (builder) => builder.execute(), {
+        concurrency: GraphAction.getConcurrency(builder, mayNotExistNodes),
+    });
+    // Remove all items from the mayNotExist map that we have just proven to exist
+    // by executing the existenceCheckQueries.
+    for (const modelResult of results) {
+        for (const item of modelResult) {
+            const modelClass = item.constructor;
+            const idMap = dontExist.get(modelClass);
+            // Exist, remove from the map.
+            idMap.delete(item.$idKey());
+        }
+    }
+    // Now only items that don't exist in the db are left in this map.
+    return dontExist;
+}
+function createExistenceCheckQueries({ builder, mayNotExist }) {
+    const builders = [];
+    for (const [modelClass, idMap] of mayNotExist.entries()) {
+        const ids = Array.from(idMap.values());
+        // Create one query per model class (table) to fetch the identifiers
+        // of the nodes that may not exist. These queries should be super fast
+        // since they come straight from the index.
+        builders.push(modelClass
+            .query()
+            .childQueryOf(builder, childQueryOptions())
+            .findByIds(ids)
+            .select(modelClass.getIdColumnArray()));
+    }
+    return builders;
+}
+function childQueryOptions() {
+    return {
+        fork: true,
+        isInternalQuery: true,
+    };
+}
+function cloneExistenceMap(exixtenseMap) {
+    const clone = new Map(exixtenseMap);
+    for (const modelClass of clone.keys()) {
+        clone.set(modelClass, new Map(clone.get(modelClass)));
+    }
+    return clone;
+}
+module.exports = {
+    GraphNodeDbExistence,
+};

package/lib/queryBuilder/graph/GraphOperation.js

@@ -0,0 +1,21 @@
+'use strict';
+class GraphOperation {
+    constructor(graphData) {
+        this.graphData = graphData;
+    }
+    get graph() {
+        return this.graphData.graph;
+    }
+    get currentGraph() {
+        return this.graphData.currentGraph;
+    }
+    get graphOptions() {
+        return this.graphData.graphOptions;
+    }
+    createActions() {
+        return [];
+    }
+}
+module.exports = {
+    GraphOperation,
+};

package/lib/queryBuilder/graph/GraphOptions.js

@@ -0,0 +1,165 @@
+'use strict';
+const NO_RELATE = 'noRelate';
+const NO_UNRELATE = 'noUnrelate';
+const NO_INSERT = 'noInsert';
+const NO_UPDATE = 'noUpdate';
+const NO_DELETE = 'noDelete';
+const UPDATE = 'update';
+const RELATE = 'relate';
+const UNRELATE = 'unrelate';
+const INSERT_MISSING = 'insertMissing';
+const FETCH_STRATEGY = 'fetchStrategy';
+const ALLOW_REFS = 'allowRefs';
+const FetchStrategy = {
+    OnlyIdentifiers: 'OnlyIdentifiers',
+    Everything: 'Everything',
+    OnlyNeeded: 'OnlyNeeded',
+};
+class GraphOptions {
+    constructor(options) {
+        if (options instanceof GraphOptions) {
+            this.options = options.options;
+        }
+        else {
+            this.options = options;
+        }
+    }
+    isFetchStrategy(strategy) {
+        if (!FetchStrategy[strategy]) {
+            throw new Error(`unknown strategy "${strategy}"`);
+        }
+        if (!this.options[FETCH_STRATEGY]) {
+            return strategy === FetchStrategy.OnlyNeeded;
+        }
+        else {
+            return this.options[FETCH_STRATEGY] === strategy;
+        }
+    }
+    isInsertOnly() {
+        // NO_RELATE is not in the list, since the `insert only` mode does
+        // relate things that can be related using inserts.
+        // TODO: Use a special key for this.
+        return [NO_DELETE, NO_UPDATE, NO_UNRELATE, INSERT_MISSING].every((opt) => {
+            return this.options[opt] === true;
+        });
+    }
+    // Like `shouldRelate` but ignores settings that explicitly disable relate operations.
+    shouldRelateIgnoreDisable(node, graphData) {
+        if (node.isReference || node.isDbReference) {
+            return true;
+        }
+        return (this._hasOption(node, RELATE) &&
+            !getCurrentNode(node, graphData) &&
+            !!node.parentEdge &&
+            !!node.parentEdge.relation &&
+            node.parentEdge.relation.hasRelateProp(node.obj) &&
+            graphData.nodeDbExistence.doesNodeExistInDb(node));
+    }
+    shouldRelate(node, graphData) {
+        return !this._hasOption(node, NO_RELATE) && this.shouldRelateIgnoreDisable(node, graphData);
+    }
+    // Like `shouldInsert` but ignores settings that explicitly disable insert operations.
+    shouldInsertIgnoreDisable(node, graphData) {
+        return (!getCurrentNode(node, graphData) &&
+            !this.shouldRelateIgnoreDisable(node, graphData) &&
+            (!node.hasId || this.shouldInsertMissing(node)));
+    }
+    shouldInsert(node, graphData) {
+        return !this._hasOption(node, NO_INSERT) && this.shouldInsertIgnoreDisable(node, graphData);
+    }
+    shouldInsertMissing(node) {
+        return this._hasOption(node, INSERT_MISSING);
+    }
+    // Like `shouldPatch() || shouldUpdate()` but ignores settings that explicitly disable
+    // update or patch operations.
+    shouldPatchOrUpdateIgnoreDisable(node, graphData) {
+        if (this.shouldRelate(node, graphData)) {
+            // We should update all nodes that are going to be related. Note that
+            // we don't actually update anything unless there is something to update
+            // so this is just a preliminary test.
+            return true;
+        }
+        return !!getCurrentNode(node, graphData);
+    }
+    shouldPatch(node, graphData) {
+        return (this.shouldPatchOrUpdateIgnoreDisable(node, graphData) &&
+            !this._hasOption(node, NO_UPDATE) &&
+            !this._hasOption(node, UPDATE));
+    }
+    shouldUpdate(node, graphData) {
+        return (this.shouldPatchOrUpdateIgnoreDisable(node, graphData) &&
+            !this._hasOption(node, NO_UPDATE) &&
+            this._hasOption(node, UPDATE));
+    }
+    // Like `shouldUnrelate` but ignores settings that explicitly disable unrelate operations.
+    shouldUnrelateIgnoreDisable(currentNode) {
+        return this._hasOption(currentNode, UNRELATE);
+    }
+    shouldUnrelate(currentNode, graphData) {
+        return (!getNode(currentNode, graphData.graph) &&
+            !this._hasOption(currentNode, NO_UNRELATE) &&
+            this.shouldUnrelateIgnoreDisable(currentNode));
+    }
+    shouldDelete(currentNode, graphData) {
+        return (!getNode(currentNode, graphData.graph) &&
+            !this._hasOption(currentNode, NO_DELETE) &&
+            !this.shouldUnrelateIgnoreDisable(currentNode));
+    }
+    shouldInsertOrRelate(node, graphData) {
+        return this.shouldInsert(node, graphData) || this.shouldRelate(node, graphData);
+    }
+    shouldDeleteOrUnrelate(currentNode, graphData) {
+        return this.shouldDelete(currentNode, graphData) || this.shouldUnrelate(currentNode, graphData);
+    }
+    allowRefs() {
+        return !!this.options[ALLOW_REFS];
+    }
+    rebasedOptions(newRoot) {
+        const newOpt = {};
+        const newRootRelationPath = newRoot.relationPathKey;
+        for (const name of Object.keys(this.options)) {
+            const value = this.options[name];
+            if (Array.isArray(value)) {
+                newOpt[name] = value
+                    .filter((it) => it.startsWith(newRootRelationPath))
+                    .map((it) => it.slice(newRootRelationPath.length + 1))
+                    .filter((it) => !!it);
+            }
+            else {
+                newOpt[name] = value;
+            }
+        }
+        return new GraphOptions(newOpt);
+    }
+    _hasOption(node, optionName) {
+        const option = this.options[optionName];
+        if (Array.isArray(option)) {
+            return option.indexOf(node.relationPathKey) !== -1;
+        }
+        else if (typeof option === 'boolean') {
+            return option;
+        }
+        else if (option === undefined) {
+            return false;
+        }
+        else {
+            throw new Error(`expected ${optionName} option value "${option}" to be an instance of boolean or array of strings`);
+        }
+    }
+}
+function getCurrentNode(node, graphData) {
+    if (!graphData || !node) {
+        return null;
+    }
+    return graphData.currentGraph.nodeForNode(node);
+}
+function getNode(currentNode, graph) {
+    if (!graph || !currentNode) {
+        return null;
+    }
+    return graph.nodeForNode(currentNode);
+}
+module.exports = {
+    GraphOptions,
+    FetchStrategy,
+};