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

package/lib/queryBuilder/join/RelationJoiner.js

@@ -0,0 +1,258 @@
+'use strict';
+const { uniqBy } = require('../../utils/objectUtils');
+const { Selection } = require('../operations/select/Selection');
+const { createModifier } = require('../../utils/createModifier');
+const { map: mapPromise } = require('../../utils/promiseUtils');
+const { getReadConcurrency } = require('../../model/modelConcurrency');
+const { ValidationErrorType } = require('../../model/ValidationError');
+const { TableTree } = require('./TableTree');
+const { JoinResultParser } = require('./JoinResultParser');
+const { ID_LENGTH_LIMIT } = require('./utils');
+/**
+ * Given a relation expression, builds a query using joins to fetch it.
+ */
+class RelationJoiner {
+    constructor({ modelClass }) {
+        this.rootModelClass = modelClass;
+        // The relation expression to join.
+        this.expression = null;
+        // Explicit modifiers for the relation expression.
+        this.modifiers = null;
+        this.options = defaultOptions();
+        this.tableTree = null;
+        this.internalSelections = null;
+    }
+    setExpression(expression) {
+        if (!this.expression) {
+            this.expression = expression;
+        }
+        return this;
+    }
+    setModifiers(modifiers) {
+        if (!this.modifiers) {
+            this.modifiers = modifiers;
+        }
+        return this;
+    }
+    setOptions(options) {
+        this.options = Object.assign(this.options, options);
+        return this;
+    }
+    /**
+     * Fetches the column information needed for building the select clauses.
+     *
+     * This must be called before calling `build(builder, true)`. `build(builder, false)`
+     * can be called without this since it doesn't build selects.
+     */
+    fetchColumnInfo(builder) {
+        const tableTree = this._getTableTree(builder);
+        const allModelClasses = new Set(tableTree.nodes.map((node) => node.modelClass));
+        return mapPromise(Array.from(allModelClasses), (modelClass) => modelClass.fetchTableMetadata({ parentBuilder: builder }), {
+            concurrency: getReadConcurrency(this.rootModelClass, builder.unsafeKnex()),
+        });
+    }
+    build(builder, buildSelects = true) {
+        const rootTableNode = this._getTableTree(builder).rootNode;
+        const userSelectQueries = new Map([[rootTableNode, builder]]);
+        for (const tableNode of rootTableNode.childNodes) {
+            this._buildJoinsForNode({ builder, tableNode, userSelectQueries });
+        }
+        if (buildSelects) {
+            this._buildSelects({ builder, tableNode: rootTableNode, userSelectQueries });
+        }
+    }
+    parseResult(builder, flatRows) {
+        const parser = JoinResultParser.create({
+            tableTree: this._getTableTree(builder),
+            omitColumnAliases: this.internalSelections.map((it) => it.alias),
+        });
+        return parser.parse(flatRows);
+    }
+    _getTableTree(builder) {
+        if (!this.tableTree) {
+            // Create the table tree lazily.
+            this.tableTree = TableTree.create({
+                rootModelClass: this.rootModelClass,
+                rootTableAlias: builder.tableRef(),
+                expression: this.expression,
+                options: this.options,
+            });
+        }
+        return this.tableTree;
+    }
+    _buildJoinsForNode({ builder, tableNode, userSelectQueries }) {
+        const subqueryToJoin = createSubqueryToJoin({
+            builder,
+            tableNode,
+            modifiers: this.modifiers,
+        });
+        const userSelectQuery = subqueryToJoin.clone();
+        // relation.join applies the relation modifier that can
+        // also contain selects.
+        userSelectQuery.modify(tableNode.relation.modify);
+        // Save the query that contains the user specified selects
+        // for later use.
+        userSelectQueries.set(tableNode, userSelectQuery);
+        tableNode.relation.join(builder, {
+            joinOperation: this.options.joinOperation,
+            ownerTable: tableNode.parentNode.alias,
+            relatedTableAlias: tableNode.alias,
+            joinTableAlias: tableNode.getJoinTableAlias(builder),
+            relatedJoinSelectQuery: ensureIdAndRelationPropsAreSelected({
+                builder: subqueryToJoin,
+                tableNode,
+            }),
+        });
+        for (const childNode of tableNode.childNodes) {
+            this._buildJoinsForNode({ builder, tableNode: childNode, userSelectQueries });
+        }
+    }
+    _buildSelects({ builder, tableNode, userSelectQueries }) {
+        const { selections, internalSelections } = getSelectionsForNode({
+            builder,
+            tableNode,
+            userSelectQueries,
+        });
+        for (const selection of selections) {
+            checkAliasLength(tableNode.modelClass, selection.name);
+        }
+        // Save the selections that were added internally (not by the user)
+        // so that we can later remove the corresponding properties when
+        // parsing the result.
+        this.internalSelections = internalSelections;
+        builder.select(selectionsToStrings(selections));
+    }
+}
+function defaultOptions() {
+    return {
+        joinOperation: 'leftJoin',
+        minimize: false,
+        separator: ':',
+        aliases: {},
+    };
+}
+function createSubqueryToJoin({ builder, tableNode, modifiers }) {
+    const { relation, expression, modelClass } = tableNode;
+    const modifierQuery = modelClass.query().childQueryOf(builder);
+    for (const modifierName of expression.node.$modify) {
+        const modifier = createModifier({
+            modifier: modifierName,
+            modelClass,
+            modifiers,
+        });
+        try {
+            modifier(modifierQuery);
+        }
+        catch (err) {
+            if (err instanceof modelClass.ModifierNotFoundError) {
+                throw modelClass.createValidationError({
+                    type: ValidationErrorType.RelationExpression,
+                    message: `could not find modifier "${modifierName}" for relation "${relation.name}"`,
+                });
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    return modifierQuery;
+}
+function ensureIdAndRelationPropsAreSelected({ builder, tableNode }) {
+    const tableRef = builder.tableRef();
+    const cols = [
+        ...builder.modelClass().getIdColumnArray(),
+        ...tableNode.relation.relatedProp.cols,
+        ...tableNode.childNodes.reduce((cols, childNode) => [...cols, ...childNode.relation.ownerProp.cols], []),
+    ];
+    const selectStrings = uniqBy(cols)
+        .filter((col) => !builder.hasSelectionAs(col, col))
+        .map((col) => `${tableRef}.${col}`);
+    return builder.select(selectStrings);
+}
+function getSelectionsForNode({ builder, tableNode, userSelectQueries }) {
+    const userSelectQuery = userSelectQueries.get(tableNode);
+    const userSelections = userSelectQuery.findAllSelections();
+    const userSelectedAllColumns = isSelectAllSelectionSet(userSelections);
+    let selections = [];
+    let internalSelections = [];
+    if (tableNode.parentNode) {
+        selections = mapUserSelectionsFromSubqueryToMainQuery({ userSelections, tableNode });
+        if (userSelectedAllColumns && tableNode.relation.isObjectionManyToManyRelation) {
+            const extraSelections = getJoinTableExtraSelectionsForNode({ builder, tableNode });
+            selections = selections.concat(extraSelections);
+        }
+    }
+    if (userSelectedAllColumns) {
+        const allColumnSelections = getAllColumnSelectionsForNode({ builder, tableNode });
+        selections = allColumnSelections.concat(selections);
+    }
+    else {
+        const idSelections = getIdSelectionsForNode({ tableNode });
+        for (const idSelection of idSelections) {
+            if (!userSelectQuery.hasSelectionAs(idSelection.column, idSelection.column)) {
+                selections.push(idSelection);
+                internalSelections.push(idSelection);
+            }
+        }
+    }
+    for (const childNode of tableNode.childNodes) {
+        const childResult = getSelectionsForNode({ builder, tableNode: childNode, userSelectQueries });
+        selections = selections.concat(childResult.selections);
+        internalSelections = internalSelections.concat(childResult.internalSelections);
+    }
+    return {
+        selections,
+        internalSelections,
+    };
+}
+function mapUserSelectionsFromSubqueryToMainQuery({ userSelections, tableNode }) {
+    return userSelections.filter(isNotSelectAll).map((selection) => {
+        return new Selection(tableNode.alias, selection.name, tableNode.getColumnAliasForColumn(selection.name));
+    });
+}
+function getJoinTableExtraSelectionsForNode({ builder, tableNode }) {
+    return tableNode.relation.joinTableExtras.map((extra) => {
+        return new Selection(tableNode.getJoinTableAlias(builder), extra.joinTableCol, tableNode.getColumnAliasForColumn(extra.aliasCol));
+    });
+}
+function getAllColumnSelectionsForNode({ builder, tableNode }) {
+    const table = builder.tableNameFor(tableNode.modelClass);
+    const tableMeta = tableNode.modelClass.tableMetadata({ table });
+    if (!tableMeta) {
+        throw new Error(`table metadata has not been fetched for table '${table}'. Are you trying to call toKnexQuery() for a withGraphJoined query? To make sure the table metadata is fetched see the objection.initialize function.`);
+    }
+    return tableMeta.columns.map((columnName) => {
+        return new Selection(tableNode.alias, columnName, tableNode.getColumnAliasForColumn(columnName));
+    });
+}
+function getIdSelectionsForNode({ tableNode }) {
+    return tableNode.modelClass.getIdColumnArray().map((columnName) => {
+        return new Selection(tableNode.alias, columnName, tableNode.getColumnAliasForColumn(columnName));
+    });
+}
+function selectionsToStrings(selections) {
+    return selections.map((selection) => {
+        const selectStr = `${selection.table}.${selection.column}`;
+        return `${selectStr} as ${selection.alias}`;
+    });
+}
+function isSelectAll(selection) {
+    return selection.column === '*';
+}
+function isNotSelectAll(selection) {
+    return selection.column !== '*';
+}
+function isSelectAllSelectionSet(selections) {
+    return selections.length === 0 || selections.some(isSelectAll);
+}
+function checkAliasLength(modelClass, alias) {
+    if (alias.length > ID_LENGTH_LIMIT) {
+        throw modelClass.createValidationError({
+            type: ValidationErrorType.RelationExpression,
+            message: `identifier ${alias} is over ${ID_LENGTH_LIMIT} characters long and would be truncated by the database engine.`,
+        });
+    }
+}
+module.exports = {
+    RelationJoiner,
+};

package/lib/queryBuilder/join/TableNode.js

@@ -0,0 +1,136 @@
+'use strict';
+class TableNode {
+    constructor({ tableTree, modelClass, expression, parentNode = null, relation = null }) {
+        this.tableTree = tableTree;
+        this.modelClass = modelClass;
+        this.parentNode = parentNode;
+        this.relation = relation;
+        this.expression = expression;
+        this.childNodes = [];
+        this.alias = this._calculateAlias();
+        this.idGetter = this._createIdGetter();
+    }
+    static create(args) {
+        const node = new TableNode(args);
+        if (node.parentNode) {
+            node.parentNode.childNodes.push(node);
+        }
+        return node;
+    }
+    get options() {
+        return this.tableTree.options;
+    }
+    get relationProperty() {
+        return this.expression.node.$name;
+    }
+    getReferenceForColumn(column) {
+        return `${this.alias}.${column}`;
+    }
+    getColumnAliasForColumn(column) {
+        if (this.parentNode) {
+            return `${this.alias}${this.options.separator}${column}`;
+        }
+        else {
+            return column;
+        }
+    }
+    getColumnForColumnAlias(columnAlias) {
+        const lastSepIndex = columnAlias.lastIndexOf(this.options.separator);
+        if (lastSepIndex === -1) {
+            return columnAlias;
+        }
+        else {
+            return columnAlias.slice(lastSepIndex + this.options.separator.length);
+        }
+    }
+    getIdFromFlatRow(flatRow) {
+        return this.idGetter(flatRow);
+    }
+    getJoinTableAlias(builder) {
+        if (this.relation.isObjectionManyToManyRelation) {
+            return (builder.aliasFor(this.relation.joinTableModelClass) ||
+                this.modelClass.joinTableAlias(this.alias));
+        }
+        else {
+            return undefined;
+        }
+    }
+    _calculateAlias() {
+        if (this.parentNode) {
+            const relationName = this.expression.node.$name;
+            const alias = this.options.aliases[relationName] || relationName;
+            if (this.options.minimize) {
+                return `_t${this.tableTree.createNextUid()}`;
+            }
+            else if (this.parentNode.parentNode) {
+                return `${this.parentNode.alias}${this.options.separator}${alias}`;
+            }
+            else {
+                return alias;
+            }
+        }
+        else {
+            return this.tableTree.rootTableAlias;
+        }
+    }
+    _createIdGetter() {
+        const idColumns = this.modelClass.getIdColumnArray();
+        const columnAliases = idColumns.map((column) => this.getColumnAliasForColumn(column));
+        if (idColumns.length === 1) {
+            return createIdGetter(columnAliases);
+        }
+        else {
+            return createCompositeIdGetter(columnAliases);
+        }
+    }
+}
+function createIdGetter(columnAliases) {
+    const columnAlias = columnAliases[0];
+    return (flatRow) => {
+        const id = flatRow[columnAlias];
+        if (id === null) {
+            return null;
+        }
+        return `${id}`;
+    };
+}
+function createCompositeIdGetter(columnAliases) {
+    if (columnAliases.length === 2) {
+        return createTwoIdGetter(columnAliases);
+    }
+    else {
+        return createMultiIdGetter(columnAliases);
+    }
+}
+function createTwoIdGetter(columnAliases) {
+    const columnAlias1 = columnAliases[0];
+    const columnAlias2 = columnAliases[1];
+    return (flatRow) => {
+        const id1 = flatRow[columnAlias1];
+        const id2 = flatRow[columnAlias2];
+        if (id1 === null || id2 === null) {
+            return null;
+        }
+        return `${id1},${id2}`;
+    };
+}
+function createMultiIdGetter(columnAliases) {
+    return (flatRow) => {
+        let idStr = '';
+        for (let i = 0, l = columnAliases.length; i < l; ++i) {
+            const columnAlias = columnAliases[i];
+            const id = flatRow[columnAlias];
+            if (id === null) {
+                return null;
+            }
+            idStr += id;
+            if (i !== l - 1) {
+                idStr += ',';
+            }
+        }
+        return idStr;
+    };
+}
+module.exports = {
+    TableNode,
+};

package/lib/queryBuilder/join/TableTree.js

@@ -0,0 +1,69 @@
+'use strict';
+const { forEachChildExpression } = require('./utils');
+const { TableNode } = require('./TableNode');
+class TableTree {
+    constructor({ expression, rootModelClass, rootTableAlias, options }) {
+        this.options = options;
+        this.rootModelClass = rootModelClass;
+        this.rootTableAlias = rootTableAlias;
+        this.nodes = [];
+        this.nodesByAlias = new Map();
+        this.uidCounter = 0;
+        this._createNodes({ expression, modelClass: rootModelClass });
+    }
+    static create(args) {
+        return new TableTree(args);
+    }
+    get rootNode() {
+        return this.nodes[0];
+    }
+    getNodeForColumnAlias(columnAlias) {
+        const lastSepIndex = columnAlias.lastIndexOf(this.options.separator);
+        if (lastSepIndex === -1) {
+            return this.rootNode;
+        }
+        else {
+            const tableAlias = columnAlias.slice(0, lastSepIndex);
+            return this.nodesByAlias.get(tableAlias);
+        }
+    }
+    createNextUid() {
+        return this.uidCounter++;
+    }
+    _createNodes({ expression, modelClass }) {
+        const rootNode = this._createRootNode({ expression, modelClass });
+        this._createChildNodes({ expression, modelClass, parentNode: rootNode });
+        for (const node of this.nodes) {
+            this.nodesByAlias.set(node.alias, node);
+        }
+    }
+    _createRootNode({ expression, modelClass }) {
+        const node = TableNode.create({
+            tableTree: this,
+            modelClass,
+            expression,
+        });
+        this.nodes.push(node);
+        return node;
+    }
+    _createChildNodes({ expression, modelClass, parentNode }) {
+        forEachChildExpression(expression, modelClass, (childExpr, relation) => {
+            const node = TableNode.create({
+                tableTree: this,
+                modelClass: relation.relatedModelClass,
+                expression: childExpr,
+                parentNode,
+                relation,
+            });
+            this.nodes.push(node);
+            this._createChildNodes({
+                expression: childExpr,
+                modelClass: relation.relatedModelClass,
+                parentNode: node,
+            });
+        });
+    }
+}
+module.exports = {
+    TableTree,
+};

package/lib/queryBuilder/join/utils.js

@@ -0,0 +1,19 @@
+'use strict';
+const { ValidationErrorType } = require('../../model/ValidationError');
+const ID_LENGTH_LIMIT = 63;
+const RELATION_RECURSION_LIMIT = 64;
+// Given a relation expression, goes through all first level children.
+function forEachChildExpression(expr, modelClass, callback) {
+    if (expr.node.$allRecursive || expr.maxRecursionDepth > RELATION_RECURSION_LIMIT) {
+        throw modelClass.createValidationError({
+            type: ValidationErrorType.RelationExpression,
+            message: `recursion depth of eager expression ${expr.toString()} too big for JoinEagerAlgorithm`,
+        });
+    }
+    expr.forEachChildExpression(modelClass, callback);
+}
+module.exports = {
+    ID_LENGTH_LIMIT,
+    RELATION_RECURSION_LIMIT,
+    forEachChildExpression,
+};

package/lib/queryBuilder/operations/DelegateOperation.js

@@ -0,0 +1,101 @@
+'use strict';
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+// Operation that simply delegates all calls to the operation passed
+// to to the constructor in `opt.delegate`.
+class DelegateOperation extends QueryBuilderOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        this.delegate = opt.delegate;
+    }
+    get modelOptions() {
+        return this.delegate.modelOptions;
+    }
+    is(OperationClass) {
+        return super.is(OperationClass) || this.delegate.is(OperationClass);
+    }
+    onAdd(builder, args) {
+        return this.delegate.onAdd(builder, args);
+    }
+    onBefore1(builder, result) {
+        return this.delegate.onBefore1(builder, result);
+    }
+    hasOnBefore1() {
+        return this.onBefore1 !== DelegateOperation.prototype.onBefore1 || this.delegate.hasOnBefore1();
+    }
+    onBefore2(builder, result) {
+        return this.delegate.onBefore2(builder, result);
+    }
+    hasOnBefore2() {
+        return this.onBefore2 !== DelegateOperation.prototype.onBefore2 || this.delegate.hasOnBefore2();
+    }
+    onBefore3(builder, result) {
+        return this.delegate.onBefore3(builder, result);
+    }
+    hasOnBefore3() {
+        return this.onBefore3 !== DelegateOperation.prototype.onBefore3 || this.delegate.hasOnBefore3();
+    }
+    onBuild(builder) {
+        return this.delegate.onBuild(builder);
+    }
+    hasOnBuild() {
+        return this.onBuild !== DelegateOperation.prototype.onBuild || this.delegate.hasOnBuild();
+    }
+    onBuildKnex(knexBuilder, builder) {
+        return this.delegate.onBuildKnex(knexBuilder, builder);
+    }
+    hasOnBuildKnex() {
+        return (this.onBuildKnex !== DelegateOperation.prototype.onBuildKnex || this.delegate.hasOnBuildKnex());
+    }
+    onRawResult(builder, result) {
+        return this.delegate.onRawResult(builder, result);
+    }
+    hasOnRawResult() {
+        return (this.onRawResult !== DelegateOperation.prototype.onRawResult || this.delegate.hasOnRawResult());
+    }
+    onAfter1(builder, result) {
+        return this.delegate.onAfter1(builder, result);
+    }
+    hasOnAfter1() {
+        return this.onAfter1 !== DelegateOperation.prototype.onAfter1 || this.delegate.hasOnAfter1();
+    }
+    onAfter2(builder, result) {
+        return this.delegate.onAfter2(builder, result);
+    }
+    hasOnAfter2() {
+        return this.onAfter2 !== DelegateOperation.prototype.onAfter2 || this.delegate.hasOnAfter2();
+    }
+    onAfter3(builder, result) {
+        return this.delegate.onAfter3(builder, result);
+    }
+    hasOnAfter3() {
+        return this.onAfter3 !== DelegateOperation.prototype.onAfter3 || this.delegate.hasOnAfter3();
+    }
+    queryExecutor(builder) {
+        return this.delegate.queryExecutor(builder);
+    }
+    hasQueryExecutor() {
+        return (this.queryExecutor !== DelegateOperation.prototype.queryExecutor ||
+            this.delegate.hasQueryExecutor());
+    }
+    onError(builder, error) {
+        return this.delegate.onError(builder, error);
+    }
+    hasOnError() {
+        return this.onError !== DelegateOperation.prototype.onError || this.delegate.hasOnError();
+    }
+    toFindOperation(builder) {
+        return this.delegate.toFindOperation(builder);
+    }
+    hasToFindOperation() {
+        return (this.hasToFindOperation !== DelegateOperation.prototype.hasToFindOperation ||
+            this.delegate.hasToFindOperation());
+    }
+    clone() {
+        const clone = super.clone();
+        clone.delegate = this.delegate && this.delegate.clone();
+        return clone;
+    }
+}
+module.exports = {
+    DelegateOperation,
+};

package/lib/queryBuilder/operations/DeleteOperation.js

@@ -0,0 +1,47 @@
+'use strict';
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+const { StaticHookArguments, hasStaticHook } = require('../StaticHookArguments');
+class DeleteOperation extends QueryBuilderOperation {
+    async onBefore2(builder, result) {
+        await callBeforeDelete(builder);
+        return result;
+    }
+    onBuildKnex(knexBuilder) {
+        return knexBuilder.delete();
+    }
+    onAfter2(builder, result) {
+        return callAfterDelete(builder, result);
+    }
+    toFindOperation() {
+        return null;
+    }
+}
+function callBeforeDelete(builder) {
+    return callStaticBeforeDelete(builder);
+}
+function callStaticBeforeDelete(builder) {
+    if (!hasStaticHook(builder.modelClass(), 'beforeDelete')) {
+        return undefined;
+    }
+    const args = StaticHookArguments.create({ builder });
+    return builder.modelClass().beforeDelete(args);
+}
+function callAfterDelete(builder, result) {
+    return callStaticAfterDelete(builder, result);
+}
+async function callStaticAfterDelete(builder, result) {
+    if (!hasStaticHook(builder.modelClass(), 'afterDelete')) {
+        return result;
+    }
+    const args = StaticHookArguments.create({ builder, result });
+    const maybeResult = await builder.modelClass().afterDelete(args);
+    if (maybeResult === undefined) {
+        return result;
+    }
+    else {
+        return maybeResult;
+    }
+}
+module.exports = {
+    DeleteOperation,
+};

package/lib/queryBuilder/operations/FindByIdOperation.js

@@ -0,0 +1,29 @@
+'use strict';
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+const { assertIdNotUndefined } = require('../../utils/assert');
+class FindByIdOperation extends QueryBuilderOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        this.id = this.opt.id;
+    }
+    onAdd(builder, args) {
+        if (this.id === null || this.id === undefined) {
+            this.id = args[0];
+        }
+        return super.onAdd(builder, args);
+    }
+    onBuild(builder) {
+        if (!builder.internalOptions().skipUndefined) {
+            assertIdNotUndefined(this.id, `undefined was passed to ${this.name}`);
+        }
+        builder.whereComposite(builder.fullIdColumn(), this.id);
+    }
+    clone() {
+        const clone = super.clone();
+        clone.id = this.id;
+        return clone;
+    }
+}
+module.exports = {
+    FindByIdOperation,
+};

package/lib/queryBuilder/operations/FindByIdsOperation.js

@@ -0,0 +1,23 @@
+'use strict';
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+class FindByIdsOperation extends QueryBuilderOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        this.ids = null;
+    }
+    onAdd(builder, args) {
+        this.ids = args[0];
+        return super.onAdd(builder, args);
+    }
+    onBuild(builder) {
+        builder.whereInComposite(builder.fullIdColumn(), this.ids);
+    }
+    clone() {
+        const clone = super.clone();
+        clone.ids = this.ids;
+        return clone;
+    }
+}
+module.exports = {
+    FindByIdsOperation,
+};