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

package/lib/queryBuilder/QueryBuilder.js

@@ -1,31 +1,24 @@
 'use strict';
-
 const { withWhereScope } = require('./whereScopes');
 const { wrapError } = require('db-errors');
-
 const { raw } = require('./RawBuilder');
 const { createModifier } = require('../utils/createModifier');
 const { ValidationErrorType } = require('../model/ValidationError');
 const { isObject, isString, isFunction, last, flatten } = require('../utils/objectUtils');
 const { RelationExpression, DuplicateRelationError } = require('./RelationExpression');
 const { assertIdNotUndefined } = require('../utils/assert');
-
 const { Selection } = require('./operations/select/Selection');
-
 const { QueryBuilderContext } = require('./QueryBuilderContext');
 const { QueryBuilderBase } = require('./QueryBuilderBase');
-
 const { FindOperation } = require('./operations/FindOperation');
 const { DeleteOperation } = require('./operations/DeleteOperation');
 const { UpdateOperation } = require('./operations/UpdateOperation');
 const { InsertOperation } = require('./operations/InsertOperation');
 const { RelateOperation } = require('./operations/RelateOperation');
 const { UnrelateOperation } = require('./operations/UnrelateOperation');
-
 const { JoinEagerOperation } = require('./operations/eager/JoinEagerOperation');
 const { NaiveEagerOperation } = require('./operations/eager/NaiveEagerOperation');
 const { WhereInEagerOperation } = require('./operations/eager/WhereInEagerOperation');
-
 const { InsertGraphAndFetchOperation } = require('./operations/InsertGraphAndFetchOperation');
 const { UpsertGraphAndFetchOperation } = require('./operations/UpsertGraphAndFetchOperation');
 const { InsertAndFetchOperation } = require('./operations/InsertAndFetchOperation');
@@ -46,1353 +39,1098 @@ const { RangeOperation } = require('./operations/RangeOperation');
 const { FirstOperation } = require('./operations/FirstOperation');
 const { FromOperation } = require('./operations/FromOperation');
 const { KnexOperation } = require('./operations/KnexOperation');
-
 class QueryBuilder extends QueryBuilderBase {
-  static init(self, modelClass) {
-    super.init(self, modelClass);
-
-    self._resultModelClass = null;
-    self._explicitRejectValue = null;
-    self._explicitResolveValue = null;
-    self._modifiers = {};
-
-    self._allowedGraphExpression = null;
-    self._findOperationOptions = modelClass.defaultFindOptions;
-    self._relatedQueryFor = null;
-    self._isRelatedQuery = false;
-    self._forError = null;
-
-    self._findOperationFactory = findOperationFactory;
-    self._insertOperationFactory = insertOperationFactory;
-    self._updateOperationFactory = updateOperationFactory;
-    self._patchOperationFactory = patchOperationFactory;
-    self._relateOperationFactory = relateOperationFactory;
-    self._unrelateOperationFactory = unrelateOperationFactory;
-    self._deleteOperationFactory = deleteOperationFactory;
-  }
-
-  static get QueryBuilderContext() {
-    return QueryBuilderContext;
-  }
-
-  static parseRelationExpression(expr) {
-    return RelationExpression.create(expr).toPojo();
-  }
-
-  tableName(newTableName) {
-    return this.tableNameFor(this.modelClass().getTableName(), newTableName);
-  }
-
-  tableRef() {
-    return this.tableRefFor(this.modelClass().getTableName());
-  }
-
-  alias(alias) {
-    return this.aliasFor(this.modelClass().getTableName(), alias);
-  }
-
-  fullIdColumnFor(modelClass) {
-    const tableName = this.tableRefFor(modelClass);
-    const idColumn = modelClass.getIdColumn();
-
-    if (Array.isArray(idColumn)) {
-      return idColumn.map((col) => `${tableName}.${col}`);
-    } else {
-      return `${tableName}.${idColumn}`;
-    }
-  }
-
-  fullIdColumn() {
-    return this.fullIdColumnFor(this.modelClass());
-  }
-
-  modifiers(modifiers) {
-    if (arguments.length === 0) {
-      return { ...this._modifiers };
-    } else {
-      this._modifiers = { ...this._modifiers, ...modifiers };
-      return this;
-    }
-  }
-
-  modify(modifier, ...args) {
-    if (!modifier) {
-      return this;
-    }
-
-    modifier = createModifier({
-      modifier,
-      modelClass: this.modelClass(),
-      modifiers: this._modifiers,
-    });
-
-    modifier(this, ...args);
-    return this;
-  }
-
-  reject(error) {
-    this._explicitRejectValue = error;
-    return this;
-  }
-
-  resolve(value) {
-    this._explicitResolveValue = value;
-    return this;
-  }
-
-  isExplicitlyResolvedOrRejected() {
-    return !!(this._explicitRejectValue || this._explicitResolveValue);
-  }
-
-  isExecutable() {
-    return !this.isExplicitlyResolvedOrRejected() && !findQueryExecutorOperation(this);
-  }
-
-  findOperationFactory(factory) {
-    this._findOperationFactory = factory;
-    return this;
-  }
-
-  insertOperationFactory(factory) {
-    this._insertOperationFactory = factory;
-    return this;
-  }
-
-  updateOperationFactory(factory) {
-    this._updateOperationFactory = factory;
-    return this;
-  }
-
-  patchOperationFactory(factory) {
-    this._patchOperationFactory = factory;
-    return this;
-  }
-
-  deleteOperationFactory(factory) {
-    this._deleteOperationFactory = factory;
-    return this;
-  }
-
-  relateOperationFactory(factory) {
-    this._relateOperationFactory = factory;
-    return this;
-  }
-
-  unrelateOperationFactory(factory) {
-    this._unrelateOperationFactory = factory;
-    return this;
-  }
-
-  withGraphFetched(exp, options = {}) {
-    return this._withGraph(exp, options, getWhereInEagerAlgorithm(this));
-  }
-
-  withGraphJoined(exp, options = {}) {
-    return this._withGraph(exp, options, getJoinEagerAlgorithm(this));
-  }
-
-  _withGraph(exp, options, algorithm) {
-    const eagerOp = ensureEagerOperation(this, algorithm);
-    const parsedExp = parseRelationExpression(this.modelClass(), exp);
-
-    eagerOp.expression = eagerOp.expression.merge(parsedExp);
-    eagerOp.graphOptions = { ...eagerOp.graphOptions, ...options };
-
-    checkEager(this);
-    return this;
-  }
-
-  allowGraph(exp) {
-    const currentExpr = this._allowedGraphExpression || RelationExpression.create();
-
-    this._allowedGraphExpression = currentExpr.merge(
-      parseRelationExpression(this.modelClass(), exp),
-    );
-
-    checkEager(this);
-    return this;
-  }
-
-  allowedGraphExpression() {
-    return this._allowedGraphExpression;
-  }
-
-  graphExpressionObject() {
-    const eagerOp = this.findOperation(EagerOperation);
-
-    if (eagerOp && !eagerOp.expression.isEmpty) {
-      return eagerOp.expression.toPojo();
-    } else {
-      return null;
-    }
-  }
-
-  graphModifiersAtPath() {
-    const eagerOp = this.findOperation(EagerOperation);
-
-    if (eagerOp && !eagerOp.expression.isEmpty) {
-      return eagerOp.modifiersAtPath.map((it) => Object.assign({}, it));
-    } else {
-      return [];
-    }
-  }
-
-  modifyGraph(path, modifier) {
-    const eagerOp = ensureEagerOperation(this);
-    eagerOp.modifiersAtPath.push({ path, modifier });
-    return this;
-  }
-
-  findOptions(opt) {
-    if (arguments.length !== 0) {
-      this._findOperationOptions = Object.assign({}, this._findOperationOptions, opt);
-      return this;
-    } else {
-      return this._findOperationOptions;
-    }
-  }
-
-  resultModelClass() {
-    return this._resultModelClass || this.modelClass();
-  }
-
-  isFind() {
-    return !(
-      this.isInsert() ||
-      this.isUpdate() ||
-      this.isDelete() ||
-      this.isRelate() ||
-      this.isUnrelate()
-    );
-  }
-
-  isInsert() {
-    return this.has(InsertOperation);
-  }
-
-  isUpdate() {
-    return this.has(UpdateOperation);
-  }
-
-  isDelete() {
-    return this.has(DeleteOperation);
-  }
-
-  isRelate() {
-    return this.has(RelateOperation);
-  }
-
-  isUnrelate() {
-    return this.has(UnrelateOperation);
-  }
-
-  hasWheres() {
-    const queryWithoutGraph = this.clone().clearWithGraph();
-    return prebuildQuery(queryWithoutGraph).has(QueryBuilderBase.WhereSelector);
-  }
-
-  hasSelects() {
-    return this.has(QueryBuilderBase.SelectSelector);
-  }
-
-  hasWithGraph() {
-    const eagerOp = this.findOperation(EagerOperation);
-    return !!eagerOp && !eagerOp.expression.isEmpty;
-  }
-
-  isSelectAll() {
-    if (this._operations.length === 0) {
-      return true;
-    }
-
-    const tableRef = this.tableRef();
-    const tableName = this.tableName();
-
-    return this.everyOperation((op) => {
-      if (op.constructor === SelectOperation) {
-        // SelectOperations with zero selections are the ones that only have
-        // raw items or other non-trivial selections.
-        return (
-          op.selections.length > 0 &&
-          op.selections.every((select) => {
-            return (!select.table || select.table === tableRef) && select.column === '*';
-          })
-        );
-      } else if (op.constructor === FromOperation) {
-        return op.table === tableName;
-      } else if (op.name === 'as' || op.is(FindOperation) || op.is(OnErrorOperation)) {
-        return true;
-      } else {
-        return false;
-      }
-    });
-  }
-
-  toString() {
-    return '[object QueryBuilder]';
-  }
-
-  clone() {
-    const builder = this.emptyInstance();
-
-    // Call the super class's clone implementation.
-    this.baseCloneInto(builder);
-
-    builder._resultModelClass = this._resultModelClass;
-
-    builder._explicitRejectValue = this._explicitRejectValue;
-    builder._explicitResolveValue = this._explicitResolveValue;
-    builder._modifiers = { ...this._modifiers };
-
-    builder._allowedGraphExpression = this._allowedGraphExpression;
-    builder._findOperationOptions = this._findOperationOptions;
-    builder._relatedQueryFor = this._relatedQueryFor;
-
-    return builder;
-  }
-
-  emptyInstance() {
-    const builder = new this.constructor(this.modelClass());
-
-    builder._findOperationFactory = this._findOperationFactory;
-    builder._insertOperationFactory = this._insertOperationFactory;
-    builder._updateOperationFactory = this._updateOperationFactory;
-    builder._patchOperationFactory = this._patchOperationFactory;
-    builder._relateOperationFactory = this._relateOperationFactory;
-    builder._unrelateOperationFactory = this._unrelateOperationFactory;
-    builder._deleteOperationFactory = this._deleteOperationFactory;
-    builder._relatedQueryFor = this._relatedQueryFor;
-    builder._isRelatedQuery = this._isRelatedQuery;
-    builder._forError = this._forError;
-
-    return builder;
-  }
-
-  clearWithGraph() {
-    this.clear(EagerOperation);
-    return this;
-  }
-
-  clearWithGraphFetched() {
-    this.clear(WhereInEagerOperation);
-    return this;
-  }
-
-  clearAllowGraph() {
-    this._allowedGraphExpression = null;
-    return this;
-  }
-
-  clearModifiers() {
-    this._modifiers = {};
-    return this;
-  }
-
-  clearReject() {
-    this._explicitRejectValue = null;
-    return this;
-  }
-
-  clearResolve() {
-    this._explicitResolveValue = null;
-    return this;
-  }
-
-  castTo(modelClass) {
-    this._resultModelClass = modelClass || null;
-    return this;
-  }
-
-  then(...args) {
-    const promise = this.execute();
-    return promise.then(...args);
-  }
-
-  catch(...args) {
-    const promise = this.execute();
-    return promise.catch(...args);
-  }
-
-  async resultSize() {
-    const knex = this.knex();
-    const builder = this.clone().clear(/orderBy|offset|limit/);
-
-    const countQuery = knex.count('* as count').from((knexBuilder) => {
-      builder.toKnexQuery(knexBuilder).as('temp');
-    });
-
-    if (this.internalOptions().debug) {
-      countQuery.debug();
-    }
-
-    const result = await countQuery;
-    return result[0] && result[0].count ? parseInt(result[0].count) : 0;
-  }
-
-  toKnexQuery(knexBuilder = this.knex().queryBuilder()) {
-    const prebuiltQuery = prebuildQuery(this.clone());
-    return buildKnexQuery(prebuiltQuery, knexBuilder);
-  }
-
-  async execute() {
-    // Take a clone so that we don't modify this instance during execution.
-    const builder = this.clone();
-
-    try {
-      await beforeExecute(builder);
-      const result = await doExecute(builder);
-      return await afterExecute(builder, result);
-    } catch (error) {
-      return await handleExecuteError(builder, error);
-    }
-  }
-
-  throwIfNotFound(data = {}) {
-    return this.runAfter((result) => {
-      if (
-        (Array.isArray(result) && result.length === 0) ||
-        result === null ||
-        result === undefined ||
-        result === 0
-      ) {
-        throw this.modelClass().createNotFoundError(this.context(), data);
-      } else {
-        return result;
-      }
-    });
-  }
-
-  findSelection(selection, explicit = false) {
-    let noSelectStatements = true;
-    let selectionInstance = null;
-
-    this.forEachOperation(true, (op) => {
-      if (op.constructor === SelectOperation) {
-        selectionInstance = op.findSelection(this, selection);
-        noSelectStatements = false;
-
+    static init(self, modelClass) {
+        super.init(self, modelClass);
+        self._resultModelClass = null;
+        self._explicitRejectValue = null;
+        self._explicitResolveValue = null;
+        self._modifiers = {};
+        self._allowedGraphExpression = null;
+        self._findOperationOptions = modelClass.defaultFindOptions;
+        self._relatedQueryFor = null;
+        self._isRelatedQuery = false;
+        self._forError = null;
+        self._findOperationFactory = findOperationFactory;
+        self._insertOperationFactory = insertOperationFactory;
+        self._updateOperationFactory = updateOperationFactory;
+        self._patchOperationFactory = patchOperationFactory;
+        self._relateOperationFactory = relateOperationFactory;
+        self._unrelateOperationFactory = unrelateOperationFactory;
+        self._deleteOperationFactory = deleteOperationFactory;
+    }
+    static get QueryBuilderContext() {
+        return QueryBuilderContext;
+    }
+    static parseRelationExpression(expr) {
+        return RelationExpression.create(expr).toPojo();
+    }
+    tableName(newTableName) {
+        return this.tableNameFor(this.modelClass().getTableName(), newTableName);
+    }
+    tableRef() {
+        return this.tableRefFor(this.modelClass().getTableName());
+    }
+    alias(alias) {
+        return this.aliasFor(this.modelClass().getTableName(), alias);
+    }
+    fullIdColumnFor(modelClass) {
+        const tableName = this.tableRefFor(modelClass);
+        const idColumn = modelClass.getIdColumn();
+        if (Array.isArray(idColumn)) {
+            return idColumn.map((col) => `${tableName}.${col}`);
+        }
+        else {
+            return `${tableName}.${idColumn}`;
+        }
+    }
+    fullIdColumn() {
+        return this.fullIdColumnFor(this.modelClass());
+    }
+    modifiers(modifiers) {
+        if (arguments.length === 0) {
+            return { ...this._modifiers };
+        }
+        else {
+            this._modifiers = { ...this._modifiers, ...modifiers };
+            return this;
+        }
+    }
+    modify(modifier, ...args) {
+        if (!modifier) {
+            return this;
+        }
+        modifier = createModifier({
+            modifier,
+            modelClass: this.modelClass(),
+            modifiers: this._modifiers,
+        });
+        modifier(this, ...args);
+        return this;
+    }
+    reject(error) {
+        this._explicitRejectValue = error;
+        return this;
+    }
+    resolve(value) {
+        this._explicitResolveValue = value;
+        return this;
+    }
+    isExplicitlyResolvedOrRejected() {
+        return !!(this._explicitRejectValue || this._explicitResolveValue);
+    }
+    isExecutable() {
+        return !this.isExplicitlyResolvedOrRejected() && !findQueryExecutorOperation(this);
+    }
+    findOperationFactory(factory) {
+        this._findOperationFactory = factory;
+        return this;
+    }
+    insertOperationFactory(factory) {
+        this._insertOperationFactory = factory;
+        return this;
+    }
+    updateOperationFactory(factory) {
+        this._updateOperationFactory = factory;
+        return this;
+    }
+    patchOperationFactory(factory) {
+        this._patchOperationFactory = factory;
+        return this;
+    }
+    deleteOperationFactory(factory) {
+        this._deleteOperationFactory = factory;
+        return this;
+    }
+    relateOperationFactory(factory) {
+        this._relateOperationFactory = factory;
+        return this;
+    }
+    unrelateOperationFactory(factory) {
+        this._unrelateOperationFactory = factory;
+        return this;
+    }
+    withGraphFetched(exp, options = {}) {
+        return this._withGraph(exp, options, getWhereInEagerAlgorithm(this));
+    }
+    withGraphJoined(exp, options = {}) {
+        return this._withGraph(exp, options, getJoinEagerAlgorithm(this));
+    }
+    _withGraph(exp, options, algorithm) {
+        const eagerOp = ensureEagerOperation(this, algorithm);
+        const parsedExp = parseRelationExpression(this.modelClass(), exp);
+        eagerOp.expression = eagerOp.expression.merge(parsedExp);
+        eagerOp.graphOptions = { ...eagerOp.graphOptions, ...options };
+        checkEager(this);
+        return this;
+    }
+    allowGraph(exp) {
+        const currentExpr = this._allowedGraphExpression || RelationExpression.create();
+        this._allowedGraphExpression = currentExpr.merge(parseRelationExpression(this.modelClass(), exp));
+        checkEager(this);
+        return this;
+    }
+    allowedGraphExpression() {
+        return this._allowedGraphExpression;
+    }
+    graphExpressionObject() {
+        const eagerOp = this.findOperation(EagerOperation);
+        if (eagerOp && !eagerOp.expression.isEmpty) {
+            return eagerOp.expression.toPojo();
+        }
+        else {
+            return null;
+        }
+    }
+    graphModifiersAtPath() {
+        const eagerOp = this.findOperation(EagerOperation);
+        if (eagerOp && !eagerOp.expression.isEmpty) {
+            return eagerOp.modifiersAtPath.map((it) => Object.assign({}, it));
+        }
+        else {
+            return [];
+        }
+    }
+    modifyGraph(path, modifier) {
+        const eagerOp = ensureEagerOperation(this);
+        eagerOp.modifiersAtPath.push({ path, modifier });
+        return this;
+    }
+    findOptions(opt) {
+        if (arguments.length !== 0) {
+            this._findOperationOptions = Object.assign({}, this._findOperationOptions, opt);
+            return this;
+        }
+        else {
+            return this._findOperationOptions;
+        }
+    }
+    resultModelClass() {
+        return this._resultModelClass || this.modelClass();
+    }
+    isFind() {
+        if (this.isInsert === QueryBuilder.prototype.isInsert &&
+            this.isUpdate === QueryBuilder.prototype.isUpdate &&
+            this.isDelete === QueryBuilder.prototype.isDelete &&
+            this.isRelate === QueryBuilder.prototype.isRelate &&
+            this.isUnrelate === QueryBuilder.prototype.isUnrelate) {
+            // The same as below in one walk of the operations instead of five.
+            return !this.has(isWriteOperation);
+        }
+        return !(this.isInsert() ||
+            this.isUpdate() ||
+            this.isDelete() ||
+            this.isRelate() ||
+            this.isUnrelate());
+    }
+    isInsert() {
+        return this.has(InsertOperation);
+    }
+    isUpdate() {
+        return this.has(UpdateOperation);
+    }
+    isDelete() {
+        return this.has(DeleteOperation);
+    }
+    isRelate() {
+        return this.has(RelateOperation);
+    }
+    isUnrelate() {
+        return this.has(UnrelateOperation);
+    }
+    hasWheres() {
+        const queryWithoutGraph = this.clone().clearWithGraph();
+        return prebuildQuery(queryWithoutGraph).has(QueryBuilderBase.WhereSelector);
+    }
+    hasSelects() {
+        return this.has(QueryBuilderBase.SelectSelector);
+    }
+    hasWithGraph() {
+        const eagerOp = this.findOperation(EagerOperation);
+        return !!eagerOp && !eagerOp.expression.isEmpty;
+    }
+    isSelectAll() {
+        if (this._operations.length === 0) {
+            return true;
+        }
+        const tableRef = this.tableRef();
+        const tableName = this.tableName();
+        return this.everyOperation((op) => {
+            if (op.constructor === SelectOperation) {
+                // SelectOperations with zero selections are the ones that only have
+                // raw items or other non-trivial selections.
+                return (op.selections.length > 0 &&
+                    op.selections.every((select) => {
+                        return (!select.table || select.table === tableRef) && select.column === '*';
+                    }));
+            }
+            else if (op.constructor === FromOperation) {
+                return op.table === tableName;
+            }
+            else if (op.name === 'as' || op.is(FindOperation) || op.is(OnErrorOperation)) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        });
+    }
+    toString() {
+        return '[object QueryBuilder]';
+    }
+    clone() {
+        const builder = this.emptyInstance();
+        // Call the super class's clone implementation.
+        this.baseCloneInto(builder);
+        builder._resultModelClass = this._resultModelClass;
+        builder._explicitRejectValue = this._explicitRejectValue;
+        builder._explicitResolveValue = this._explicitResolveValue;
+        builder._modifiers = { ...this._modifiers };
+        builder._allowedGraphExpression = this._allowedGraphExpression;
+        builder._findOperationOptions = this._findOperationOptions;
+        builder._relatedQueryFor = this._relatedQueryFor;
+        return builder;
+    }
+    emptyInstance() {
+        const builder = new this.constructor(this.modelClass());
+        builder._findOperationFactory = this._findOperationFactory;
+        builder._insertOperationFactory = this._insertOperationFactory;
+        builder._updateOperationFactory = this._updateOperationFactory;
+        builder._patchOperationFactory = this._patchOperationFactory;
+        builder._relateOperationFactory = this._relateOperationFactory;
+        builder._unrelateOperationFactory = this._unrelateOperationFactory;
+        builder._deleteOperationFactory = this._deleteOperationFactory;
+        builder._relatedQueryFor = this._relatedQueryFor;
+        builder._isRelatedQuery = this._isRelatedQuery;
+        builder._forError = this._forError;
+        return builder;
+    }
+    clearWithGraph() {
+        this.clear(EagerOperation);
+        return this;
+    }
+    clearWithGraphFetched() {
+        this.clear(WhereInEagerOperation);
+        return this;
+    }
+    clearAllowGraph() {
+        this._allowedGraphExpression = null;
+        return this;
+    }
+    clearModifiers() {
+        this._modifiers = {};
+        return this;
+    }
+    clearReject() {
+        this._explicitRejectValue = null;
+        return this;
+    }
+    clearResolve() {
+        this._explicitResolveValue = null;
+        return this;
+    }
+    castTo(modelClass) {
+        this._resultModelClass = modelClass || null;
+        return this;
+    }
+    then(...args) {
+        const promise = this.execute();
+        return promise.then(...args);
+    }
+    catch(...args) {
+        const promise = this.execute();
+        return promise.catch(...args);
+    }
+    finally(...args) {
+        const promise = this.execute();
+        return promise.finally(...args);
+    }
+    async resultSize() {
+        const knex = this.knex();
+        const builder = this.clone().clear(/orderBy|offset|limit/);
+        const countQuery = knex.count('* as count').from((knexBuilder) => {
+            builder.toKnexQuery(knexBuilder).as('temp');
+        });
+        if (this.internalOptions().debug) {
+            countQuery.debug();
+        }
+        const result = await countQuery;
+        return result[0] && result[0].count ? parseInt(result[0].count, 10) : 0;
+    }
+    toKnexQuery(knexBuilder = this.knex().queryBuilder()) {
+        const prebuiltQuery = prebuildQuery(this.clone());
+        return buildKnexQuery(prebuiltQuery, knexBuilder);
+    }
+    async execute() {
+        // Take a clone so that we don't modify this instance during execution.
+        const builder = this.clone();
+        try {
+            await beforeExecute(builder);
+            const result = await doExecute(builder);
+            return await afterExecute(builder, result);
+        }
+        catch (error) {
+            return await handleExecuteError(builder, error);
+        }
+    }
+    throwIfNotFound(data = {}) {
+        return this.runAfter((result) => {
+            if ((Array.isArray(result) && result.length === 0) ||
+                result === null ||
+                result === undefined ||
+                result === 0) {
+                throw this.modelClass().createNotFoundError(this.context(), data);
+            }
+            else {
+                return result;
+            }
+        });
+    }
+    findSelection(selection, explicit = false) {
+        let noSelectStatements = true;
+        let selectionInstance = null;
+        this.forEachOperation(true, (op) => {
+            if (op.constructor === SelectOperation) {
+                selectionInstance = op.findSelection(this, selection);
+                noSelectStatements = false;
+                if (selectionInstance) {
+                    return false;
+                }
+            }
+        });
         if (selectionInstance) {
-          return false;
+            return selectionInstance;
         }
-      }
-    });
-
-    if (selectionInstance) {
-      return selectionInstance;
-    }
-
-    if (noSelectStatements && !explicit) {
-      const selectAll = new Selection(this.tableRef(), '*');
-
-      if (Selection.doesSelect(this, selectAll, selection)) {
-        return selectAll;
-      } else {
-        return null;
-      }
-    } else {
-      return null;
-    }
-  }
-
-  findAllSelections() {
-    let allSelections = [];
-
-    this.forEachOperation(true, (op) => {
-      if (op.constructor === SelectOperation) {
-        allSelections = allSelections.concat(op.selections);
-      }
-    });
-
-    return allSelections;
-  }
-
-  hasSelection(selection, explicit) {
-    return this.findSelection(selection, explicit) !== null;
-  }
-
-  hasSelectionAs(selection, alias, explicit) {
-    selection = Selection.create(selection);
-    const foundSelection = this.findSelection(selection, explicit);
-
-    if (foundSelection === null) {
-      return false;
-    } else {
-      if (foundSelection.column === '*') {
-        // * selects the columns with their column names as aliases.
-        return selection.column === alias;
-      } else {
-        return foundSelection.name === alias;
-      }
-    }
-  }
-
-  traverse(modelClass, traverser) {
-    if (typeof traverser === 'undefined') {
-      traverser = modelClass;
-      modelClass = null;
-    }
-
-    return this.runAfter((result) => {
-      this.resultModelClass().traverse(modelClass, result, traverser);
-      return result;
-    });
-  }
-
-  page(page, pageSize) {
-    return this.range(+page * +pageSize, (+page + 1) * +pageSize - 1);
-  }
-
-  columnInfo({ table = null } = {}) {
-    table = table || this.tableName();
-
-    const knex = this.knex();
-    const tableParts = table.split('.');
-    const columnInfoQuery = knex(last(tableParts)).columnInfo();
-    const schema = this.internalOptions().schema;
-
-    if (schema) {
-      columnInfoQuery.withSchema(schema);
-    } else if (tableParts.length > 1) {
-      columnInfoQuery.withSchema(tableParts[0]);
-    }
-
-    if (this.internalOptions().debug) {
-      columnInfoQuery.debug();
-    }
-
-    return columnInfoQuery;
-  }
-
-  withSchema(schema) {
-    this.internalOptions().schema = schema;
-    this.internalContext().onBuild.push((builder) => {
-      if (!builder.has(/withSchema/)) {
-        // Need to push this operation to the front because knex doesn't use the
-        // schema for operations called before `withSchema`.
-        builder.addOperationToFront(new KnexOperation('withSchema'), [schema]);
-      }
-    });
-
-    return this;
-  }
-
-  debug /* istanbul ignore next */() {
-    this.internalOptions().debug = true;
-    this.internalContext().onBuild.push((builder) => {
-      builder.addOperation(new KnexOperation('debug'), []);
-    });
-
-    return this;
-  }
-
-  insert(modelsOrObjects) {
-    return writeOperation(this, () => {
-      const insertOperation = this._insertOperationFactory(this);
-
-      this.addOperation(insertOperation, [modelsOrObjects]);
-    });
-  }
-
-  insertAndFetch(modelsOrObjects) {
-    return writeOperation(this, () => {
-      const insertOperation = this._insertOperationFactory(this);
-
-      const insertAndFetchOperation = new InsertAndFetchOperation('insertAndFetch', {
-        delegate: insertOperation,
-      });
-
-      this.addOperation(insertAndFetchOperation, [modelsOrObjects]);
-    });
-  }
-
-  insertGraph(modelsOrObjects, opt) {
-    return writeOperation(this, () => {
-      const insertOperation = this._insertOperationFactory(this);
-
-      const insertGraphOperation = new InsertGraphOperation('insertGraph', {
-        delegate: insertOperation,
-        opt,
-      });
-
-      this.addOperation(insertGraphOperation, [modelsOrObjects]);
-    });
-  }
-
-  insertGraphAndFetch(modelsOrObjects, opt) {
-    return writeOperation(this, () => {
-      const insertOperation = this._insertOperationFactory(this);
-
-      const insertGraphOperation = new InsertGraphOperation('insertGraph', {
-        delegate: insertOperation,
-        opt,
-      });
-
-      const insertGraphAndFetchOperation = new InsertGraphAndFetchOperation('insertGraphAndFetch', {
-        delegate: insertGraphOperation,
-      });
-
-      return this.addOperation(insertGraphAndFetchOperation, [modelsOrObjects]);
-    });
-  }
-
-  update(modelOrObject) {
-    return writeOperation(this, () => {
-      const updateOperation = this._updateOperationFactory(this);
-
-      this.addOperation(updateOperation, [modelOrObject]);
-    });
-  }
-
-  updateAndFetch(modelOrObject) {
-    return writeOperation(this, () => {
-      const updateOperation = this._updateOperationFactory(this);
-
-      if (!(updateOperation.instance instanceof this.modelClass())) {
-        throw new Error('updateAndFetch can only be called for instance operations');
-      }
-
-      const updateAndFetch = new UpdateAndFetchOperation('updateAndFetch', {
-        delegate: updateOperation,
-      });
-
-      // patchOperation is an instance update operation that already adds the
-      // required "where id = $" clause.
-      updateAndFetch.skipIdWhere = true;
-
-      this.addOperation(updateAndFetch, [updateOperation.instance.$id(), modelOrObject]);
-    });
-  }
-
-  updateAndFetchById(id, modelOrObject) {
-    return writeOperation(this, () => {
-      const updateOperation = this._updateOperationFactory(this);
-
-      const updateAndFetch = new UpdateAndFetchOperation('updateAndFetch', {
-        delegate: updateOperation,
-      });
-
-      this.addOperation(updateAndFetch, [id, modelOrObject]);
-    });
-  }
-
-  upsertGraph(modelsOrObjects, upsertOptions) {
-    return writeOperation(this, () => {
-      const upsertGraphOperation = new UpsertGraphOperation('upsertGraph', {
-        upsertOptions,
-      });
-
-      this.addOperation(upsertGraphOperation, [modelsOrObjects]);
-    });
-  }
-
-  upsertGraphAndFetch(modelsOrObjects, upsertOptions) {
-    return writeOperation(this, () => {
-      const upsertGraphOperation = new UpsertGraphOperation('upsertGraph', {
-        upsertOptions,
-      });
-
-      const upsertGraphAndFetchOperation = new UpsertGraphAndFetchOperation('upsertGraphAndFetch', {
-        delegate: upsertGraphOperation,
-      });
-
-      return this.addOperation(upsertGraphAndFetchOperation, [modelsOrObjects]);
-    });
-  }
-
-  patch(modelOrObject) {
-    return writeOperation(this, () => {
-      const patchOperation = this._patchOperationFactory(this);
-
-      this.addOperation(patchOperation, [modelOrObject]);
-    });
-  }
-
-  patchAndFetch(modelOrObject) {
-    return writeOperation(this, () => {
-      const patchOperation = this._patchOperationFactory(this);
-
-      if (!(patchOperation.instance instanceof this.modelClass())) {
-        throw new Error('patchAndFetch can only be called for instance operations');
-      }
-
-      const patchAndFetch = new UpdateAndFetchOperation('patchAndFetch', {
-        delegate: patchOperation,
-      });
-
-      // patchOperation is an instance update operation that already adds the
-      // required "where id = $" clause.
-      patchAndFetch.skipIdWhere = true;
-
-      this.addOperation(patchAndFetch, [patchOperation.instance.$id(), modelOrObject]);
-    });
-  }
-
-  patchAndFetchById(id, modelOrObject) {
-    return writeOperation(this, () => {
-      const patchOperation = this._patchOperationFactory(this);
-
-      const patchAndFetch = new UpdateAndFetchOperation('patchAndFetch', {
-        delegate: patchOperation,
-      });
-
-      this.addOperation(patchAndFetch, [id, modelOrObject]);
-    });
-  }
-
-  delete(...args) {
-    return writeOperation(this, () => {
-      if (args.length) {
-        throw new Error(
-          `Don't pass arguments to delete(). You should use it like this: delete().where('foo', 'bar').andWhere(...)`,
-        );
-      }
-
-      const deleteOperation = this._deleteOperationFactory(this);
-      this.addOperation(deleteOperation, args);
-    });
-  }
-
-  del(...args) {
-    return this.delete(...args);
-  }
-
-  relate(...args) {
-    return writeOperation(this, () => {
-      const relateOperation = this._relateOperationFactory(this);
-
-      this.addOperation(relateOperation, args);
-    });
-  }
-
-  unrelate(...args) {
-    return writeOperation(this, () => {
-      if (args.length) {
-        throw new Error(
-          `Don't pass arguments to unrelate(). You should use it like this: unrelate().where('foo', 'bar').andWhere(...)`,
-        );
-      }
-
-      const unrelateOperation = this._unrelateOperationFactory(this);
-      this.addOperation(unrelateOperation, args);
-    });
-  }
-
-  increment(propertyName, howMuch) {
-    const columnName = this.modelClass().propertyNameToColumnName(propertyName);
-
-    return this.patch({
-      [columnName]: raw('?? + ?', [columnName, howMuch]),
-    });
-  }
-
-  decrement(propertyName, howMuch) {
-    const columnName = this.modelClass().propertyNameToColumnName(propertyName);
-
-    return this.patch({
-      [columnName]: raw('?? - ?', [columnName, howMuch]),
-    });
-  }
-
-  findOne(...args) {
-    return this.where.apply(this, args).first();
-  }
-
-  range(...args) {
-    return this.clear(RangeOperation).addOperation(new RangeOperation('range'), args);
-  }
-
-  first(...args) {
-    return this.addOperation(new FirstOperation('first'), args);
-  }
-
-  joinRelated(expression, options) {
-    ensureJoinRelatedOperation(this, 'innerJoin').addCall({
-      expression,
-      options,
-    });
-
-    return this;
-  }
-
-  innerJoinRelated(expression, options) {
-    ensureJoinRelatedOperation(this, 'innerJoin').addCall({
-      expression,
-      options,
-    });
-
-    return this;
-  }
-
-  outerJoinRelated(expression, options) {
-    ensureJoinRelatedOperation(this, 'outerJoin').addCall({
-      expression,
-      options,
-    });
-
-    return this;
-  }
-
-  fullOuterJoinRelated(expression, options) {
-    ensureJoinRelatedOperation(this, 'fullOuterJoin').addCall({
-      expression,
-      options,
-    });
-
-    return this;
-  }
-
-  leftJoinRelated(expression, options) {
-    ensureJoinRelatedOperation(this, 'leftJoin').addCall({
-      expression,
-      options,
-    });
-
-    return this;
-  }
-
-  leftOuterJoinRelated(expression, options) {
-    ensureJoinRelatedOperation(this, 'leftOuterJoin').addCall({
-      expression,
-      options,
-    });
-
-    return this;
-  }
-
-  rightJoinRelated(expression, options) {
-    ensureJoinRelatedOperation(this, 'rightJoin').addCall({
-      expression,
-      options,
-    });
-
-    return this;
-  }
-
-  rightOuterJoinRelated(expression, options) {
-    ensureJoinRelatedOperation(this, 'rightOuterJoin').addCall({
-      expression,
-      options,
-    });
-
-    return this;
-  }
-
-  deleteById(id) {
-    return withWhereScope(this, () => this.findById(id))
-      .delete()
-      .runBefore((_, builder) => {
-        if (!builder.internalOptions().skipUndefined) {
-          assertIdNotUndefined(id, `undefined was passed to deleteById`);
+        if (noSelectStatements && !explicit) {
+            const selectAll = new Selection(this.tableRef(), '*');
+            if (Selection.doesSelect(this, selectAll, selection)) {
+                return selectAll;
+            }
+            else {
+                return null;
+            }
+        }
+        else {
+            return null;
+        }
+    }
+    findAllSelections() {
+        let allSelections = [];
+        this.forEachOperation(true, (op) => {
+            if (op.constructor === SelectOperation) {
+                allSelections = allSelections.concat(op.selections);
+            }
+        });
+        return allSelections;
+    }
+    hasSelection(selection, explicit) {
+        return this.findSelection(selection, explicit) !== null;
+    }
+    hasSelectionAs(selection, alias, explicit) {
+        selection = Selection.create(selection);
+        const foundSelection = this.findSelection(selection, explicit);
+        if (foundSelection === null) {
+            return false;
+        }
+        else {
+            if (foundSelection.column === '*') {
+                // * selects the columns with their column names as aliases.
+                return selection.column === alias;
+            }
+            else {
+                return foundSelection.name === alias;
+            }
         }
-      });
-  }
-
-  findById(...args) {
-    return this.addOperation(new FindByIdOperation('findById'), args).first();
-  }
-
-  findByIds(...args) {
-    return this.addOperation(new FindByIdsOperation('findByIds'), args);
-  }
-
-  runBefore(...args) {
-    return this.addOperation(new RunBeforeOperation('runBefore'), args);
-  }
-
-  onBuild(...args) {
-    return this.addOperation(new OnBuildOperation('onBuild'), args);
-  }
-
-  onBuildKnex(...args) {
-    return this.addOperation(new OnBuildKnexOperation('onBuildKnex'), args);
-  }
-
-  runAfter(...args) {
-    return this.addOperation(new RunAfterOperation('runAfter'), args);
-  }
-
-  onError(...args) {
-    return this.addOperation(new OnErrorOperation('onError'), args);
-  }
-
-  from(...args) {
-    return this.addOperation(new FromOperation('from'), args);
-  }
-
-  updateFrom(...args) {
-    return this.addOperation(new KnexOperation('updateFrom'), args);
-  }
-
-  table(...args) {
-    return this.addOperation(new FromOperation('table'), args);
-  }
-
-  for(relatedQueryFor) {
-    if (arguments.length === 0) {
-      return this._relatedQueryFor;
-    }
-
-    if (this._forError !== null) {
-      // Keep the first error.
-    } else if (!this._isRelatedQuery) {
-      // Without this check `Model.query().for(1).delete()` would delete all rows.
-      this._forError = new Error(
-        'for() can only be used with queries created using the static relatedQuery() method',
-      );
-    } else if (!this.isFind()) {
-      // The owner has already been passed to the write operation.
-      this._forError = new Error(
-        'for() must be called before the write methods ' +
-          '(insert, update, patch, delete, relate, unrelate, increment, decrement)',
-      );
-    }
-
-    this._relatedQueryFor = relatedQueryFor;
-    return this;
-  }
+    }
+    traverse(modelClass, traverser) {
+        if (typeof traverser === 'undefined') {
+            traverser = modelClass;
+            modelClass = null;
+        }
+        return this.runAfter((result) => {
+            this.resultModelClass().traverse(modelClass, result, traverser);
+            return result;
+        });
+    }
+    page(page, pageSize) {
+        return this.range(+page * +pageSize, (+page + 1) * +pageSize - 1);
+    }
+    columnInfo({ table = null } = {}) {
+        table = table || this.tableName();
+        const knex = this.knex();
+        const tableParts = table.split('.');
+        const columnInfoQuery = knex(last(tableParts)).columnInfo();
+        const schema = this.internalOptions().schema;
+        if (schema) {
+            columnInfoQuery.withSchema(schema);
+        }
+        else if (tableParts.length > 1) {
+            columnInfoQuery.withSchema(tableParts[0]);
+        }
+        if (this.internalOptions().debug) {
+            columnInfoQuery.debug();
+        }
+        return columnInfoQuery;
+    }
+    withSchema(schema) {
+        this.internalOptions().schema = schema;
+        this.internalContext().onBuild.push((builder) => {
+            if (!builder.has(/withSchema/)) {
+                // Need to push this operation to the front because knex doesn't use the
+                // schema for operations called before `withSchema`.
+                builder.addOperationToFront(new KnexOperation('withSchema'), [schema]);
+            }
+        });
+        return this;
+    }
+    debug /* istanbul ignore next */() {
+        this.internalOptions().debug = true;
+        this.internalContext().onBuild.push((builder) => {
+            builder.addOperation(new KnexOperation('debug'), []);
+        });
+        return this;
+    }
+    insert(modelsOrObjects) {
+        return writeOperation(this, () => {
+            const insertOperation = this._insertOperationFactory(this);
+            this.addOperation(insertOperation, [modelsOrObjects]);
+        });
+    }
+    insertAndFetch(modelsOrObjects) {
+        return writeOperation(this, () => {
+            const insertOperation = this._insertOperationFactory(this);
+            const insertAndFetchOperation = new InsertAndFetchOperation('insertAndFetch', {
+                delegate: insertOperation,
+            });
+            this.addOperation(insertAndFetchOperation, [modelsOrObjects]);
+        });
+    }
+    insertGraph(modelsOrObjects, opt) {
+        return writeOperation(this, () => {
+            const insertOperation = this._insertOperationFactory(this);
+            const insertGraphOperation = new InsertGraphOperation('insertGraph', {
+                delegate: insertOperation,
+                opt,
+            });
+            this.addOperation(insertGraphOperation, [modelsOrObjects]);
+        });
+    }
+    insertGraphAndFetch(modelsOrObjects, opt) {
+        return writeOperation(this, () => {
+            const insertOperation = this._insertOperationFactory(this);
+            const insertGraphOperation = new InsertGraphOperation('insertGraph', {
+                delegate: insertOperation,
+                opt,
+            });
+            const insertGraphAndFetchOperation = new InsertGraphAndFetchOperation('insertGraphAndFetch', {
+                delegate: insertGraphOperation,
+            });
+            return this.addOperation(insertGraphAndFetchOperation, [modelsOrObjects]);
+        });
+    }
+    update(modelOrObject) {
+        return writeOperation(this, () => {
+            const updateOperation = this._updateOperationFactory(this);
+            this.addOperation(updateOperation, [modelOrObject]);
+        });
+    }
+    updateAndFetch(modelOrObject) {
+        return writeOperation(this, () => {
+            const updateOperation = this._updateOperationFactory(this);
+            if (!(updateOperation.instance instanceof this.modelClass())) {
+                throw new Error('updateAndFetch can only be called for instance operations');
+            }
+            const updateAndFetch = new UpdateAndFetchOperation('updateAndFetch', {
+                delegate: updateOperation,
+            });
+            // patchOperation is an instance update operation that already adds the
+            // required "where id = $" clause.
+            updateAndFetch.skipIdWhere = true;
+            this.addOperation(updateAndFetch, [updateOperation.instance.$id(), modelOrObject]);
+        });
+    }
+    updateAndFetchById(id, modelOrObject) {
+        return writeOperation(this, () => {
+            const updateOperation = this._updateOperationFactory(this);
+            const updateAndFetch = new UpdateAndFetchOperation('updateAndFetch', {
+                delegate: updateOperation,
+            });
+            this.addOperation(updateAndFetch, [id, modelOrObject]);
+        });
+    }
+    upsertGraph(modelsOrObjects, upsertOptions) {
+        return writeOperation(this, () => {
+            const upsertGraphOperation = new UpsertGraphOperation('upsertGraph', {
+                upsertOptions,
+            });
+            this.addOperation(upsertGraphOperation, [modelsOrObjects]);
+        });
+    }
+    upsertGraphAndFetch(modelsOrObjects, upsertOptions) {
+        return writeOperation(this, () => {
+            const upsertGraphOperation = new UpsertGraphOperation('upsertGraph', {
+                upsertOptions,
+            });
+            const upsertGraphAndFetchOperation = new UpsertGraphAndFetchOperation('upsertGraphAndFetch', {
+                delegate: upsertGraphOperation,
+            });
+            return this.addOperation(upsertGraphAndFetchOperation, [modelsOrObjects]);
+        });
+    }
+    patch(modelOrObject) {
+        return writeOperation(this, () => {
+            const patchOperation = this._patchOperationFactory(this);
+            this.addOperation(patchOperation, [modelOrObject]);
+        });
+    }
+    patchAndFetch(modelOrObject) {
+        return writeOperation(this, () => {
+            const patchOperation = this._patchOperationFactory(this);
+            if (!(patchOperation.instance instanceof this.modelClass())) {
+                throw new Error('patchAndFetch can only be called for instance operations');
+            }
+            const patchAndFetch = new UpdateAndFetchOperation('patchAndFetch', {
+                delegate: patchOperation,
+            });
+            // patchOperation is an instance update operation that already adds the
+            // required "where id = $" clause.
+            patchAndFetch.skipIdWhere = true;
+            this.addOperation(patchAndFetch, [patchOperation.instance.$id(), modelOrObject]);
+        });
+    }
+    patchAndFetchById(id, modelOrObject) {
+        return writeOperation(this, () => {
+            const patchOperation = this._patchOperationFactory(this);
+            const patchAndFetch = new UpdateAndFetchOperation('patchAndFetch', {
+                delegate: patchOperation,
+            });
+            this.addOperation(patchAndFetch, [id, modelOrObject]);
+        });
+    }
+    delete(...args) {
+        return writeOperation(this, () => {
+            if (args.length) {
+                throw new Error(`Don't pass arguments to delete(). You should use it like this: delete().where('foo', 'bar').andWhere(...)`);
+            }
+            const deleteOperation = this._deleteOperationFactory(this);
+            this.addOperation(deleteOperation, args);
+        });
+    }
+    del(...args) {
+        return this.delete(...args);
+    }
+    relate(...args) {
+        return writeOperation(this, () => {
+            const relateOperation = this._relateOperationFactory(this);
+            this.addOperation(relateOperation, args);
+        });
+    }
+    unrelate(...args) {
+        return writeOperation(this, () => {
+            if (args.length) {
+                throw new Error(`Don't pass arguments to unrelate(). You should use it like this: unrelate().where('foo', 'bar').andWhere(...)`);
+            }
+            const unrelateOperation = this._unrelateOperationFactory(this);
+            this.addOperation(unrelateOperation, args);
+        });
+    }
+    increment(propertyName, howMuch) {
+        const columnName = this.modelClass().propertyNameToColumnName(propertyName);
+        return this.patch({
+            [columnName]: raw('?? + ?', [columnName, howMuch]),
+        });
+    }
+    decrement(propertyName, howMuch) {
+        const columnName = this.modelClass().propertyNameToColumnName(propertyName);
+        return this.patch({
+            [columnName]: raw('?? - ?', [columnName, howMuch]),
+        });
+    }
+    findOne(...args) {
+        return this.where.apply(this, args).first();
+    }
+    range(...args) {
+        return this.clear(RangeOperation).addOperation(new RangeOperation('range'), args);
+    }
+    first(...args) {
+        return this.addOperation(new FirstOperation('first'), args);
+    }
+    joinRelated(expression, options) {
+        ensureJoinRelatedOperation(this, 'innerJoin').addCall({
+            expression,
+            options,
+        });
+        return this;
+    }
+    innerJoinRelated(expression, options) {
+        ensureJoinRelatedOperation(this, 'innerJoin').addCall({
+            expression,
+            options,
+        });
+        return this;
+    }
+    outerJoinRelated(expression, options) {
+        ensureJoinRelatedOperation(this, 'outerJoin').addCall({
+            expression,
+            options,
+        });
+        return this;
+    }
+    fullOuterJoinRelated(expression, options) {
+        ensureJoinRelatedOperation(this, 'fullOuterJoin').addCall({
+            expression,
+            options,
+        });
+        return this;
+    }
+    leftJoinRelated(expression, options) {
+        ensureJoinRelatedOperation(this, 'leftJoin').addCall({
+            expression,
+            options,
+        });
+        return this;
+    }
+    leftOuterJoinRelated(expression, options) {
+        ensureJoinRelatedOperation(this, 'leftOuterJoin').addCall({
+            expression,
+            options,
+        });
+        return this;
+    }
+    rightJoinRelated(expression, options) {
+        ensureJoinRelatedOperation(this, 'rightJoin').addCall({
+            expression,
+            options,
+        });
+        return this;
+    }
+    rightOuterJoinRelated(expression, options) {
+        ensureJoinRelatedOperation(this, 'rightOuterJoin').addCall({
+            expression,
+            options,
+        });
+        return this;
+    }
+    deleteById(id) {
+        return withWhereScope(this, () => this.findById(id))
+            .delete()
+            .runBefore((_, builder) => {
+            if (!builder.internalOptions().skipUndefined) {
+                assertIdNotUndefined(id, `undefined was passed to deleteById`);
+            }
+        });
+    }
+    findById(...args) {
+        return this.addOperation(new FindByIdOperation('findById'), args).first();
+    }
+    findByIds(...args) {
+        return this.addOperation(new FindByIdsOperation('findByIds'), args);
+    }
+    runBefore(...args) {
+        return this.addOperation(new RunBeforeOperation('runBefore'), args);
+    }
+    onBuild(...args) {
+        return this.addOperation(new OnBuildOperation('onBuild'), args);
+    }
+    onBuildKnex(...args) {
+        return this.addOperation(new OnBuildKnexOperation('onBuildKnex'), args);
+    }
+    runAfter(...args) {
+        return this.addOperation(new RunAfterOperation('runAfter'), args);
+    }
+    onError(...args) {
+        return this.addOperation(new OnErrorOperation('onError'), args);
+    }
+    from(...args) {
+        return this.addOperation(new FromOperation('from'), args);
+    }
+    updateFrom(...args) {
+        return this.addOperation(new KnexOperation('updateFrom'), args);
+    }
+    table(...args) {
+        return this.addOperation(new FromOperation('table'), args);
+    }
+    for(relatedQueryFor) {
+        if (arguments.length === 0) {
+            return this._relatedQueryFor;
+        }
+        if (this._forError !== null) {
+            // Keep the first error.
+        }
+        else if (!this._isRelatedQuery) {
+            // Without this check `Model.query().for(1).delete()` would delete all rows.
+            this._forError = new Error('for() can only be used with queries created using the static relatedQuery() method');
+        }
+        else if (!this.isFind()) {
+            // The owner has already been passed to the write operation.
+            this._forError = new Error('for() must be called before the write methods ' +
+                '(insert, update, patch, delete, relate, unrelate, increment, decrement)');
+        }
+        this._relatedQueryFor = relatedQueryFor;
+        return this;
+    }
 }
-
 Object.defineProperties(QueryBuilder.prototype, {
-  isObjectionQueryBuilder: {
-    enumerable: false,
-    writable: false,
-    value: true,
-  },
+    isObjectionQueryBuilder: {
+        enumerable: false,
+        writable: false,
+        value: true,
+    },
 });
-
+function isWriteOperation(op) {
+    return (op.is(InsertOperation) ||
+        op.is(UpdateOperation) ||
+        op.is(DeleteOperation) ||
+        op.is(RelateOperation) ||
+        op.is(UnrelateOperation));
+}
 function ensureEagerOperation(builder, algorithm = null) {
-  const modelClass = builder.modelClass();
-  const defaultGraphOptions = modelClass.getDefaultGraphOptions();
-  const eagerOp = builder.findOperation(EagerOperation);
-
-  if (algorithm) {
-    const EagerOperationClass = getOperationClassForEagerAlgorithm(builder, algorithm);
-
-    if (eagerOp instanceof EagerOperationClass) {
-      return eagerOp;
-    } else {
-      const newEagerOp = new EagerOperationClass('eager', {
-        defaultGraphOptions,
-      });
-
-      if (eagerOp) {
-        newEagerOp.cloneFrom(eagerOp);
-      }
-
-      builder.clear(EagerOperation);
-      builder.addOperation(newEagerOp);
-
-      return newEagerOp;
-    }
-  } else {
-    if (eagerOp) {
-      return eagerOp;
-    } else {
-      const EagerOperationClass = getOperationClassForEagerAlgorithm(
-        builder,
-        getWhereInEagerAlgorithm(builder),
-      );
-
-      const newEagerOp = new EagerOperationClass('eager', {
-        defaultGraphOptions,
-      });
-
-      builder.addOperation(newEagerOp);
-
-      return newEagerOp;
-    }
-  }
+    const modelClass = builder.modelClass();
+    const defaultGraphOptions = modelClass.getDefaultGraphOptions();
+    const eagerOp = builder.findOperation(EagerOperation);
+    if (algorithm) {
+        const EagerOperationClass = getOperationClassForEagerAlgorithm(builder, algorithm);
+        if (eagerOp instanceof EagerOperationClass) {
+            return eagerOp;
+        }
+        else {
+            const newEagerOp = new EagerOperationClass('eager', {
+                defaultGraphOptions,
+            });
+            if (eagerOp) {
+                newEagerOp.cloneFrom(eagerOp);
+            }
+            builder.clear(EagerOperation);
+            builder.addOperation(newEagerOp);
+            return newEagerOp;
+        }
+    }
+    else {
+        if (eagerOp) {
+            return eagerOp;
+        }
+        else {
+            const EagerOperationClass = getOperationClassForEagerAlgorithm(builder, getWhereInEagerAlgorithm(builder));
+            const newEagerOp = new EagerOperationClass('eager', {
+                defaultGraphOptions,
+            });
+            builder.addOperation(newEagerOp);
+            return newEagerOp;
+        }
+    }
 }
-
 function getWhereInEagerAlgorithm(builder) {
-  return builder.modelClass().WhereInEagerAlgorithm;
+    return builder.modelClass().WhereInEagerAlgorithm;
 }
-
 function getJoinEagerAlgorithm(builder) {
-  return builder.modelClass().JoinEagerAlgorithm;
+    return builder.modelClass().JoinEagerAlgorithm;
 }
-
 function getNaiveEagerAlgorithm(builder) {
-  return builder.modelClass().NaiveEagerAlgorithm;
+    return builder.modelClass().NaiveEagerAlgorithm;
 }
-
 function getOperationClassForEagerAlgorithm(builder, algorithm) {
-  if (algorithm === getJoinEagerAlgorithm(builder)) {
-    return JoinEagerOperation;
-  } else if (algorithm === getNaiveEagerAlgorithm(builder)) {
-    return NaiveEagerOperation;
-  } else {
-    return WhereInEagerOperation;
-  }
+    if (algorithm === getJoinEagerAlgorithm(builder)) {
+        return JoinEagerOperation;
+    }
+    else if (algorithm === getNaiveEagerAlgorithm(builder)) {
+        return NaiveEagerOperation;
+    }
+    else {
+        return WhereInEagerOperation;
+    }
 }
-
 function parseRelationExpression(modelClass, exp) {
-  try {
-    return RelationExpression.create(exp);
-  } catch (err) {
-    if (err instanceof DuplicateRelationError) {
-      throw modelClass.createValidationError({
-        type: ValidationErrorType.RelationExpression,
-        message: `Duplicate relation name "${err.relationName}" in relation expression "${exp}". For example, use "${err.relationName}.[foo, bar]" instead of "[${err.relationName}.foo, ${err.relationName}.bar]".`,
-      });
-    } else {
-      throw modelClass.createValidationError({
-        type: ValidationErrorType.RelationExpression,
-        message: `Invalid relation expression "${exp}"`,
-      });
-    }
-  }
+    try {
+        return RelationExpression.create(exp);
+    }
+    catch (err) {
+        if (err instanceof DuplicateRelationError) {
+            throw modelClass.createValidationError({
+                type: ValidationErrorType.RelationExpression,
+                message: `Duplicate relation name "${err.relationName}" in relation expression "${exp}". For example, use "${err.relationName}.[foo, bar]" instead of "[${err.relationName}.foo, ${err.relationName}.bar]".`,
+            });
+        }
+        else {
+            throw modelClass.createValidationError({
+                type: ValidationErrorType.RelationExpression,
+                message: `Invalid relation expression "${exp}"`,
+            });
+        }
+    }
 }
-
 function checkEager(builder) {
-  const eagerOp = builder.findOperation(EagerOperation);
-
-  if (!eagerOp) {
-    return;
-  }
-
-  const expr = eagerOp.expression;
-  const allowedExpr = builder.allowedGraphExpression();
-
-  if (expr.numChildren > 0 && allowedExpr && !allowedExpr.isSubExpression(expr)) {
-    const modelClass = builder.modelClass();
-
-    builder.reject(
-      modelClass.createValidationError({
-        type: ValidationErrorType.UnallowedRelation,
-        message: 'eager expression not allowed',
-      }),
-    );
-  }
+    const eagerOp = builder.findOperation(EagerOperation);
+    if (!eagerOp) {
+        return;
+    }
+    const expr = eagerOp.expression;
+    const allowedExpr = builder.allowedGraphExpression();
+    if (expr.numChildren > 0 && allowedExpr && !allowedExpr.isSubExpression(expr)) {
+        const modelClass = builder.modelClass();
+        builder.reject(modelClass.createValidationError({
+            type: ValidationErrorType.UnallowedRelation,
+            message: 'eager expression not allowed',
+        }));
+    }
 }
-
 function findQueryExecutorOperation(builder) {
-  return builder.findOperation((op) => op.hasQueryExecutor());
+    return builder.findOperation((op) => op.hasQueryExecutor());
 }
-
 function checkForUsage(builder) {
-  if (builder._forError !== null) {
-    throw builder._forError;
-  }
+    if (builder._forError !== null) {
+        throw builder._forError;
+    }
 }
-
 function beforeExecute(builder) {
-  let promise = Promise.resolve();
-
-  // This needs to be checked before any hooks are called.
-  checkForUsage(builder);
-
-  builder = addImplicitOperations(builder);
-
-  // Resolve all before hooks before building and executing the query
-  // and the rest of the hooks.
-  promise = chainOperationHooks(promise, builder, 'onBefore1');
-  promise = chainOperationHooks(promise, builder, 'onBefore2');
-
-  promise = chainHooks(promise, builder, builder.context().runBefore);
-  promise = chainHooks(promise, builder, builder.internalContext().runBefore);
-
-  promise = chainOperationHooks(promise, builder, 'onBefore3');
-
-  return promise;
+    let promise = Promise.resolve();
+    // This needs to be checked before any hooks are called.
+    checkForUsage(builder);
+    builder = addImplicitOperations(builder);
+    // Resolve all before hooks before building and executing the query
+    // and the rest of the hooks.
+    promise = chainOperationHooks(promise, builder, 'onBefore1');
+    promise = chainOperationHooks(promise, builder, 'onBefore2');
+    promise = chainHooks(promise, builder, builder.context().runBefore);
+    promise = chainHooks(promise, builder, builder.internalContext().runBefore);
+    promise = chainOperationHooks(promise, builder, 'onBefore3');
+    return promise;
 }
-
 function doExecute(builder) {
-  let promise = Promise.resolve();
-
-  builder = callOnBuildHooks(builder);
-  const queryExecutorOperation = findQueryExecutorOperation(builder);
-
-  const explicitRejectValue = builder._explicitRejectValue;
-  const explicitResolveValue = builder._explicitResolveValue;
-
-  if (explicitRejectValue !== null) {
-    promise = Promise.reject(explicitRejectValue);
-  } else if (explicitResolveValue !== null) {
-    promise = Promise.resolve(explicitResolveValue);
-  } else if (queryExecutorOperation !== null) {
-    promise = Promise.resolve(queryExecutorOperation.queryExecutor(builder));
-  } else {
-    promise = Promise.resolve(buildKnexQuery(builder));
-
-    promise = chainOperationHooks(promise, builder, 'onRawResult');
-    promise = promise.then((result) => createModels(result, builder));
-  }
-
-  return promise;
+    let promise = Promise.resolve();
+    builder = callOnBuildHooks(builder);
+    const queryExecutorOperation = findQueryExecutorOperation(builder);
+    const explicitRejectValue = builder._explicitRejectValue;
+    const explicitResolveValue = builder._explicitResolveValue;
+    if (explicitRejectValue !== null) {
+        promise = Promise.reject(explicitRejectValue);
+    }
+    else if (explicitResolveValue !== null) {
+        promise = Promise.resolve(explicitResolveValue);
+    }
+    else if (queryExecutorOperation !== null) {
+        promise = Promise.resolve(queryExecutorOperation.queryExecutor(builder));
+    }
+    else {
+        promise = Promise.resolve(buildKnexQuery(builder));
+        promise = chainOperationHooks(promise, builder, 'onRawResult');
+        promise = promise.then((result) => createModels(result, builder));
+    }
+    return promise;
 }
-
 function afterExecute(builder, result) {
-  let promise = Promise.resolve(result);
-
-  promise = chainOperationHooks(promise, builder, 'onAfter1');
-  promise = chainOperationHooks(promise, builder, 'onAfter2');
-
-  promise = chainHooks(promise, builder, builder.context().runAfter);
-  promise = chainHooks(promise, builder, builder.internalContext().runAfter);
-
-  promise = chainOperationHooks(promise, builder, 'onAfter3');
-
-  return promise;
+    let promise = Promise.resolve(result);
+    promise = chainOperationHooks(promise, builder, 'onAfter1');
+    promise = chainOperationHooks(promise, builder, 'onAfter2');
+    promise = chainHooks(promise, builder, builder.context().runAfter);
+    promise = chainHooks(promise, builder, builder.internalContext().runAfter);
+    promise = chainOperationHooks(promise, builder, 'onAfter3');
+    return promise;
 }
-
 class ReturnImmediatelyException {
-  constructor(value) {
-    this.value = value;
-  }
+    constructor(value) {
+        this.value = value;
+    }
 }
-
 function handleReturnImmediatelyValue(builder) {
-  const { returnImmediatelyValue } = builder.internalOptions();
-  if (returnImmediatelyValue !== undefined) {
-    throw new ReturnImmediatelyException(returnImmediatelyValue);
-  }
+    const { returnImmediatelyValue } = builder.internalOptions();
+    if (returnImmediatelyValue !== undefined) {
+        throw new ReturnImmediatelyException(returnImmediatelyValue);
+    }
 }
-
 function handleExecuteError(builder, err) {
-  if (err instanceof ReturnImmediatelyException) {
-    return Promise.resolve(err.value);
-  }
-
-  let promise = Promise.reject(wrapError(err));
-
-  builder.forEachOperation(true, (op) => {
-    if (op.hasOnError()) {
-      promise = promise.catch((err) =>
-        builder.callAsyncOperationMethod(op, 'onError', [builder, err]),
-      );
-    }
-  });
-
-  return promise;
+    if (err instanceof ReturnImmediatelyException) {
+        return Promise.resolve(err.value);
+    }
+    let promise = Promise.reject(wrapError(err));
+    builder.forEachOperation(true, (op) => {
+        if (op.hasOnError()) {
+            promise = promise.catch((err) => builder.callAsyncOperationMethod(op, 'onError', [builder, err]));
+        }
+    });
+    return promise;
 }
-
 function chainOperationHooks(promise, builder, hookName) {
-  return promise.then((result) => {
-    let promise = Promise.resolve(result);
-
-    builder.forEachOperation(true, (op) => {
-      if (op.hasHook(hookName)) {
-        promise = promise.then((result) => {
-          const res = builder.callAsyncOperationMethod(op, hookName, [builder, result]);
-          handleReturnImmediatelyValue(builder);
-          return res;
+    return promise.then((result) => {
+        let promise = Promise.resolve(result);
+        builder.forEachOperation(true, (op) => {
+            if (op.hasHook(hookName)) {
+                promise = promise.then((result) => {
+                    const res = builder.callAsyncOperationMethod(op, hookName, [builder, result]);
+                    handleReturnImmediatelyValue(builder);
+                    return res;
+                });
+            }
         });
-      }
+        return promise;
     });
-
-    return promise;
-  });
 }
-
 function ensureJoinRelatedOperation(builder, joinOperation) {
-  const opName = joinOperation + 'Relation';
-  let op = builder.findOperation(opName);
-
-  if (!op) {
-    op = new JoinRelatedOperation(opName, { joinOperation });
-    builder.addOperation(op);
-  }
-
-  return op;
+    const opName = joinOperation + 'Relation';
+    let op = builder.findOperation(opName);
+    if (!op) {
+        op = new JoinRelatedOperation(opName, { joinOperation });
+        builder.addOperation(op);
+    }
+    return op;
 }
-
 function prebuildQuery(builder) {
-  checkForUsage(builder);
-
-  builder = addImplicitOperations(builder);
-  builder = callOnBuildHooks(builder);
-
-  const queryExecutorOperation = findQueryExecutorOperation(builder);
-
-  if (queryExecutorOperation) {
-    return prebuildQuery(queryExecutorOperation.queryExecutor(builder));
-  } else {
-    return builder;
-  }
+    checkForUsage(builder);
+    builder = addImplicitOperations(builder);
+    builder = callOnBuildHooks(builder);
+    const queryExecutorOperation = findQueryExecutorOperation(builder);
+    if (queryExecutorOperation) {
+        return prebuildQuery(queryExecutorOperation.queryExecutor(builder));
+    }
+    else {
+        return builder;
+    }
 }
-
 function addImplicitOperations(builder) {
-  if (builder.isFind()) {
-    // If no write operations have been called at this point this query is a
-    // find query and we need to call the custom find implementation.
-    addFindOperation(builder);
-  }
-
-  if (builder.hasWithGraph()) {
-    moveEagerOperationToEnd(builder);
-  }
-
-  return builder;
+    if (builder.isFind()) {
+        // If no write operations have been called at this point this query is a
+        // find query and we need to call the custom find implementation.
+        addFindOperation(builder);
+    }
+    if (builder.hasWithGraph()) {
+        moveEagerOperationToEnd(builder);
+    }
+    return builder;
 }
-
 function addFindOperation(builder) {
-  if (!builder.has(FindOperation)) {
-    const operation = builder._findOperationFactory(builder);
-    builder.addOperationToFront(operation, []);
-  }
+    if (!builder.has(FindOperation)) {
+        const operation = builder._findOperationFactory(builder);
+        builder.addOperationToFront(operation, []);
+    }
 }
-
 function moveEagerOperationToEnd(builder) {
-  const eagerOp = builder.findOperation(EagerOperation);
-
-  builder.clear(EagerOperation);
-  builder.addOperation(eagerOp);
+    const eagerOp = builder.findOperation(EagerOperation);
+    builder.clear(EagerOperation);
+    builder.addOperation(eagerOp);
 }
-
 function callOnBuildHooks(builder) {
-  callOnBuildFuncs(builder, builder.context().onBuild);
-  callOnBuildFuncs(builder, builder.internalContext().onBuild);
-
-  builder.executeOnBuild();
-  return builder;
+    callOnBuildFuncs(builder, builder.context().onBuild);
+    callOnBuildFuncs(builder, builder.internalContext().onBuild);
+    builder.executeOnBuild();
+    return builder;
 }
-
 function callOnBuildFuncs(builder, func) {
-  if (isFunction(func)) {
-    func.call(builder, builder);
-  } else if (Array.isArray(func)) {
-    func.forEach((func) => callOnBuildFuncs(builder, func));
-  }
+    if (isFunction(func)) {
+        func.call(builder, builder);
+    }
+    else if (Array.isArray(func)) {
+        func.forEach((func) => callOnBuildFuncs(builder, func));
+    }
 }
-
 function buildKnexQuery(builder, knexBuilder = builder.knex().queryBuilder()) {
-  knexBuilder = builder.executeOnBuildKnex(knexBuilder);
-
-  const fromOperation = builder.findLastOperation(QueryBuilderBase.FromSelector);
-
-  if (!builder.isPartial()) {
-    // Set the table only if it hasn't been explicitly set yet.
-    if (!fromOperation) {
-      knexBuilder = setDefaultTable(builder, knexBuilder);
-    }
-
-    // Only add `table.*` select if there are no explicit selects
-    // and `from` is a table name and not a subquery.
-    if (!builder.hasSelects() && (!fromOperation || fromOperation.table)) {
-      knexBuilder = setDefaultSelect(builder, knexBuilder);
-    }
-  }
-
-  return knexBuilder;
+    knexBuilder = builder.executeOnBuildKnex(knexBuilder);
+    const fromOperation = builder.findLastOperation(QueryBuilderBase.FromSelector);
+    if (!builder.isPartial()) {
+        // Set the table only if it hasn't been explicitly set yet.
+        if (!fromOperation) {
+            knexBuilder = setDefaultTable(builder, knexBuilder);
+        }
+        // Only add `table.*` select if there are no explicit selects
+        // and `from` is a table name and not a subquery.
+        if (!builder.hasSelects() && (!fromOperation || fromOperation.table)) {
+            knexBuilder = setDefaultSelect(builder, knexBuilder);
+        }
+    }
+    return knexBuilder;
 }
-
 function setDefaultTable(builder, knexBuilder) {
-  const table = builder.tableName();
-  const tableRef = builder.tableRef();
-
-  if (table === tableRef) {
-    return knexBuilder.table(table);
-  } else {
-    return knexBuilder.table(`${table} as ${tableRef}`);
-  }
+    const table = builder.tableName();
+    const tableRef = builder.tableRef();
+    if (table === tableRef) {
+        return knexBuilder.table(table);
+    }
+    else {
+        return knexBuilder.table(`${table} as ${tableRef}`);
+    }
 }
-
 function setDefaultSelect(builder, knexBuilder) {
-  const tableRef = builder.tableRef();
-
-  return knexBuilder.select(`${tableRef}.*`);
+    const tableRef = builder.tableRef();
+    return knexBuilder.select(`${tableRef}.*`);
 }
-
 async function chainHooks(promise, builder, func) {
-  return promise.then((result) => {
-    let promise = Promise.resolve(result);
-
-    if (isFunction(func)) {
-      promise = promise.then((result) => {
-        const res = func.call(builder, result, builder);
-        handleReturnImmediatelyValue(builder);
-        return res;
-      });
-    } else if (Array.isArray(func)) {
-      func.forEach((func) => {
-        promise = chainHooks(promise, builder, func);
-      });
-    }
-
-    return promise;
-  });
+    return promise.then((result) => {
+        let promise = Promise.resolve(result);
+        if (isFunction(func)) {
+            promise = promise.then((result) => {
+                const res = func.call(builder, result, builder);
+                handleReturnImmediatelyValue(builder);
+                return res;
+            });
+        }
+        else if (Array.isArray(func)) {
+            func.forEach((func) => {
+                promise = chainHooks(promise, builder, func);
+            });
+        }
+        return promise;
+    });
 }
-
 function createModels(result, builder) {
-  if (result === null || result === undefined) {
-    return null;
-  }
-
-  if (builder.isInsert()) {
-    // results are applied to input models in `InsertOperation.onAfter1` instead.
+    if (result === null || result === undefined) {
+        return null;
+    }
+    if (builder.isInsert()) {
+        // results are applied to input models in `InsertOperation.onAfter1` instead.
+        return result;
+    }
+    const modelClass = builder.resultModelClass();
+    if (Array.isArray(result)) {
+        if (result.length && shouldBeConvertedToModel(result[0], modelClass)) {
+            for (let i = 0, l = result.length; i < l; ++i) {
+                result[i] = modelClass.fromDatabaseJson(result[i]);
+            }
+        }
+    }
+    else if (shouldBeConvertedToModel(result, modelClass)) {
+        result = modelClass.fromDatabaseJson(result);
+    }
     return result;
-  }
-
-  const modelClass = builder.resultModelClass();
-
-  if (Array.isArray(result)) {
-    if (result.length && shouldBeConvertedToModel(result[0], modelClass)) {
-      for (let i = 0, l = result.length; i < l; ++i) {
-        result[i] = modelClass.fromDatabaseJson(result[i]);
-      }
-    }
-  } else if (shouldBeConvertedToModel(result, modelClass)) {
-    result = modelClass.fromDatabaseJson(result);
-  }
-
-  return result;
 }
-
 function shouldBeConvertedToModel(obj, modelClass) {
-  return isObject(obj) && !(obj instanceof modelClass);
+    return isObject(obj) && !(obj instanceof modelClass);
 }
-
 function writeOperation(builder, cb) {
-  if (!builder.isFind()) {
-    return builder.reject(
-      new Error(
-        'Double call to a write method. ' +
-          'You can only call one of the write methods ' +
-          '(insert, update, patch, delete, relate, unrelate, increment, decrement) ' +
-          'and only once per query builder.',
-      ),
-    );
-  }
-
-  try {
-    cb();
-    return builder;
-  } catch (err) {
-    return builder.reject(err);
-  }
+    if (!builder.isFind()) {
+        return builder.reject(new Error('Double call to a write method. ' +
+            'You can only call one of the write methods ' +
+            '(insert, update, patch, delete, relate, unrelate, increment, decrement) ' +
+            'and only once per query builder.'));
+    }
+    try {
+        cb();
+        return builder;
+    }
+    catch (err) {
+        return builder.reject(err);
+    }
 }
-
 function findOperationFactory() {
-  return new FindOperation('find');
+    return new FindOperation('find');
 }
-
 function insertOperationFactory() {
-  return new InsertOperation('insert');
+    return new InsertOperation('insert');
 }
-
 function updateOperationFactory() {
-  return new UpdateOperation('update');
+    return new UpdateOperation('update');
 }
-
 function patchOperationFactory() {
-  return new UpdateOperation('patch', {
-    modelOptions: { patch: true },
-  });
+    return new UpdateOperation('patch', {
+        modelOptions: { patch: true },
+    });
 }
-
 function relateOperationFactory() {
-  return new RelateOperation('relate', {});
+    return new RelateOperation('relate', {});
 }
-
 function unrelateOperationFactory() {
-  return new UnrelateOperation('unrelate', {});
+    return new UnrelateOperation('unrelate', {});
 }
-
 function deleteOperationFactory() {
-  return new DeleteOperation('delete');
+    return new DeleteOperation('delete');
 }
-
 module.exports = {
-  QueryBuilder,
+    QueryBuilder,
 };