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

package/lib/queryBuilder/operations/InstanceUpdateOperation.js

@@ -0,0 +1,45 @@
+'use strict';
+const { withWhereScope } = require('../whereScopes');
+const { UpdateOperation } = require('./UpdateOperation');
+const { InstanceFindOperation } = require('./InstanceFindOperation');
+const { assertHasId } = require('../../utils/assert');
+const { isObject } = require('../../utils/objectUtils');
+class InstanceUpdateOperation extends UpdateOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        this.instance = opt.instance;
+        this.modelOptions.old = opt.instance;
+    }
+    onAdd(builder, args) {
+        const retVal = super.onAdd(builder, args);
+        if (!this.model) {
+            this.model = this.instance;
+        }
+        return retVal;
+    }
+    onBuild(builder) {
+        super.onBuild(builder);
+        assertHasId(this.instance);
+        withWhereScope(builder, () => builder.findById(this.instance.$id()));
+    }
+    async onAfter2(builder, result) {
+        // The result may be an object if `returning` was used.
+        if (Array.isArray(result)) {
+            result = result[0];
+        }
+        result = await super.onAfter2(builder, result);
+        this.instance.$set(this.model);
+        if (isObject(result)) {
+            this.instance.$set(result);
+        }
+        return result;
+    }
+    toFindOperation() {
+        return new InstanceFindOperation('find', {
+            instance: this.instance,
+        });
+    }
+}
+module.exports = {
+    InstanceUpdateOperation,
+};

package/lib/queryBuilder/operations/JoinRelatedOperation.js

@@ -0,0 +1,83 @@
+'use strict';
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+const { RelationExpression } = require('../RelationExpression');
+const { RelationJoiner } = require('../join/RelationJoiner');
+const { isString } = require('../../utils/objectUtils');
+class JoinRelatedOperation extends QueryBuilderOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        this.calls = [];
+    }
+    get joinOperation() {
+        return this.opt.joinOperation;
+    }
+    addCall(call) {
+        this.calls.push(call);
+    }
+    onBuild(builder) {
+        const modelClass = builder.modelClass();
+        const joinOperation = this.joinOperation;
+        let mergedExpr = RelationExpression.create();
+        for (const call of this.calls) {
+            const expr = RelationExpression.create(call.expression).toPojo();
+            const childNames = expr.$childNames;
+            const options = call.options || {};
+            if (childNames.length === 1) {
+                applyAlias(expr, modelClass, builder, options);
+            }
+            if (options.aliases) {
+                applyAliases(expr, modelClass, options);
+            }
+            mergedExpr = mergedExpr.merge(expr);
+        }
+        const joiner = new RelationJoiner({
+            modelClass,
+        });
+        joiner.setOptions({ joinOperation });
+        joiner.setExpression(mergedExpr);
+        joiner.setModifiers(builder.modifiers());
+        joiner.build(builder, false);
+    }
+    clone() {
+        const clone = super.clone();
+        clone.calls = this.calls.slice();
+        return clone;
+    }
+}
+function applyAlias(expr, modelClass, builder, options) {
+    const childNames = expr.$childNames;
+    const childName = childNames[0];
+    const childExpr = expr[childName];
+    const relation = modelClass.getRelation(childExpr.$relation);
+    let alias = childName;
+    if (options.alias === false) {
+        alias = builder.tableRefFor(relation.relatedModelClass);
+    }
+    else if (isString(options.alias)) {
+        alias = options.alias;
+    }
+    if (childName !== alias) {
+        renameRelationExpressionNode(expr, childName, alias);
+    }
+}
+function applyAliases(expr, modelClass, options) {
+    for (const childName of expr.$childNames) {
+        const childExpr = expr[childName];
+        const relation = modelClass.getRelation(childExpr.$relation);
+        const alias = options.aliases[childExpr.$relation];
+        if (alias && alias !== childName) {
+            renameRelationExpressionNode(expr, childName, alias);
+        }
+        applyAliases(childExpr, relation.relatedModelClass, options);
+    }
+}
+function renameRelationExpressionNode(expr, oldName, newName) {
+    const childExpr = expr[oldName];
+    delete expr[oldName];
+    expr[newName] = childExpr;
+    childExpr.$name = newName;
+    expr.$childNames = expr.$childNames.map((it) => (it === oldName ? newName : it));
+}
+module.exports = {
+    JoinRelatedOperation,
+};

package/lib/queryBuilder/operations/KnexOperation.js

@@ -0,0 +1,11 @@
+'use strict';
+const { ObjectionToKnexConvertingOperation } = require('./ObjectionToKnexConvertingOperation');
+// An operation that simply calls the equivalent knex method.
+class KnexOperation extends ObjectionToKnexConvertingOperation {
+    onBuildKnex(knexBuilder, builder) {
+        return knexBuilder[this.name].apply(knexBuilder, this.getKnexArgs(builder));
+    }
+}
+module.exports = {
+    KnexOperation,
+};

package/lib/queryBuilder/operations/MergeOperation.js

@@ -0,0 +1,43 @@
+'use strict';
+const { isFunction, isEmpty, isObject } = require('../../utils/objectUtils');
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+const { convertFieldExpressionsToRaw } = require('./UpdateOperation');
+class MergeOperation extends QueryBuilderOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        this.model = null;
+        this.args = null;
+    }
+    onAdd(builder, args) {
+        this.args = args;
+        if (!isEmpty(args) && isObject(args[0]) && !Array.isArray(args[0])) {
+            const json = args[0];
+            const modelClass = builder.modelClass();
+            this.model = modelClass.ensureModel(json, { patch: true });
+        }
+        return true;
+    }
+    onBuildKnex(knexBuilder, builder) {
+        if (!isFunction(knexBuilder.merge)) {
+            throw new Error('merge method can only be chained right after onConflict method');
+        }
+        if (this.model) {
+            const json = this.model.$toDatabaseJson(builder);
+            const convertedJson = convertFieldExpressionsToRaw(builder, this.model, json);
+            return knexBuilder.merge(convertedJson);
+        }
+        return knexBuilder.merge(...this.args);
+    }
+    toFindOperation() {
+        return null;
+    }
+    clone() {
+        const clone = super.clone();
+        clone.model = this.model;
+        clone.args = this.args;
+        return clone;
+    }
+}
+module.exports = {
+    MergeOperation,
+};

package/lib/queryBuilder/operations/ObjectionToKnexConvertingOperation.js

@@ -0,0 +1,173 @@
+'use strict';
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+const { isPlainObject, isObject, isFunction, once } = require('../../utils/objectUtils');
+const { isKnexQueryBuilder, isKnexJoinBuilder } = require('../../utils/knexUtils');
+const { transformation } = require('../transformations');
+const { isModelClass } = require('../../utils/resolveModel');
+const getJoinBuilder = once(() => require('../JoinBuilder').JoinBuilder);
+// An abstract operation base class that converts all arguments from objection types
+// to knex types. For example objection query builders are converted into knex query
+// builders and objection RawBuilder instances are converted into knex Raw instances.
+class ObjectionToKnexConvertingOperation extends QueryBuilderOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        this.args = null;
+    }
+    getKnexArgs(builder) {
+        return convertArgs(this.name, builder, this.args);
+    }
+    onAdd(builder, args) {
+        this.args = Array.from(args);
+        return shouldBeAdded(this.name, builder, this.args);
+    }
+    clone() {
+        const clone = super.clone();
+        clone.args = this.args;
+        return clone;
+    }
+}
+function shouldBeAdded(opName, builder, args) {
+    const skipUndefined = builder.internalOptions().skipUndefined;
+    for (let i = 0, l = args.length; i < l; ++i) {
+        const arg = args[i];
+        if (isUndefined(arg)) {
+            if (skipUndefined) {
+                return false;
+            }
+            else {
+                throw new Error(`undefined passed as argument #${i} for '${opName}' operation. Call skipUndefined() method to ignore the undefined values.`);
+            }
+        }
+    }
+    return true;
+}
+function convertArgs(opName, builder, args) {
+    const skipUndefined = builder.internalOptions().skipUndefined;
+    return args.map((arg, i) => {
+        if (hasToKnexRawMethod(arg)) {
+            return convertToKnexRaw(arg, builder);
+        }
+        else if (isObjectionQueryBuilderBase(arg)) {
+            return convertQueryBuilderBase(arg, builder);
+        }
+        else if (isArray(arg)) {
+            return convertArray(arg, builder, i, opName, skipUndefined);
+        }
+        else if (isModelClass(arg)) {
+            // Model classes can be used in place of their table names, for example
+            // `join(Pet, ...)`. They are functions, so this check must come first.
+            return arg.getTableName();
+        }
+        else if (isFunction(arg)) {
+            return convertFunction(arg, builder);
+        }
+        else if (isModel(arg)) {
+            return convertModel(arg);
+        }
+        else if (isPlainObject(arg)) {
+            return convertPlainObject(arg, builder, i, opName, skipUndefined);
+        }
+        else {
+            return arg;
+        }
+    });
+}
+function isUndefined(item) {
+    return item === undefined;
+}
+function hasToKnexRawMethod(item) {
+    return isObject(item) && isFunction(item.toKnexRaw);
+}
+function convertToKnexRaw(item, builder) {
+    return item.toKnexRaw(builder);
+}
+function isObjectionQueryBuilderBase(item) {
+    return isObject(item) && item.isObjectionQueryBuilderBase === true;
+}
+function convertQueryBuilderBase(item, builder) {
+    item = transformation.onConvertQueryBuilderBase(item, builder);
+    return item.subqueryOf(builder).toKnexQuery();
+}
+function isArray(item) {
+    return Array.isArray(item);
+}
+function convertArray(arr, builder, i, opName, skipUndefined) {
+    return arr.map((item) => {
+        if (item === undefined) {
+            if (!skipUndefined) {
+                throw new Error(`undefined passed as an item in argument #${i} for '${opName}' operation. Call skipUndefined() method to ignore the undefined values.`);
+            }
+        }
+        else if (hasToKnexRawMethod(item)) {
+            return convertToKnexRaw(item, builder);
+        }
+        else if (isObjectionQueryBuilderBase(item)) {
+            return convertQueryBuilderBase(item, builder);
+        }
+        else if (isModelClass(item)) {
+            return item.getTableName();
+        }
+        else {
+            return item;
+        }
+    });
+}
+function convertFunction(func, builder) {
+    return function convertedKnexArgumentFunction(...args) {
+        if (isKnexQueryBuilder(this)) {
+            convertQueryBuilderFunction(this, func, builder);
+        }
+        else if (isKnexJoinBuilder(this)) {
+            convertJoinBuilderFunction(this, func, builder);
+        }
+        else {
+            return func.apply(this, args);
+        }
+    };
+}
+function convertQueryBuilderFunction(knexQueryBuilder, func, builder) {
+    const convertedQueryBuilder = builder.constructor.forClass(builder.modelClass());
+    convertedQueryBuilder.isPartial(true).subqueryOf(builder);
+    func.call(convertedQueryBuilder, convertedQueryBuilder);
+    convertedQueryBuilder.toKnexQuery(knexQueryBuilder);
+}
+function convertJoinBuilderFunction(knexJoinBuilder, func, builder) {
+    const JoinBuilder = getJoinBuilder();
+    const joinClauseBuilder = JoinBuilder.forClass(builder.modelClass());
+    joinClauseBuilder.isPartial(true).subqueryOf(builder);
+    func.call(joinClauseBuilder, joinClauseBuilder);
+    joinClauseBuilder.toKnexQuery(knexJoinBuilder);
+}
+function isModel(item) {
+    return isObject(item) && item.$isObjectionModel;
+}
+function convertModel(model) {
+    return model.$toDatabaseJson();
+}
+function convertPlainObject(obj, builder, i, opName, skipUndefined) {
+    return Object.keys(obj).reduce((out, key) => {
+        const item = obj[key];
+        if (item === undefined) {
+            if (!skipUndefined) {
+                throw new Error(`undefined passed as a property in argument #${i} for '${opName}' operation. Call skipUndefined() method to ignore the undefined values.`);
+            }
+        }
+        else if (hasToKnexRawMethod(item)) {
+            out[key] = convertToKnexRaw(item, builder);
+        }
+        else if (isObjectionQueryBuilderBase(item)) {
+            out[key] = convertQueryBuilderBase(item, builder);
+        }
+        else if (isModelClass(item)) {
+            // `{ alias: ModelClass }`.
+            out[key] = item.getTableName();
+        }
+        else {
+            out[key] = item;
+        }
+        return out;
+    }, {});
+}
+module.exports = {
+    ObjectionToKnexConvertingOperation,
+};

package/lib/queryBuilder/operations/OnBuildKnexOperation.js

@@ -0,0 +1,23 @@
+'use strict';
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+class OnBuildKnexOperation extends QueryBuilderOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        this.func = null;
+    }
+    onAdd(_, args) {
+        this.func = args[0];
+        return true;
+    }
+    onBuildKnex(knexBuilder, builder) {
+        return this.func.call(knexBuilder, knexBuilder, builder);
+    }
+    clone() {
+        const clone = super.clone();
+        clone.func = this.func;
+        return clone;
+    }
+}
+module.exports = {
+    OnBuildKnexOperation,
+};

package/lib/queryBuilder/operations/OnBuildOperation.js

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

package/lib/queryBuilder/operations/OnErrorOperation.js

@@ -0,0 +1,23 @@
+'use strict';
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+class OnErrorOperation extends QueryBuilderOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        this.func = null;
+    }
+    onAdd(_, args) {
+        this.func = args[0];
+        return true;
+    }
+    onError(builder, error) {
+        return this.func.call(builder, error, builder);
+    }
+    clone() {
+        const clone = super.clone();
+        clone.func = this.func;
+        return clone;
+    }
+}
+module.exports = {
+    OnErrorOperation,
+};

package/lib/queryBuilder/operations/QueryBuilderOperation.js

@@ -0,0 +1,258 @@
+'use strict';
+const hookNameToHasMethodName = {
+    onAdd: 'hasOnAdd',
+    onBefore1: 'hasOnBefore1',
+    onBefore2: 'hasOnBefore2',
+    onBefore3: 'hasOnBefore3',
+    onBuild: 'hasOnBuild',
+    onBuildKnex: 'hasOnBuildKnex',
+    onRawResult: 'hasOnRawResult',
+    queryExecutor: 'hasQueryExecutor',
+    onAfter1: 'hasOnAfter1',
+    onAfter2: 'hasOnAfter2',
+    onAfter3: 'hasOnAfter3',
+    onError: 'hasOnError',
+};
+// An abstract base class for all query builder operations. QueryBuilderOperations almost always
+// correspond to a single query builder method call. For example SelectOperation could be added when
+// a `select` method is called.
+//
+// QueryBuilderOperation is just a bunch of query execution lifecycle hooks that subclasses
+// can (but don't have to) implement.
+//
+// Basically a query builder is nothing but an array of QueryBuilderOperations. When the query is
+// executed the hooks are called in the order explained below. The hooks are called so that a
+// certain hook is called for _all_ operations before the next hook is called. For example if
+// a builder has 5 operations, onBefore1 hook is called for each of them (and their results are awaited)
+// before onBefore2 hook is called for any of the operations.
+class QueryBuilderOperation {
+    constructor(name = null, opt = {}) {
+        this.name = name;
+        this.opt = opt;
+        // From which hook was this operation added as a child
+        // operation.
+        this.adderHookName = null;
+        // The parent operation that added this operation.
+        this.parentOperation = null;
+        // Operations this operation added in any of its hooks.
+        this.childOperations = [];
+        // The where scope (see `whereScopes.js`) this operation was added in.
+        this.whereScope = null;
+    }
+    is(OperationClass) {
+        return this instanceof OperationClass;
+    }
+    hasHook(hookName) {
+        return this[hookNameToHasMethodName[hookName]]();
+    }
+    // This is called immediately when a query builder method is called.
+    //
+    // This method must be synchronous.
+    // This method should never call any methods that add operations to the builder.
+    onAdd(builder, args) {
+        return true;
+    }
+    hasOnAdd() {
+        return true;
+    }
+    // This is called as the first thing when the query is executed but before
+    // the actual database operation (knex query) is executed.
+    //
+    // This method can be asynchronous.
+    // You may call methods that add operations to to the builder.
+    onBefore1(builder, result) { }
+    hasOnBefore1() {
+        return this.onBefore1 !== QueryBuilderOperation.prototype.onBefore1;
+    }
+    // This is called as the second thing when the query is executed but before
+    // the actual database operation (knex query) is executed.
+    //
+    // This method can be asynchronous.
+    // You may call methods that add operations to to the builder.
+    onBefore2(builder, result) { }
+    hasOnBefore2() {
+        return this.onBefore2 !== QueryBuilderOperation.prototype.onBefore2;
+    }
+    // This is called as the third thing when the query is executed but before
+    // the actual database operation (knex query) is executed.
+    //
+    // This method can be asynchronous.
+    // You may call methods that add operations to to the builder.
+    onBefore3(builder, result) { }
+    hasOnBefore3() {
+        return this.onBefore3 !== QueryBuilderOperation.prototype.onBefore3;
+    }
+    // This is called as the last thing when the query is executed but before
+    // the actual database operation (knex query) is executed. If your operation
+    // needs to call other query building operations (methods that add QueryBuilderOperations)
+    // this is the best and last place to do it.
+    //
+    // This method must be synchronous.
+    // You may call methods that add operations to to the builder.
+    onBuild(builder) { }
+    hasOnBuild() {
+        return this.onBuild !== QueryBuilderOperation.prototype.onBuild;
+    }
+    // This is called when the knex query is built. Here you should only call knex
+    // methods. You may call getters and other immutable methods of the `builder`
+    // but you should never call methods that add QueryBuilderOperations.
+    //
+    // This method must be synchronous.
+    // This method should never call any methods that add operations to the builder.
+    // This method should always return the knex query builder.
+    onBuildKnex(knexBuilder, builder) {
+        return knexBuilder;
+    }
+    hasOnBuildKnex() {
+        return this.onBuildKnex !== QueryBuilderOperation.prototype.onBuildKnex;
+    }
+    // The raw knex result is passed to this method right after the database query
+    // has finished. This method may modify it and return the modified rows. The
+    // rows are automatically converted to models (if possible) after this hook
+    // is called.
+    //
+    // This method can be asynchronous.
+    onRawResult(builder, rows) {
+        return rows;
+    }
+    hasOnRawResult() {
+        return this.onRawResult !== QueryBuilderOperation.prototype.onRawResult;
+    }
+    // This is called as the first thing after the query has been executed and
+    // rows have been converted to model instances.
+    //
+    // This method can be asynchronous.
+    onAfter1(builder, result) {
+        return result;
+    }
+    hasOnAfter1() {
+        return this.onAfter1 !== QueryBuilderOperation.prototype.onAfter1;
+    }
+    // This is called as the second thing after the query has been executed and
+    // rows have been converted to model instances.
+    //
+    // This method can be asynchronous.
+    onAfter2(builder, result) {
+        return result;
+    }
+    hasOnAfter2() {
+        return this.onAfter2 !== QueryBuilderOperation.prototype.onAfter2;
+    }
+    // This is called as the third thing after the query has been executed and
+    // rows have been converted to model instances.
+    //
+    // This method can be asynchronous.
+    onAfter3(builder, result) {
+        return result;
+    }
+    hasOnAfter3() {
+        return this.onAfter3 !== QueryBuilderOperation.prototype.onAfter3;
+    }
+    // This method can be implemented to return another operation that will replace
+    // this one. This method is called after all `onBeforeX` and `onBuildX` hooks
+    // but before the database query is executed.
+    //
+    // This method must return a QueryBuilder instance.
+    queryExecutor(builder) { }
+    hasQueryExecutor() {
+        return this.queryExecutor !== QueryBuilderOperation.prototype.queryExecutor;
+    }
+    // This is called if an error occurs in the query execution.
+    //
+    // This method must return a QueryBuilder instance.
+    onError(builder, error) { }
+    hasOnError() {
+        return this.onError !== QueryBuilderOperation.prototype.onError;
+    }
+    // Returns the "find" equivalent of this operation.
+    //
+    // For example an operation that finds an item and updates it
+    // should return an operation that simply finds the item but
+    // doesn't update anything. An insert operation should return
+    // null since there is no find equivalent for it etc.
+    toFindOperation(builder) {
+        return this;
+    }
+    hasToFindOperation() {
+        return this.toFindOperation !== QueryBuilderOperation.prototype.toFindOperation;
+    }
+    // Given a set of operations, returns true if any of this operation's
+    // ancestor operations are included in the set.
+    isAncestorInSet(operationSet) {
+        let ancestor = this.parentOperation;
+        while (ancestor) {
+            if (operationSet.has(ancestor)) {
+                return true;
+            }
+            ancestor = ancestor.parentOperation;
+        }
+        return false;
+    }
+    // Takes a deep clone of this operation.
+    clone() {
+        const clone = new this.constructor(this.name, this.opt);
+        clone.adderHookName = this.adderHookName;
+        clone.parentOperation = this.parentOperation;
+        clone.whereScope = this.whereScope;
+        clone.childOperations = this.childOperations.map((childOp) => {
+            const childOpClone = childOp.clone();
+            childOpClone.parentOperation = clone;
+            return childOpClone;
+        });
+        return clone;
+    }
+    // Add an operation as a child operation. `hookName` must be the
+    // name of the parent operation's hook that called this method.
+    addChildOperation(hookName, operation) {
+        operation.adderHookName = hookName;
+        operation.parentOperation = this;
+        this.childOperations.push(operation);
+    }
+    // Removes a single child operation.
+    removeChildOperation(operation) {
+        const index = this.childOperations.indexOf(operation);
+        if (index !== -1) {
+            operation.parentOperation = null;
+            this.childOperations.splice(index, 1);
+        }
+    }
+    // Replaces a single child operation.
+    replaceChildOperation(operation, newOperation) {
+        const index = this.childOperations.indexOf(operation);
+        if (index !== -1) {
+            newOperation.adderHookName = operation.adderHookName;
+            newOperation.parentOperation = this;
+            operation.parentOperation = null;
+            this.childOperations[index] = newOperation;
+        }
+    }
+    // Removes all child operations that were added from the `hookName` hook.
+    removeChildOperationsByHookName(hookName) {
+        // Called before every hook. Most operations have no children.
+        if (this.childOperations.length !== 0) {
+            this.childOperations = this.childOperations.filter((op) => op.adderHookName !== hookName);
+        }
+    }
+    // Iterates through all descendant operations recursively.
+    forEachDescendantOperation(callback) {
+        for (const operation of this.childOperations) {
+            if (callback(operation) === false) {
+                return false;
+            }
+            if (operation.forEachDescendantOperation(callback) === false) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+Object.defineProperties(QueryBuilderOperation, {
+    isObjectionQueryBuilderOperationClass: {
+        enumerable: false,
+        writable: false,
+        value: true,
+    },
+});
+module.exports = {
+    QueryBuilderOperation,
+};