@abedmurrar/objection 4.0.0-alpha.0 → 4.0.0-beta.1

package/lib/queryBuilder/QueryBuilderOperationSupport.js

@@ -1,558 +1,484 @@
 'use strict';
-
 const { isString, isFunction, isRegExp, mergeMaps, last } = require('../utils/objectUtils');
 const { QueryBuilderContextBase } = require('./QueryBuilderContextBase');
 const { QueryBuilderUserContext } = require('./QueryBuilderUserContext');
 const { deprecate } = require('../utils/deprecate');
 const { effectiveWhereScope, createWhereGrouping } = require('./whereScopes');
-
 const AllSelector = () => true;
-const SelectSelector =
-  /^(select|columns|column|distinct|count|countDistinct|min|max|sum|sumDistinct|avg|avgDistinct)$/;
+const SelectSelector = /^(select|columns|column|distinct|count|countDistinct|min|max|sum|sumDistinct|avg|avgDistinct)$/;
 const WhereSelector = /^(where|orWhere|andWhere|find\w+)/;
 const OnSelector = /^(on|orOn|andOn)/;
 const OrderBySelector = /orderBy/;
 const JoinSelector = /(join|joinRaw|joinRelated)$/i;
 const FromSelector = /^(from|fromRaw|into|table)$/;
-
 class QueryBuilderOperationSupport {
-  constructor(...args) {
-    this.constructor.init(this, ...args);
-  }
-
-  static init(self, modelClass) {
-    self._modelClass = modelClass;
-    self._operations = [];
-    self._context = new this.QueryBuilderContext(self);
-    self._parentQuery = null;
-    self._isPartialQuery = false;
-    self._activeOperations = [];
-    self._whereScope = null;
-  }
-
-  static forClass(modelClass) {
-    return new this(modelClass);
-  }
-
-  static get AllSelector() {
-    return AllSelector;
-  }
-
-  static get QueryBuilderContext() {
-    return QueryBuilderContextBase;
-  }
-
-  static get QueryBuilderUserContext() {
-    return QueryBuilderUserContext;
-  }
-
-  static get SelectSelector() {
-    return SelectSelector;
-  }
-
-  static get WhereSelector() {
-    return WhereSelector;
-  }
-
-  static get OnSelector() {
-    return OnSelector;
-  }
-
-  static get JoinSelector() {
-    return JoinSelector;
-  }
-
-  static get FromSelector() {
-    return FromSelector;
-  }
-
-  static get OrderBySelector() {
-    return OrderBySelector;
-  }
-
-  modelClass() {
-    return this._modelClass;
-  }
-
-  context(obj) {
-    const ctx = this._context;
-
-    if (arguments.length === 0) {
-      return ctx.userContext;
-    } else {
-      ctx.userContext = ctx.userContext.newMerge(this, obj);
-      return this;
-    }
-  }
-
-  clearContext() {
-    const ctx = this._context;
-    ctx.userContext = new this.constructor.QueryBuilderUserContext(this);
-    return this;
-  }
-
-  internalContext(ctx) {
-    if (arguments.length === 0) {
-      return this._context;
-    } else {
-      this._context = ctx;
-      return this;
-    }
-  }
-
-  internalOptions(opt) {
-    if (arguments.length === 0) {
-      return this._context.options;
-    } else {
-      const oldOpt = this._context.options;
-      this._context.options = Object.assign(oldOpt, opt);
-      return this;
-    }
-  }
-
-  isPartial(isPartial) {
-    if (arguments.length === 0) {
-      return this._isPartialQuery;
-    } else {
-      this._isPartialQuery = isPartial;
-      return this;
-    }
-  }
-
-  isInternal() {
-    return this.internalOptions().isInternalQuery;
-  }
-
-  tableNameFor(modelClassOrTableName, newTableName) {
-    const tableName = getTableName(modelClassOrTableName);
-    const ctx = this.internalContext();
-    const tableMap = ctx.tableMap;
-
-    if (isString(newTableName)) {
-      ctx.tableMap = tableMap || new Map();
-      ctx.tableMap.set(tableName, newTableName);
-      return this;
-    } else {
-      return (tableMap && tableMap.get(tableName)) || tableName;
-    }
-  }
-
-  aliasFor(modelClassOrTableName, alias) {
-    const tableName = getTableName(modelClassOrTableName);
-    const ctx = this.internalContext();
-    const aliasMap = ctx.aliasMap;
-
-    if (isString(alias)) {
-      ctx.aliasMap = aliasMap || new Map();
-      ctx.aliasMap.set(tableName, alias);
-      return this;
-    } else {
-      return (aliasMap && aliasMap.get(tableName)) || null;
-    }
-  }
-
-  tableRefFor(modelClassOrTableName) {
-    return this.aliasFor(modelClassOrTableName) || this.tableNameFor(modelClassOrTableName);
-  }
-
-  childQueryOf(query, { fork, isInternalQuery } = {}) {
-    if (query) {
-      let currentCtx = this.context();
-      let ctx = query.internalContext();
-
-      if (fork) {
-        ctx = ctx.clone();
-      }
-
-      if (isInternalQuery) {
-        ctx.options.isInternalQuery = true;
-      }
-
-      this._parentQuery = query;
-      this.internalContext(ctx);
-      this.context(currentCtx);
-
-      // Use the parent's knex if there was no knex in `ctx`.
-      if (this.unsafeKnex() === null) {
-        this.knex(query.unsafeKnex());
-      }
-    }
-
-    return this;
-  }
-
-  subqueryOf(query) {
-    if (query) {
-      if (this._isPartialQuery) {
-        // Merge alias and table name maps for "partial" subqueries.
+    constructor(...args) {
+        this.constructor.init(this, ...args);
+    }
+    static init(self, modelClass) {
+        self._modelClass = modelClass;
+        self._operations = [];
+        self._context = new this.QueryBuilderContext(self);
+        self._parentQuery = null;
+        self._isPartialQuery = false;
+        self._activeOperations = [];
+        self._whereScope = null;
+    }
+    static forClass(modelClass) {
+        return new this(modelClass);
+    }
+    static get AllSelector() {
+        return AllSelector;
+    }
+    static get QueryBuilderContext() {
+        return QueryBuilderContextBase;
+    }
+    static get QueryBuilderUserContext() {
+        return QueryBuilderUserContext;
+    }
+    static get SelectSelector() {
+        return SelectSelector;
+    }
+    static get WhereSelector() {
+        return WhereSelector;
+    }
+    static get OnSelector() {
+        return OnSelector;
+    }
+    static get JoinSelector() {
+        return JoinSelector;
+    }
+    static get FromSelector() {
+        return FromSelector;
+    }
+    static get OrderBySelector() {
+        return OrderBySelector;
+    }
+    modelClass() {
+        return this._modelClass;
+    }
+    context(obj) {
+        const ctx = this._context;
+        if (arguments.length === 0) {
+            return ctx.userContext;
+        }
+        else {
+            ctx.userContext = ctx.userContext.newMerge(this, obj);
+            return this;
+        }
+    }
+    clearContext() {
+        const ctx = this._context;
+        ctx.userContext = new this.constructor.QueryBuilderUserContext(this);
+        return this;
+    }
+    internalContext(ctx) {
+        if (arguments.length === 0) {
+            return this._context;
+        }
+        else {
+            this._context = ctx;
+            return this;
+        }
+    }
+    internalOptions(opt) {
+        if (arguments.length === 0) {
+            return this._context.options;
+        }
+        else {
+            const oldOpt = this._context.options;
+            this._context.options = Object.assign(oldOpt, opt);
+            return this;
+        }
+    }
+    isPartial(isPartial) {
+        if (arguments.length === 0) {
+            return this._isPartialQuery;
+        }
+        else {
+            this._isPartialQuery = isPartial;
+            return this;
+        }
+    }
+    isInternal() {
+        return this.internalOptions().isInternalQuery;
+    }
+    tableNameFor(modelClassOrTableName, newTableName) {
+        const tableName = getTableName(modelClassOrTableName);
+        const ctx = this.internalContext();
+        const tableMap = ctx.tableMap;
+        if (isString(newTableName)) {
+            ctx.tableMap = tableMap || new Map();
+            ctx.tableMap.set(tableName, newTableName);
+            return this;
+        }
+        else {
+            return (tableMap && tableMap.get(tableName)) || tableName;
+        }
+    }
+    aliasFor(modelClassOrTableName, alias) {
+        const tableName = getTableName(modelClassOrTableName);
         const ctx = this.internalContext();
-
-        ctx.aliasMap = mergeMaps(query.internalContext().aliasMap, ctx.aliasMap);
-        ctx.tableMap = mergeMaps(query.internalContext().tableMap, ctx.tableMap);
-      }
-
-      this._parentQuery = query;
-
-      if (this.unsafeKnex() === null) {
-        this.knex(query.unsafeKnex());
-      }
-    }
-
-    return this;
-  }
-
-  parentQuery() {
-    return this._parentQuery;
-  }
-
-  knex(...args) {
-    if (args.length === 0) {
-      const knex = this.unsafeKnex();
-
-      if (!knex) {
-        throw new Error(
-          `no database connection available for a query. You need to bind the model class or the query to a knex instance.`,
-        );
-      }
-
-      return knex;
-    } else {
-      this._context.knex = args[0];
-      return this;
-    }
-  }
-
-  unsafeKnex() {
-    return this._context.knex || this._modelClass.knex() || null;
-  }
-
-  clear(operationSelector) {
-    const operationsToRemove = new Set();
-
-    this.forEachOperation(operationSelector, (op) => {
-      // If an ancestor operation has already been removed,
-      // there's no need to remove the children anymore.
-      if (!op.isAncestorInSet(operationsToRemove)) {
-        operationsToRemove.add(op);
-      }
-    });
-
-    for (const op of operationsToRemove) {
-      this.removeOperation(op);
-    }
-
-    return this;
-  }
-
-  toFindQuery() {
-    const findQuery = this.clone();
-    const operationsToReplace = [];
-    const operationsToRemove = [];
-
-    findQuery.forEachOperation(
-      (op) => op.hasToFindOperation(),
-      (op) => {
-        const findOp = op.toFindOperation(findQuery);
-
-        if (!findOp) {
-          operationsToRemove.push(op);
-        } else {
-          operationsToReplace.push({ op, findOp });
+        const aliasMap = ctx.aliasMap;
+        if (isString(alias)) {
+            ctx.aliasMap = aliasMap || new Map();
+            ctx.aliasMap.set(tableName, alias);
+            return this;
+        }
+        else {
+            return (aliasMap && aliasMap.get(tableName)) || null;
+        }
+    }
+    tableRefFor(modelClassOrTableName) {
+        return this.aliasFor(modelClassOrTableName) || this.tableNameFor(modelClassOrTableName);
+    }
+    childQueryOf(query, { fork, isInternalQuery } = {}) {
+        if (query) {
+            const currentCtx = this.context();
+            let ctx = query.internalContext();
+            if (fork) {
+                ctx = ctx.clone();
+            }
+            if (isInternalQuery) {
+                ctx.options.isInternalQuery = true;
+            }
+            this._parentQuery = query;
+            this.internalContext(ctx);
+            this.context(currentCtx);
+            // Use the parent's knex if there was no knex in `ctx`.
+            if (this.unsafeKnex() === null) {
+                this.knex(query.unsafeKnex());
+            }
+        }
+        return this;
+    }
+    subqueryOf(query) {
+        if (query) {
+            if (this._isPartialQuery) {
+                // Merge alias and table name maps for "partial" subqueries.
+                const ctx = this.internalContext();
+                ctx.aliasMap = mergeMaps(query.internalContext().aliasMap, ctx.aliasMap);
+                ctx.tableMap = mergeMaps(query.internalContext().tableMap, ctx.tableMap);
+            }
+            this._parentQuery = query;
+            if (this.unsafeKnex() === null) {
+                this.knex(query.unsafeKnex());
+            }
+        }
+        return this;
+    }
+    parentQuery() {
+        return this._parentQuery;
+    }
+    knex(...args) {
+        if (args.length === 0) {
+            const knex = this.unsafeKnex();
+            if (!knex) {
+                throw new Error(`no database connection available for a query. You need to bind the model class or the query to a knex instance.`);
+            }
+            return knex;
+        }
+        else {
+            this._context.knex = args[0];
+            return this;
+        }
+    }
+    unsafeKnex() {
+        return this._context.knex || this._modelClass.knex() || null;
+    }
+    clear(operationSelector) {
+        const operationsToRemove = new Set();
+        this.forEachOperation(operationSelector, (op) => {
+            // If an ancestor operation has already been removed,
+            // there's no need to remove the children anymore.
+            if (!op.isAncestorInSet(operationsToRemove)) {
+                operationsToRemove.add(op);
+            }
+        });
+        for (const op of operationsToRemove) {
+            this.removeOperation(op);
+        }
+        return this;
+    }
+    toFindQuery() {
+        const findQuery = this.clone();
+        const operationsToReplace = [];
+        const operationsToRemove = [];
+        findQuery.forEachOperation((op) => op.hasToFindOperation(), (op) => {
+            const findOp = op.toFindOperation(findQuery);
+            if (!findOp) {
+                operationsToRemove.push(op);
+            }
+            else {
+                operationsToReplace.push({ op, findOp });
+            }
+        });
+        for (const op of operationsToRemove) {
+            findQuery.removeOperation(op);
         }
-      },
-    );
-
-    for (const op of operationsToRemove) {
-      findQuery.removeOperation(op);
-    }
-
-    for (const { op, findOp } of operationsToReplace) {
-      findQuery.replaceOperation(op, findOp);
-    }
-
-    return findQuery;
-  }
-
-  clearSelect() {
-    return this.clear(SelectSelector);
-  }
-
-  clearWhere() {
-    return this.clear(WhereSelector);
-  }
-
-  clearOrder() {
-    return this.clear(OrderBySelector);
-  }
-
-  copyFrom(queryBuilder, operationSelector) {
-    const operationsToAdd = new Set();
-
-    queryBuilder.forEachOperation(operationSelector, (op) => {
-      // If an ancestor operation has already been added,
-      // there is no need to add
-      if (!op.isAncestorInSet(operationsToAdd)) {
-        operationsToAdd.add(op);
-      }
-    });
-
-    for (const op of operationsToAdd) {
-      const opClone = op.clone();
-
-      // The scope may come from a parent operation that is not copied.
-      opClone.whereScope = effectiveWhereScope(op);
-
-      // We may be moving nested operations to the root. Clear
-      // any links to the parent operations.
-      opClone.parentOperation = null;
-      opClone.adderHookName = null;
-
-      // We don't use `addOperation` here because we don't what to
-      // call `onAdd` or add these operations as child operations.
-      this._operations.push(opClone);
-    }
-
-    return this;
-  }
-
-  has(operationSelector) {
-    return !!this.findOperation(operationSelector);
-  }
-
-  forEachOperation(operationSelector, callback, match = true) {
-    const selector = buildFunctionForOperationSelector(operationSelector);
-
-    for (const op of this._operations) {
-      if (selector(op) === match && callback(op) === false) {
-        break;
-      }
-
-      const childRes = op.forEachDescendantOperation((op) => {
-        if (selector(op) === match && callback(op) === false) {
-          return false;
+        for (const { op, findOp } of operationsToReplace) {
+            findQuery.replaceOperation(op, findOp);
         }
-      });
-
-      if (childRes === false) {
-        break;
-      }
-    }
-
-    return this;
-  }
-
-  findOperation(operationSelector) {
-    let op = null;
-
-    this.forEachOperation(operationSelector, (it) => {
-      op = it;
-      return false;
-    });
-
-    return op;
-  }
-
-  findLastOperation(operationSelector) {
-    let op = null;
-
-    this.forEachOperation(operationSelector, (it) => {
-      op = it;
-    });
-
-    return op;
-  }
-
-  everyOperation(operationSelector) {
-    let every = true;
-
-    this.forEachOperation(
-      operationSelector,
-      () => {
-        every = false;
-        return false;
-      },
-      false,
-    );
-
-    return every;
-  }
-
-  callOperationMethod(operation, hookName, args) {
-    try {
-      operation.removeChildOperationsByHookName(hookName);
-
-      this._activeOperations.push({
-        operation,
-        hookName,
-      });
-
-      return operation[hookName](...args);
-    } finally {
-      this._activeOperations.pop();
-    }
-  }
-
-  async callAsyncOperationMethod(operation, hookName, args) {
-    operation.removeChildOperationsByHookName(hookName);
-
-    this._activeOperations.push({
-      operation,
-      hookName,
-    });
-
-    try {
-      return await operation[hookName](...args);
-    } finally {
-      this._activeOperations.pop();
-    }
-  }
-
-  addOperation(operation, args) {
-    const ret = this.addOperationUsingMethod('push', operation, args);
-    return ret;
-  }
-
-  addOperationToFront(operation, args) {
-    return this.addOperationUsingMethod('unshift', operation, args);
-  }
-
-  addOperationUsingMethod(arrayMethod, operation, args) {
-    const shouldAdd = this.callOperationMethod(operation, 'onAdd', [this, args]);
-
-    if (shouldAdd) {
-      if (this._whereScope !== null && operation.whereScope === null) {
-        operation.whereScope = this._whereScope;
-      }
-
-      if (this._activeOperations.length) {
-        const { operation: parentOperation, hookName } = last(this._activeOperations);
-        parentOperation.addChildOperation(hookName, operation);
-      } else {
-        this._operations[arrayMethod](operation);
-      }
-    }
-
-    return this;
-  }
-
-  removeOperation(operation) {
-    if (operation.parentOperation) {
-      operation.parentOperation.removeChildOperation(operation);
-    } else {
-      const index = this._operations.indexOf(operation);
-
-      if (index !== -1) {
-        this._operations.splice(index, 1);
-      }
-    }
-
-    return this;
-  }
-
-  replaceOperation(operation, newOperation) {
-    if (operation.parentOperation) {
-      operation.parentOperation.replaceChildOperation(operation, newOperation);
-    } else {
-      const index = this._operations.indexOf(operation);
-
-      if (index !== -1) {
-        this._operations[index] = newOperation;
-      }
-    }
-
-    return this;
-  }
-
-  clone() {
-    return this.baseCloneInto(new this.constructor(this.unsafeKnex()));
-  }
-
-  baseCloneInto(builder) {
-    builder._modelClass = this._modelClass;
-    builder._operations = this._operations.map((it) => it.clone());
-    builder._context = this._context.clone();
-    builder._parentQuery = this._parentQuery;
-    builder._isPartialQuery = this._isPartialQuery;
-
-    // Don't copy the active operation stack. We never continue (nor can we)
-    // a query from the exact mid-hook-call state.
-    builder._activeOperations = [];
-
-    return builder;
-  }
-
-  toKnexQuery(knexBuilder = this.knex().queryBuilder()) {
-    this.executeOnBuild();
-    return this.executeOnBuildKnex(knexBuilder);
-  }
-
-  executeOnBuild() {
-    this.forEachOperation(true, (op) => {
-      if (op.hasOnBuild()) {
-        this.callOperationMethod(op, 'onBuild', [this]);
-      }
-    });
-  }
-
-  executeOnBuildKnex(knexBuilder) {
-    const whereGrouping = createWhereGrouping(this);
-
-    this.forEachOperation(true, (op) => {
-      if (whereGrouping !== null && whereGrouping.isGrouped(op)) {
-        knexBuilder = whereGrouping.build(op, knexBuilder);
-      } else if (op.hasOnBuildKnex()) {
-        const newKnexBuilder = this.callOperationMethod(op, 'onBuildKnex', [knexBuilder, this]);
-        // Default to the input knex builder for backwards compatibility
-        // with QueryBuilder.onBuildKnex hooks.
-        knexBuilder = newKnexBuilder || knexBuilder;
-      }
-    });
-
-    return knexBuilder;
-  }
-
-  toString() {
-    return this.toKnexQuery().toString();
-  }
-
-  toSql() {
-    return this.toString();
-  }
-
-  skipUndefined() {
-    deprecate('skipUndefined() is deprecated and will be removed in objection 4.0');
-    this.internalOptions().skipUndefined = true;
-    return this;
-  }
+        return findQuery;
+    }
+    clearSelect() {
+        return this.clear(SelectSelector);
+    }
+    clearWhere() {
+        return this.clear(WhereSelector);
+    }
+    clearOrder() {
+        return this.clear(OrderBySelector);
+    }
+    copyFrom(queryBuilder, operationSelector) {
+        const operationsToAdd = new Set();
+        queryBuilder.forEachOperation(operationSelector, (op) => {
+            // If an ancestor operation has already been added,
+            // there is no need to add
+            if (!op.isAncestorInSet(operationsToAdd)) {
+                operationsToAdd.add(op);
+            }
+        });
+        for (const op of operationsToAdd) {
+            const opClone = op.clone();
+            // The scope may come from a parent operation that is not copied.
+            opClone.whereScope = effectiveWhereScope(op);
+            // We may be moving nested operations to the root. Clear
+            // any links to the parent operations.
+            opClone.parentOperation = null;
+            opClone.adderHookName = null;
+            // We don't use `addOperation` here because we don't what to
+            // call `onAdd` or add these operations as child operations.
+            this._operations.push(opClone);
+        }
+        return this;
+    }
+    has(operationSelector) {
+        return !!this.findOperation(operationSelector);
+    }
+    forEachOperation(operationSelector, callback, match = true) {
+        visitOperations(this._operations, selectorKind(operationSelector), operationSelector, callback, match);
+        return this;
+    }
+    findOperation(operationSelector) {
+        let op = null;
+        this.forEachOperation(operationSelector, (it) => {
+            op = it;
+            return false;
+        });
+        return op;
+    }
+    findLastOperation(operationSelector) {
+        let op = null;
+        this.forEachOperation(operationSelector, (it) => {
+            op = it;
+        });
+        return op;
+    }
+    everyOperation(operationSelector) {
+        let every = true;
+        this.forEachOperation(operationSelector, () => {
+            every = false;
+            return false;
+        }, false);
+        return every;
+    }
+    callOperationMethod(operation, hookName, args) {
+        try {
+            operation.removeChildOperationsByHookName(hookName);
+            this._activeOperations.push({
+                operation,
+                hookName,
+            });
+            return operation[hookName](...args);
+        }
+        finally {
+            this._activeOperations.pop();
+        }
+    }
+    async callAsyncOperationMethod(operation, hookName, args) {
+        operation.removeChildOperationsByHookName(hookName);
+        this._activeOperations.push({
+            operation,
+            hookName,
+        });
+        try {
+            return await operation[hookName](...args);
+        }
+        finally {
+            this._activeOperations.pop();
+        }
+    }
+    addOperation(operation, args) {
+        const ret = this.addOperationUsingMethod('push', operation, args);
+        return ret;
+    }
+    addOperationToFront(operation, args) {
+        return this.addOperationUsingMethod('unshift', operation, args);
+    }
+    addOperationUsingMethod(arrayMethod, operation, args) {
+        const shouldAdd = this.callOperationMethod(operation, 'onAdd', [this, args]);
+        if (shouldAdd) {
+            if (this._whereScope !== null && operation.whereScope === null) {
+                operation.whereScope = this._whereScope;
+            }
+            if (this._activeOperations.length) {
+                const { operation: parentOperation, hookName } = last(this._activeOperations);
+                parentOperation.addChildOperation(hookName, operation);
+            }
+            else {
+                this._operations[arrayMethod](operation);
+            }
+        }
+        return this;
+    }
+    removeOperation(operation) {
+        if (operation.parentOperation) {
+            operation.parentOperation.removeChildOperation(operation);
+        }
+        else {
+            const index = this._operations.indexOf(operation);
+            if (index !== -1) {
+                this._operations.splice(index, 1);
+            }
+        }
+        return this;
+    }
+    replaceOperation(operation, newOperation) {
+        if (operation.parentOperation) {
+            operation.parentOperation.replaceChildOperation(operation, newOperation);
+        }
+        else {
+            const index = this._operations.indexOf(operation);
+            if (index !== -1) {
+                this._operations[index] = newOperation;
+            }
+        }
+        return this;
+    }
+    clone() {
+        return this.baseCloneInto(new this.constructor(this.unsafeKnex()));
+    }
+    baseCloneInto(builder) {
+        builder._modelClass = this._modelClass;
+        builder._operations = this._operations.map((it) => it.clone());
+        builder._context = this._context.clone();
+        builder._parentQuery = this._parentQuery;
+        builder._isPartialQuery = this._isPartialQuery;
+        // Don't copy the active operation stack. We never continue (nor can we)
+        // a query from the exact mid-hook-call state.
+        builder._activeOperations = [];
+        return builder;
+    }
+    toKnexQuery(knexBuilder = this.knex().queryBuilder()) {
+        this.executeOnBuild();
+        return this.executeOnBuildKnex(knexBuilder);
+    }
+    executeOnBuild() {
+        this.forEachOperation(true, (op) => {
+            if (op.hasOnBuild()) {
+                this.callOperationMethod(op, 'onBuild', [this]);
+            }
+        });
+    }
+    executeOnBuildKnex(knexBuilder) {
+        const whereGrouping = createWhereGrouping(this);
+        this.forEachOperation(true, (op) => {
+            if (whereGrouping !== null && whereGrouping.isGrouped(op)) {
+                knexBuilder = whereGrouping.build(op, knexBuilder);
+            }
+            else if (op.hasOnBuildKnex()) {
+                const newKnexBuilder = this.callOperationMethod(op, 'onBuildKnex', [knexBuilder, this]);
+                // Default to the input knex builder for backwards compatibility
+                // with QueryBuilder.onBuildKnex hooks.
+                knexBuilder = newKnexBuilder || knexBuilder;
+            }
+        });
+        return knexBuilder;
+    }
+    toString() {
+        return this.toKnexQuery().toString();
+    }
+    toSql() {
+        return this.toString();
+    }
+    skipUndefined() {
+        deprecate('skipUndefined() is deprecated and will be removed in objection 4.0');
+        this.internalOptions().skipUndefined = true;
+        return this;
+    }
 }
-
-function buildFunctionForOperationSelector(operationSelector) {
-  if (operationSelector === true) {
-    return AllSelector;
-  } else if (isRegExp(operationSelector)) {
-    return (op) => operationSelector.test(op.name);
-  } else if (isString(operationSelector)) {
-    return (op) => op.name === operationSelector;
-  } else if (
-    isFunction(operationSelector) &&
-    operationSelector.isObjectionQueryBuilderOperationClass
-  ) {
-    return (op) => op.is(operationSelector);
-  } else if (isFunction(operationSelector)) {
-    return operationSelector;
-  } else {
-    return () => false;
-  }
+// Operation selectors are `true` (every operation), a regex or a string that
+// is matched against the operation name, an operation class, or a predicate.
+// Queries walk their operations many times, so the selector is classified
+// once per walk instead of being wrapped in a new function.
+const SELECT_ALL = 0;
+const SELECT_REGEX = 1;
+const SELECT_NAME = 2;
+const SELECT_CLASS = 3;
+const SELECT_PREDICATE = 4;
+const SELECT_NONE = 5;
+function selectorKind(operationSelector) {
+    if (operationSelector === true) {
+        return SELECT_ALL;
+    }
+    else if (isRegExp(operationSelector)) {
+        return SELECT_REGEX;
+    }
+    else if (isString(operationSelector)) {
+        return SELECT_NAME;
+    }
+    else if (isFunction(operationSelector) &&
+        operationSelector.isObjectionQueryBuilderOperationClass) {
+        return SELECT_CLASS;
+    }
+    else if (isFunction(operationSelector)) {
+        return SELECT_PREDICATE;
+    }
+    else {
+        return SELECT_NONE;
+    }
+}
+function matchesSelector(op, kind, operationSelector) {
+    switch (kind) {
+        case SELECT_ALL:
+            return true;
+        case SELECT_REGEX:
+            return operationSelector.test(op.name);
+        case SELECT_NAME:
+            return op.name === operationSelector;
+        case SELECT_CLASS:
+            return op.is(operationSelector);
+        case SELECT_PREDICATE:
+            return operationSelector(op);
+        default:
+            return false;
+    }
+}
+// Visits the operations and their descendants depth first, each operation
+// before its children. Returns false if the callback stopped the walk by
+// returning false. The arrays are read as the walk goes, so operations that
+// the callback adds are visited too, as before.
+function visitOperations(operations, kind, operationSelector, callback, match) {
+    for (const op of operations) {
+        if (matchesSelector(op, kind, operationSelector) === match && callback(op) === false) {
+            return false;
+        }
+        if (op.childOperations.length !== 0 &&
+            visitOperations(op.childOperations, kind, operationSelector, callback, match) === false) {
+            return false;
+        }
+    }
+    return true;
 }
-
 function getTableName(modelClassOrTableName) {
-  if (isString(modelClassOrTableName)) {
-    return modelClassOrTableName;
-  } else {
-    return modelClassOrTableName.getTableName();
-  }
+    if (isString(modelClassOrTableName)) {
+        return modelClassOrTableName;
+    }
+    else {
+        return modelClassOrTableName.getTableName();
+    }
 }
-
 module.exports = {
-  QueryBuilderOperationSupport,
+    QueryBuilderOperationSupport,
 };