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

package/lib/queryBuilder/transformations/CompositeQueryTransformation.js

@@ -0,0 +1,17 @@
+'use strict';
+const { QueryTransformation } = require('./QueryTransformation');
+class CompositeQueryTransformation extends QueryTransformation {
+    constructor(transformations) {
+        super();
+        this.transformations = transformations;
+    }
+    onConvertQueryBuilderBase(item, builder) {
+        for (const transformation of this.transformations) {
+            item = transformation.onConvertQueryBuilderBase(item, builder);
+        }
+        return item;
+    }
+}
+module.exports = {
+    CompositeQueryTransformation,
+};

package/lib/queryBuilder/transformations/QueryTransformation.js

@@ -0,0 +1,9 @@
+'use strict';
+class QueryTransformation {
+    onConvertQueryBuilderBase(item, builder) {
+        return item;
+    }
+}
+module.exports = {
+    QueryTransformation,
+};

package/lib/queryBuilder/transformations/WrapMysqlModifySubqueryTransformation.js

@@ -0,0 +1,57 @@
+'use strict';
+const { QueryTransformation } = require('./QueryTransformation');
+const { isMySql } = require('../../utils/knexUtils');
+/**
+ * Mysql doesn't allow queries like this:
+ *
+ *   update foo set bar = 1 where id in (select id from foo)
+ *
+ * because the subquery is for the same table `foo` as the parent update query.
+ * The same goes for delete queries too.
+ *
+ * This transformation wraps those subqueries like this:
+ *
+ *   update foo set bar = 1 where id in (select * from (select id from foo))
+ */
+class WrapMysqlModifySubqueryTransformation extends QueryTransformation {
+    onConvertQueryBuilderBase(query, parentQuery) {
+        const knex = parentQuery.unsafeKnex();
+        // Cannot detect anything if, for whatever reason, a knex instance
+        // or a transaction is not registered at this point.
+        if (!knex) {
+            return query;
+        }
+        // This transformation only applies to MySQL.
+        if (!isMySql(knex)) {
+            return query;
+        }
+        // A subquery in a join callback belongs to the query of the join.
+        while (parentQuery && typeof parentQuery.isUpdate !== 'function') {
+            parentQuery = parentQuery.parentQuery();
+        }
+        // This transformation only applies to update and delete queries.
+        if (!parentQuery || (!parentQuery.isUpdate() && !parentQuery.isDelete())) {
+            return query;
+        }
+        // If the subquery is for another table and the query doesn't join the
+        // parent query's table, we're good to go.
+        if (parentQuery.tableName() !== query.tableName() &&
+            !hasJoinsToTable(query, parentQuery.tableName())) {
+            return query;
+        }
+        return query.modelClass().query().from(query.as('mysql_subquery_fix'));
+    }
+}
+function hasJoinsToTable(query, tableName) {
+    let found = false;
+    query.forEachOperation(query.constructor.JoinSelector, (op) => {
+        if (op.args[0] === tableName) {
+            found = true;
+            return false;
+        }
+    });
+    return found;
+}
+module.exports = {
+    WrapMysqlModifySubqueryTransformation,
+};

package/lib/queryBuilder/transformations/index.js

@@ -0,0 +1,9 @@
+'use strict';
+const { CompositeQueryTransformation } = require('./CompositeQueryTransformation');
+const { WrapMysqlModifySubqueryTransformation, } = require('./WrapMysqlModifySubqueryTransformation');
+const transformation = new CompositeQueryTransformation([
+    new WrapMysqlModifySubqueryTransformation(),
+]);
+module.exports = {
+    transformation,
+};

package/lib/queryBuilder/whereScopes.js

@@ -0,0 +1,199 @@
+'use strict';
+const { isObject, isFunction } = require('../utils/objectUtils');
+const { isKnexRaw } = require('../utils/knexUtils');
+// Where clauses objection adds on its own, like the owner condition of a relation
+// query or the id condition of `$query()`, are tagged with a "where scope". When
+// a query has where clauses from more than one scope, the clauses of each scope
+// are wrapped in parentheses so that an `orWhere` in one scope can't escape the
+// conditions of the others. Without this, `$relatedQuery('pets').where(a).orWhere(b)`
+// would produce `owner and a or b` and match other owners' pets.
+//
+// The scopes are only used when the knex query is built. The operation tree is
+// never modified.
+const WhereSelector = /^(where|orWhere|andWhere|find\w+)/;
+// Where operations that only ever produce a single predicate or predicates
+// joined with `and`. A scope that only contains these (and no raw arguments)
+// doesn't need to be wrapped in parentheses.
+const AND_ONLY_OPERATIONS = new Set([
+    'where',
+    'andWhere',
+    'whereNot',
+    'andWhereNot',
+    'whereIn',
+    'whereNotIn',
+    'whereNull',
+    'whereNotNull',
+    'whereBetween',
+    'whereNotBetween',
+    'whereExists',
+    'whereNotExists',
+    'whereColumn',
+    'andWhereColumn',
+    'whereNotColumn',
+    'andWhereNotColumn',
+    'whereLike',
+    'whereILike',
+    'whereWrapped',
+    'whereComposite',
+    'whereInComposite',
+    'whereJsonSupersetOf',
+    'whereJsonSubsetOf',
+    'whereJsonNotSupersetOf',
+    'whereJsonNotSubsetOf',
+    'whereJsonHasAny',
+    'whereJsonHasAll',
+    'whereJsonNotArray',
+    'whereJsonNotObject',
+    'whereJsonOverlaps',
+    'whereJsonNotOverlaps',
+    'whereJsonObject',
+    'whereNotJsonObject',
+    'whereJsonPath',
+    'findById',
+    'findByIds',
+]);
+function withWhereScope(builder, callback) {
+    const previous = builder._whereScope;
+    // A fresh object works as a unique token.
+    builder._whereScope = {};
+    try {
+        return callback();
+    }
+    finally {
+        builder._whereScope = previous;
+    }
+}
+function effectiveWhereScope(op) {
+    while (op) {
+        if (op.whereScope !== null) {
+            return op.whereScope;
+        }
+        op = op.parentOperation;
+    }
+    return null;
+}
+// Returns null if no where clauses need to be grouped. Otherwise returns an
+// object that tells, for each operation, whether the operation is built as
+// part of a group.
+function createWhereGrouping(builder) {
+    const scopes = new Map();
+    builder.forEachOperation(WhereSelector, (op) => {
+        if (!hasWhereAncestor(op)) {
+            const scope = effectiveWhereScope(op);
+            const ops = scopes.get(scope) || [];
+            ops.push(op);
+            scopes.set(scope, ops);
+        }
+    });
+    if (scopes.size < 2) {
+        return null;
+    }
+    const groupByFirstOp = new Map();
+    const groupedOps = new Set();
+    for (const ops of scopes.values()) {
+        if (ops.every(isAndOnlyTree)) {
+            continue;
+        }
+        groupByFirstOp.set(ops[0], ops);
+        for (const op of ops) {
+            groupedOps.add(op);
+            op.forEachDescendantOperation((it) => {
+                groupedOps.add(it);
+            });
+        }
+    }
+    if (groupedOps.size === 0) {
+        return null;
+    }
+    return {
+        isGrouped(op) {
+            return groupedOps.has(op);
+        },
+        // Builds the whole group if `op` is the first operation of a group.
+        build(op, knexBuilder) {
+            const ops = groupByFirstOp.get(op);
+            if (!ops) {
+                return knexBuilder;
+            }
+            return knexBuilder.where(function () {
+                let groupBuilder = this;
+                for (const groupOp of ops) {
+                    groupBuilder = buildOperationTree(builder, groupOp, groupBuilder);
+                }
+            });
+        },
+    };
+}
+function buildOperationTree(builder, op, knexBuilder) {
+    const ops = [op];
+    op.forEachDescendantOperation((it) => {
+        ops.push(it);
+    });
+    for (const it of ops) {
+        if (it.hasOnBuildKnex()) {
+            knexBuilder =
+                builder.callOperationMethod(it, 'onBuildKnex', [knexBuilder, builder]) || knexBuilder;
+        }
+    }
+    return knexBuilder;
+}
+function hasWhereAncestor(op) {
+    for (let parent = op.parentOperation; parent; parent = parent.parentOperation) {
+        if (WhereSelector.test(parent.name)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isAndOnlyTree(op) {
+    if (!isAndOnly(op)) {
+        return false;
+    }
+    let andOnly = true;
+    op.forEachDescendantOperation((it) => {
+        if (it.hasOnBuildKnex() && !isAndOnly(it)) {
+            andOnly = false;
+            return false;
+        }
+    });
+    return andOnly;
+}
+function isAndOnly(op) {
+    return AND_ONLY_OPERATIONS.has(op.name) && !containsRaw(op.args);
+}
+function containsRaw(value) {
+    if (Array.isArray(value)) {
+        return value.some(containsRaw);
+    }
+    else if (!isObject(value)) {
+        return false;
+    }
+    else if (value.isObjectionReferenceBuilder) {
+        // A reference is always a single (possibly casted) column or json path.
+        return false;
+    }
+    else if (value.isObjectionFunctionBuilder) {
+        // `fn()` calls and expressions like `ref('a').eq(1)` are wrapped in parentheses,
+        // so only their arguments can contain anything.
+        return containsRaw(value._args);
+    }
+    else if (isKnexRaw(value) || isFunction(value.toKnexRaw)) {
+        // Raw sql (and anything that is converted into it) can contain anything.
+        return true;
+    }
+    else if (value.isObjectionQueryBuilderBase || isFunction(value.toSQL)) {
+        // Subqueries are always wrapped in parentheses.
+        return false;
+    }
+    else if (Object.getPrototypeOf(value) === Object.prototype) {
+        return Object.values(value).some(containsRaw);
+    }
+    else {
+        return false;
+    }
+}
+module.exports = {
+    withWhereScope,
+    effectiveWhereScope,
+    createWhereGrouping,
+};

package/lib/relations/Relation.js

@@ -0,0 +1,317 @@
+'use strict';
+const { withWhereScope } = require('../queryBuilder/whereScopes');
+const { RelationProperty } = require('./RelationProperty');
+const { RelationFindOperation } = require('./RelationFindOperation');
+const { RelationUpdateOperation } = require('./RelationUpdateOperation');
+const { RelationDeleteOperation } = require('./RelationDeleteOperation');
+const { resolveModel } = require('../utils/resolveModel');
+const { get, isFunction } = require('../utils/objectUtils');
+const { mapAfterAllReturn } = require('../utils/promiseUtils');
+const { createModifier } = require('../utils/createModifier');
+class Relation {
+    constructor(relationName, OwnerClass) {
+        this.name = relationName;
+        this.ownerModelClass = OwnerClass;
+        this.relatedModelClass = null;
+        this.ownerProp = null;
+        this.relatedProp = null;
+        this.joinTableModelClass = null;
+        this.joinTableOwnerProp = null;
+        this.joinTableRelatedProp = null;
+        this.joinTableBeforeInsert = null;
+        this.joinTableExtras = [];
+        this.modify = null;
+        this.beforeInsert = null;
+    }
+    setMapping(mapping) {
+        let ctx = {
+            name: this.name,
+            mapping,
+            ownerModelClass: this.ownerModelClass,
+            relatedModelClass: null,
+            relatedProp: null,
+            ownerProp: null,
+            modify: null,
+            beforeInsert: null,
+            forbiddenMappingProperties: this.forbiddenMappingProperties,
+            createError: (msg) => this.createError(msg),
+        };
+        ctx = checkForbiddenProperties(ctx);
+        ctx = checkOwnerModelClass(ctx);
+        ctx = checkRelatedModelClass(ctx);
+        ctx = resolveRelatedModelClass(ctx);
+        ctx = checkRelation(ctx);
+        ctx = createJoinProperties(ctx);
+        ctx = parseModify(ctx);
+        ctx = parseBeforeInsert(ctx);
+        this.relatedModelClass = ctx.relatedModelClass;
+        this.ownerProp = ctx.ownerProp;
+        this.relatedProp = ctx.relatedProp;
+        this.modify = ctx.modify;
+        this.beforeInsert = ctx.beforeInsert;
+    }
+    get forbiddenMappingProperties() {
+        return ['join.through'];
+    }
+    get joinTable() {
+        return this.joinTableModelClass ? this.joinTableModelClass.getTableName() : null;
+    }
+    get joinModelClass() {
+        return this.getJoinModelClass(this.ownerModelClass.knex());
+    }
+    getJoinModelClass(knex) {
+        return this.joinTableModelClass && knex !== this.joinTableModelClass.knex()
+            ? this.joinTableModelClass.bindKnex(knex)
+            : this.joinTableModelClass;
+    }
+    isOneToOne() {
+        return false;
+    }
+    clone() {
+        const relation = new this.constructor(this.name, this.ownerModelClass);
+        relation.relatedModelClass = this.relatedModelClass;
+        relation.ownerProp = this.ownerProp;
+        relation.relatedProp = this.relatedProp;
+        relation.modify = this.modify;
+        relation.beforeInsert = this.beforeInsert;
+        relation.joinTableModelClass = this.joinTableModelClass;
+        relation.joinTableOwnerProp = this.joinTableOwnerProp;
+        relation.joinTableRelatedProp = this.joinTableRelatedProp;
+        relation.joinTableBeforeInsert = this.joinTableBeforeInsert;
+        relation.joinTableExtras = this.joinTableExtras;
+        return relation;
+    }
+    bindKnex(knex) {
+        const bound = this.clone();
+        bound.relatedModelClass = this.relatedModelClass.bindKnex(knex);
+        bound.ownerModelClass = this.ownerModelClass.bindKnex(knex);
+        if (this.joinTableModelClass) {
+            bound.joinTableModelClass = this.joinTableModelClass.bindKnex(knex);
+        }
+        return bound;
+    }
+    findQuery(builder, owner) {
+        const relatedRefs = this.relatedProp.refs(builder);
+        withWhereScope(builder, () => {
+            owner.buildFindQuery(builder, this, relatedRefs);
+        });
+        return this.applyModify(builder);
+    }
+    applyModify(builder) {
+        try {
+            // The relation's `modify` gets its own scope so that an `orWhere`
+            // in it can't escape the owner condition.
+            return withWhereScope(builder, () => builder.modify(this.modify));
+        }
+        catch (err) {
+            if (err instanceof this.relatedModelClass.ModifierNotFoundError) {
+                throw this.createError(err.message);
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    join(builder, { joinOperation = 'join', relatedTableAlias = builder.tableRefFor(this.relatedModelClass), relatedJoinSelectQuery = this.relatedModelClass.query().childQueryOf(builder), relatedTable = builder.tableNameFor(this.relatedModelClass), ownerTable = builder.tableRefFor(this.ownerModelClass), } = {}) {
+        let relatedJoinSelect = this.applyModify(relatedJoinSelectQuery).as(relatedTableAlias);
+        if (relatedJoinSelect.isSelectAll()) {
+            // No need to join a subquery if the query is `select * from "RelatedTable"`.
+            relatedJoinSelect = aliasedTableName(relatedTable, relatedTableAlias);
+        }
+        return builder[joinOperation](relatedJoinSelect, (join) => {
+            const relatedProp = this.relatedProp;
+            const ownerProp = this.ownerProp;
+            relatedProp.forEach((i) => {
+                const relatedRef = relatedProp.ref(builder, i).table(relatedTableAlias);
+                const ownerRef = ownerProp.ref(builder, i).table(ownerTable);
+                join.on(relatedRef, ownerRef);
+            });
+        });
+    }
+    find(_, owner) {
+        return new RelationFindOperation('find', {
+            relation: this,
+            owner,
+        });
+    }
+    insert(_, owner) {
+        /* istanbul ignore next */
+        throw this.createError('not implemented');
+    }
+    update(_, owner) {
+        return new RelationUpdateOperation('update', {
+            relation: this,
+            owner,
+        });
+    }
+    patch(_, owner) {
+        return new RelationUpdateOperation('patch', {
+            relation: this,
+            owner,
+            modelOptions: { patch: true },
+        });
+    }
+    delete(_, owner) {
+        return new RelationDeleteOperation('delete', {
+            relation: this,
+            owner,
+        });
+    }
+    relate() {
+        /* istanbul ignore next */
+        throw this.createError('not implemented');
+    }
+    unrelate() {
+        /* istanbul ignore next */
+        throw this.createError('not implemented');
+    }
+    hasRelateProp(model) {
+        return model.$hasProps(this.relatedProp.props);
+    }
+    setRelateProp(model, values) {
+        this.relatedProp.forEach((i) => {
+            this.relatedProp.setProp(model, i, values[i]);
+        });
+    }
+    executeBeforeInsert(models, queryContext, result) {
+        return mapAfterAllReturn(models, (model) => this.beforeInsert(model, queryContext), result);
+    }
+    createError(message) {
+        if (this.ownerModelClass && this.ownerModelClass.name && this.name) {
+            return new Error(`${this.ownerModelClass.name}.relationMappings.${this.name}: ${message}`);
+        }
+        else {
+            return new Error(`${this.constructor.name}: ${message}`);
+        }
+    }
+}
+Object.defineProperties(Relation, {
+    isObjectionRelationClass: {
+        enumerable: false,
+        writable: false,
+        value: true,
+    },
+});
+Object.defineProperties(Relation.prototype, {
+    isObjectionRelation: {
+        enumerable: false,
+        writable: false,
+        value: true,
+    },
+});
+function checkForbiddenProperties(ctx) {
+    ctx.forbiddenMappingProperties.forEach((prop) => {
+        if (get(ctx.mapping, prop.split('.')) !== undefined) {
+            throw ctx.createError(`Property ${prop} is not supported for this relation type.`);
+        }
+    });
+    return ctx;
+}
+function checkOwnerModelClass(ctx) {
+    if (!isFunction(ctx.ownerModelClass) || !ctx.ownerModelClass.isObjectionModelClass) {
+        throw ctx.createError(`Relation's owner is not a subclass of Model`);
+    }
+    return ctx;
+}
+function checkRelatedModelClass(ctx) {
+    if (!ctx.mapping.modelClass) {
+        throw ctx.createError('modelClass is not defined');
+    }
+    return ctx;
+}
+function resolveRelatedModelClass(ctx) {
+    let relatedModelClass;
+    try {
+        relatedModelClass = resolveModel(ctx.mapping.modelClass, ctx.ownerModelClass.modelPaths, 'modelClass');
+    }
+    catch (err) {
+        throw ctx.createError(err.message);
+    }
+    return Object.assign(ctx, { relatedModelClass });
+}
+function checkRelation(ctx) {
+    if (!ctx.mapping.relation) {
+        throw ctx.createError('relation is not defined');
+    }
+    if (!isFunction(ctx.mapping.relation) || !ctx.mapping.relation.isObjectionRelationClass) {
+        throw ctx.createError('relation is not a subclass of Relation');
+    }
+    return ctx;
+}
+function createJoinProperties(ctx) {
+    const mapping = ctx.mapping;
+    if (!mapping.join || !mapping.join.from || !mapping.join.to) {
+        throw ctx.createError('join must be an object that maps the columns of the related models together. For example: {from: "SomeTable.id", to: "SomeOtherTable.someModelId"}');
+    }
+    const fromProp = createRelationProperty(ctx, mapping.join.from, 'join.from');
+    const toProp = createRelationProperty(ctx, mapping.join.to, 'join.to');
+    let ownerProp;
+    let relatedProp;
+    if (fromProp.modelClass.getTableName() === ctx.ownerModelClass.getTableName()) {
+        ownerProp = fromProp;
+        relatedProp = toProp;
+    }
+    else if (toProp.modelClass.getTableName() === ctx.ownerModelClass.getTableName()) {
+        ownerProp = toProp;
+        relatedProp = fromProp;
+    }
+    else {
+        throw ctx.createError('join: either `from` or `to` must point to the owner model table.');
+    }
+    if (ownerProp.props.some((it) => it === ctx.name)) {
+        throw ctx.createError(`join: relation name and join property '${ctx.name}' cannot have the same name. If you cannot change one or the other, you can use $parseDatabaseJson and $formatDatabaseJson methods to convert the column name.`);
+    }
+    if (relatedProp.modelClass.getTableName() !== ctx.relatedModelClass.getTableName()) {
+        throw ctx.createError('join: either `from` or `to` must point to the related model table.');
+    }
+    return Object.assign(ctx, { ownerProp, relatedProp });
+}
+function createRelationProperty(ctx, refString, propName) {
+    try {
+        return new RelationProperty(refString, (table) => {
+            return [ctx.ownerModelClass, ctx.relatedModelClass].find((it) => it.getTableName() === table);
+        });
+    }
+    catch (err) {
+        if (err instanceof RelationProperty.ModelNotFoundError) {
+            throw ctx.createError(`join: either \`from\` or \`to\` must point to the owner model table and the other one to the related table. It might be that specified table '${err.tableName}' is not correct`);
+        }
+        else if (err instanceof RelationProperty.InvalidReferenceError) {
+            throw ctx.createError(`${propName} must have format TableName.columnName. For example "SomeTable.id" or in case of composite key ["SomeTable.a", "SomeTable.b"].`);
+        }
+        else {
+            throw err;
+        }
+    }
+}
+function parseModify(ctx) {
+    const mapping = ctx.mapping;
+    const modifier = mapping.modify || mapping.filter;
+    const modify = modifier &&
+        createModifier({
+            modifier,
+            modelClass: ctx.relatedModelClass,
+        });
+    return Object.assign(ctx, { modify });
+}
+function parseBeforeInsert(ctx) {
+    let beforeInsert;
+    if (isFunction(ctx.mapping.beforeInsert)) {
+        beforeInsert = ctx.mapping.beforeInsert;
+    }
+    else {
+        beforeInsert = (model) => model;
+    }
+    return Object.assign(ctx, { beforeInsert });
+}
+function aliasedTableName(tableName, alias) {
+    if (tableName === alias) {
+        return tableName;
+    }
+    else {
+        return `${tableName} as ${alias}`;
+    }
+}
+module.exports = {
+    Relation,
+};

package/lib/relations/RelationDeleteOperation.js

@@ -0,0 +1,23 @@
+'use strict';
+const { DeleteOperation } = require('../queryBuilder/operations/DeleteOperation');
+const { RelationFindOperation } = require('./RelationFindOperation');
+class RelationDeleteOperation extends DeleteOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        this.relation = opt.relation;
+        this.owner = opt.owner;
+    }
+    onBuild(builder) {
+        super.onBuild(builder);
+        this.relation.findQuery(builder, this.owner);
+    }
+    toFindOperation() {
+        return new RelationFindOperation('find', {
+            relation: this.relation,
+            owner: this.owner,
+        });
+    }
+}
+module.exports = {
+    RelationDeleteOperation,
+};