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

package/lib/queryBuilder/QueryBuilderBase.js

@@ -0,0 +1,666 @@
+'use strict';
+const { QueryBuilderOperationSupport } = require('./QueryBuilderOperationSupport');
+const { isSqlite, isMsSql } = require('../utils/knexUtils');
+const { KnexOperation } = require('./operations/KnexOperation');
+const HavingSelector = /^(having|orHaving|andHaving)/;
+const GroupBySelector = /^groupBy/;
+const { expression } = require('./expressions');
+const { MergeOperation } = require('./operations/MergeOperation');
+const { SelectOperation } = require('./operations/select/SelectOperation');
+const { ReturningOperation } = require('./operations/ReturningOperation');
+const { WhereCompositeOperation } = require('./operations/WhereCompositeOperation');
+const { WhereJsonOperation } = require('./operations/jsonApi/WhereJsonOperation');
+const { WhereJsonOverlapsOperation } = require('./operations/jsonApi/WhereJsonOverlapsOperation');
+const { WhereInCompositeOperation, } = require('./operations/whereInComposite/WhereInCompositeOperation');
+const { WhereInCompositeSqliteOperation, } = require('./operations/whereInComposite/WhereInCompositeSqliteOperation');
+const { WhereInCompositeMsSqlOperation, } = require('./operations/whereInComposite/WhereInCompositeMsSqlOperation');
+const { WhereJsonHasOperation } = require('./operations/jsonApi/WhereJsonHasOperation');
+const { WhereJsonNotObjectOperation } = require('./operations/jsonApi/WhereJsonNotObjectOperation');
+class QueryBuilderBase extends QueryBuilderOperationSupport {
+    modify(...args) {
+        const func = args[0];
+        if (!func) {
+            return this;
+        }
+        if (args.length === 1) {
+            func.call(this, this);
+        }
+        else {
+            args[0] = this;
+            func(...args);
+        }
+        return this;
+    }
+    transacting(trx) {
+        this._context.knex = trx || null;
+        return this;
+    }
+    select(...args) {
+        return this.addOperation(new SelectOperation('select'), args);
+    }
+    insert(...args) {
+        return this.addOperation(new KnexOperation('insert'), args);
+    }
+    update(...args) {
+        return this.addOperation(new KnexOperation('update'), args);
+    }
+    delete(...args) {
+        return this.addOperation(new KnexOperation('delete'), args);
+    }
+    del(...args) {
+        return this.delete(...args);
+    }
+    forUpdate(...args) {
+        return this.addOperation(new KnexOperation('forUpdate'), args);
+    }
+    forShare(...args) {
+        return this.addOperation(new KnexOperation('forShare'), args);
+    }
+    forNoKeyUpdate(...args) {
+        return this.addOperation(new KnexOperation('forNoKeyUpdate'), args);
+    }
+    forKeyShare(...args) {
+        return this.addOperation(new KnexOperation('forKeyShare'), args);
+    }
+    skipLocked(...args) {
+        return this.addOperation(new KnexOperation('skipLocked'), args);
+    }
+    noWait(...args) {
+        return this.addOperation(new KnexOperation('noWait'), args);
+    }
+    as(...args) {
+        return this.addOperation(new KnexOperation('as'), args);
+    }
+    columns(...args) {
+        return this.addOperation(new SelectOperation('columns'), args);
+    }
+    column(...args) {
+        return this.addOperation(new SelectOperation('column'), args);
+    }
+    from(...args) {
+        return this.addOperation(new KnexOperation('from'), args);
+    }
+    fromJS(...args) {
+        return this.addOperation(new KnexOperation('fromJS'), args);
+    }
+    fromRaw(...args) {
+        return this.addOperation(new KnexOperation('fromRaw'), args);
+    }
+    into(...args) {
+        return this.addOperation(new KnexOperation('into'), args);
+    }
+    withSchema(...args) {
+        return this.addOperation(new KnexOperation('withSchema'), args);
+    }
+    table(...args) {
+        return this.addOperation(new KnexOperation('table'), args);
+    }
+    distinct(...args) {
+        return this.addOperation(new SelectOperation('distinct'), args);
+    }
+    distinctOn(...args) {
+        return this.addOperation(new SelectOperation('distinctOn'), args);
+    }
+    join(...args) {
+        return this.addOperation(new KnexOperation('join'), args);
+    }
+    joinRaw(...args) {
+        return this.addOperation(new KnexOperation('joinRaw'), args);
+    }
+    innerJoin(...args) {
+        return this.addOperation(new KnexOperation('innerJoin'), args);
+    }
+    leftJoin(...args) {
+        return this.addOperation(new KnexOperation('leftJoin'), args);
+    }
+    leftOuterJoin(...args) {
+        return this.addOperation(new KnexOperation('leftOuterJoin'), args);
+    }
+    rightJoin(...args) {
+        return this.addOperation(new KnexOperation('rightJoin'), args);
+    }
+    rightOuterJoin(...args) {
+        return this.addOperation(new KnexOperation('rightOuterJoin'), args);
+    }
+    outerJoin(...args) {
+        return this.addOperation(new KnexOperation('outerJoin'), args);
+    }
+    fullOuterJoin(...args) {
+        return this.addOperation(new KnexOperation('fullOuterJoin'), args);
+    }
+    crossJoin(...args) {
+        return this.addOperation(new KnexOperation('crossJoin'), args);
+    }
+    where(...args) {
+        return this.addOperation(new KnexOperation('where'), args);
+    }
+    andWhere(...args) {
+        return this.addOperation(new KnexOperation('andWhere'), args);
+    }
+    orWhere(...args) {
+        return this.addOperation(new KnexOperation('orWhere'), args);
+    }
+    whereNot(...args) {
+        return this.addOperation(new KnexOperation('whereNot'), args);
+    }
+    andWhereNot(...args) {
+        return this.addOperation(new KnexOperation('andWhereNot'), args);
+    }
+    orWhereNot(...args) {
+        return this.addOperation(new KnexOperation('orWhereNot'), args);
+    }
+    // Makes the query match no rows.
+    none() {
+        return this.where(expression('(1 = 0)', []));
+    }
+    whereRaw(...args) {
+        return this.addOperation(new KnexOperation('whereRaw'), args);
+    }
+    andWhereRaw(...args) {
+        return this.addOperation(new KnexOperation('andWhereRaw'), args);
+    }
+    orWhereRaw(...args) {
+        return this.addOperation(new KnexOperation('orWhereRaw'), args);
+    }
+    whereWrapped(...args) {
+        return this.addOperation(new KnexOperation('whereWrapped'), args);
+    }
+    havingWrapped(...args) {
+        return this.addOperation(new KnexOperation('havingWrapped'), args);
+    }
+    whereExists(...args) {
+        return this.addOperation(new KnexOperation('whereExists'), args);
+    }
+    orWhereExists(...args) {
+        return this.addOperation(new KnexOperation('orWhereExists'), args);
+    }
+    whereNotExists(...args) {
+        return this.addOperation(new KnexOperation('whereNotExists'), args);
+    }
+    orWhereNotExists(...args) {
+        return this.addOperation(new KnexOperation('orWhereNotExists'), args);
+    }
+    whereIn(...args) {
+        return this.addOperation(new KnexOperation('whereIn'), args);
+    }
+    orWhereIn(...args) {
+        return this.addOperation(new KnexOperation('orWhereIn'), args);
+    }
+    whereNotIn(...args) {
+        return this.addOperation(new KnexOperation('whereNotIn'), args);
+    }
+    orWhereNotIn(...args) {
+        return this.addOperation(new KnexOperation('orWhereNotIn'), args);
+    }
+    whereNull(...args) {
+        return this.addOperation(new KnexOperation('whereNull'), args);
+    }
+    orWhereNull(...args) {
+        return this.addOperation(new KnexOperation('orWhereNull'), args);
+    }
+    whereNotNull(...args) {
+        return this.addOperation(new KnexOperation('whereNotNull'), args);
+    }
+    orWhereNotNull(...args) {
+        return this.addOperation(new KnexOperation('orWhereNotNull'), args);
+    }
+    whereBetween(...args) {
+        return this.addOperation(new KnexOperation('whereBetween'), args);
+    }
+    andWhereBetween(...args) {
+        return this.addOperation(new KnexOperation('andWhereBetween'), args);
+    }
+    whereNotBetween(...args) {
+        return this.addOperation(new KnexOperation('whereNotBetween'), args);
+    }
+    andWhereNotBetween(...args) {
+        return this.addOperation(new KnexOperation('andWhereNotBetween'), args);
+    }
+    orWhereBetween(...args) {
+        return this.addOperation(new KnexOperation('orWhereBetween'), args);
+    }
+    orWhereNotBetween(...args) {
+        return this.addOperation(new KnexOperation('orWhereNotBetween'), args);
+    }
+    whereLike(...args) {
+        return this.addOperation(new KnexOperation('whereLike'), args);
+    }
+    andWhereLike(...args) {
+        return this.addOperation(new KnexOperation('andWhereLike'), args);
+    }
+    orWhereLike(...args) {
+        return this.addOperation(new KnexOperation('orWhereLike'), args);
+    }
+    whereILike(...args) {
+        return this.addOperation(new KnexOperation('whereILike'), args);
+    }
+    andWhereILike(...args) {
+        return this.addOperation(new KnexOperation('andWhereILike'), args);
+    }
+    orWhereILike(...args) {
+        return this.addOperation(new KnexOperation('orWhereILike'), args);
+    }
+    groupBy(...args) {
+        return this.addOperation(new KnexOperation('groupBy'), args);
+    }
+    groupByRaw(...args) {
+        return this.addOperation(new KnexOperation('groupByRaw'), args);
+    }
+    orderBy(...args) {
+        return this.addOperation(new KnexOperation('orderBy'), args);
+    }
+    orderByRaw(...args) {
+        return this.addOperation(new KnexOperation('orderByRaw'), args);
+    }
+    union(...args) {
+        return this.addOperation(new KnexOperation('union'), args);
+    }
+    unionAll(...args) {
+        return this.addOperation(new KnexOperation('unionAll'), args);
+    }
+    intersect(...args) {
+        return this.addOperation(new KnexOperation('intersect'), args);
+    }
+    except(...args) {
+        return this.addOperation(new KnexOperation('except'), args);
+    }
+    having(...args) {
+        return this.addOperation(new KnexOperation('having'), args);
+    }
+    // Like clearSelect() and clearWhere(), these remove the operations, so that
+    // has() and copyFrom() see the query as it is.
+    clearHaving() {
+        return this.clear(HavingSelector);
+    }
+    clearGroup() {
+        return this.clear(GroupBySelector);
+    }
+    orHaving(...args) {
+        return this.addOperation(new KnexOperation('orHaving'), args);
+    }
+    havingIn(...args) {
+        return this.addOperation(new KnexOperation('havingIn'), args);
+    }
+    orHavingIn(...args) {
+        return this.addOperation(new KnexOperation('orHavingIn'), args);
+    }
+    havingNotIn(...args) {
+        return this.addOperation(new KnexOperation('havingNotIn'), args);
+    }
+    orHavingNotIn(...args) {
+        return this.addOperation(new KnexOperation('orHavingNotIn'), args);
+    }
+    havingNull(...args) {
+        return this.addOperation(new KnexOperation('havingNull'), args);
+    }
+    orHavingNull(...args) {
+        return this.addOperation(new KnexOperation('orHavingNull'), args);
+    }
+    havingNotNull(...args) {
+        return this.addOperation(new KnexOperation('havingNotNull'), args);
+    }
+    orHavingNotNull(...args) {
+        return this.addOperation(new KnexOperation('orHavingNotNull'), args);
+    }
+    havingExists(...args) {
+        return this.addOperation(new KnexOperation('havingExists'), args);
+    }
+    orHavingExists(...args) {
+        return this.addOperation(new KnexOperation('orHavingExists'), args);
+    }
+    havingNotExists(...args) {
+        return this.addOperation(new KnexOperation('havingNotExists'), args);
+    }
+    orHavingNotExists(...args) {
+        return this.addOperation(new KnexOperation('orHavingNotExists'), args);
+    }
+    havingBetween(...args) {
+        return this.addOperation(new KnexOperation('havingBetween'), args);
+    }
+    orHavingBetween(...args) {
+        return this.addOperation(new KnexOperation('orHavingBetween'), args);
+    }
+    havingNotBetween(...args) {
+        return this.addOperation(new KnexOperation('havingNotBetween'), args);
+    }
+    orHavingNotBetween(...args) {
+        return this.addOperation(new KnexOperation('orHavingNotBetween'), args);
+    }
+    andHaving(...args) {
+        return this.addOperation(new KnexOperation('andHaving'), args);
+    }
+    andHavingIn(...args) {
+        return this.addOperation(new KnexOperation('andHavingIn'), args);
+    }
+    andHavingNotIn(...args) {
+        return this.addOperation(new KnexOperation('andHavingNotIn'), args);
+    }
+    andHavingNull(...args) {
+        return this.addOperation(new KnexOperation('andHavingNull'), args);
+    }
+    andHavingNotNull(...args) {
+        return this.addOperation(new KnexOperation('andHavingNotNull'), args);
+    }
+    andHavingExists(...args) {
+        return this.addOperation(new KnexOperation('andHavingExists'), args);
+    }
+    andHavingNotExists(...args) {
+        return this.addOperation(new KnexOperation('andHavingNotExists'), args);
+    }
+    andHavingBetween(...args) {
+        return this.addOperation(new KnexOperation('andHavingBetween'), args);
+    }
+    andHavingNotBetween(...args) {
+        return this.addOperation(new KnexOperation('andHavingNotBetween'), args);
+    }
+    comment(...args) {
+        return this.addOperation(new KnexOperation('comment'), args);
+    }
+    hintComment(...args) {
+        return this.addOperation(new KnexOperation('hintComment'), args);
+    }
+    using(...args) {
+        return this.addOperation(new KnexOperation('using'), args);
+    }
+    havingRaw(...args) {
+        return this.addOperation(new KnexOperation('havingRaw'), args);
+    }
+    orHavingRaw(...args) {
+        return this.addOperation(new KnexOperation('orHavingRaw'), args);
+    }
+    offset(...args) {
+        return this.addOperation(new KnexOperation('offset'), args);
+    }
+    limit(...args) {
+        return this.addOperation(new KnexOperation('limit'), args);
+    }
+    count(...args) {
+        return this.addOperation(new SelectOperation('count'), args);
+    }
+    countDistinct(...args) {
+        return this.addOperation(new SelectOperation('countDistinct'), args);
+    }
+    min(...args) {
+        return this.addOperation(new SelectOperation('min'), args);
+    }
+    max(...args) {
+        return this.addOperation(new SelectOperation('max'), args);
+    }
+    sum(...args) {
+        return this.addOperation(new SelectOperation('sum'), args);
+    }
+    sumDistinct(...args) {
+        return this.addOperation(new SelectOperation('sumDistinct'), args);
+    }
+    avg(...args) {
+        return this.addOperation(new SelectOperation('avg'), args);
+    }
+    avgDistinct(...args) {
+        return this.addOperation(new SelectOperation('avgDistinct'), args);
+    }
+    debug(...args) {
+        return this.addOperation(new KnexOperation('debug'), args);
+    }
+    returning(...args) {
+        return this.addOperation(new ReturningOperation('returning'), args);
+    }
+    truncate(...args) {
+        return this.addOperation(new KnexOperation('truncate'), args);
+    }
+    connection(...args) {
+        return this.addOperation(new KnexOperation('connection'), args);
+    }
+    options(...args) {
+        return this.addOperation(new KnexOperation('options'), args);
+    }
+    columnInfo(...args) {
+        return this.addOperation(new KnexOperation('columnInfo'), args);
+    }
+    off(...args) {
+        return this.addOperation(new KnexOperation('off'), args);
+    }
+    timeout(...args) {
+        return this.addOperation(new KnexOperation('timeout'), args);
+    }
+    with(...args) {
+        return this.addOperation(new KnexOperation('with'), args);
+    }
+    withWrapped(...args) {
+        return this.addOperation(new KnexOperation('withWrapped'), args);
+    }
+    withRecursive(...args) {
+        return this.addOperation(new KnexOperation('withRecursive'), args);
+    }
+    withMaterialized(...args) {
+        return this.addOperation(new KnexOperation('withMaterialized'), args);
+    }
+    withNotMaterialized(...args) {
+        return this.addOperation(new KnexOperation('withNotMaterialized'), args);
+    }
+    whereComposite(...args) {
+        return this.addOperation(new WhereCompositeOperation('whereComposite'), args);
+    }
+    whereInComposite(...args) {
+        let operation = null;
+        if (isSqlite(this.knex())) {
+            operation = new WhereInCompositeSqliteOperation('whereInComposite');
+        }
+        else if (isMsSql(this.knex())) {
+            operation = new WhereInCompositeMsSqlOperation('whereInComposite');
+        }
+        else {
+            operation = new WhereInCompositeOperation('whereInComposite');
+        }
+        return this.addOperation(operation, args);
+    }
+    whereNotInComposite(...args) {
+        let operation = null;
+        if (isSqlite(this.knex())) {
+            operation = new WhereInCompositeSqliteOperation('whereNotInComposite', { prefix: 'not' });
+        }
+        else if (isMsSql(this.knex())) {
+            operation = new WhereInCompositeMsSqlOperation('whereNotInComposite', { prefix: 'not' });
+        }
+        else {
+            operation = new WhereInCompositeOperation('whereNotInComposite', { prefix: 'not' });
+        }
+        return this.addOperation(operation, args);
+    }
+    jsonExtract(...args) {
+        return this.addOperation(new KnexOperation('jsonExtract'), args);
+    }
+    jsonSet(...args) {
+        return this.addOperation(new KnexOperation('jsonSet'), args);
+    }
+    jsonInsert(...args) {
+        return this.addOperation(new KnexOperation('jsonInsert'), args);
+    }
+    jsonRemove(...args) {
+        return this.addOperation(new KnexOperation('jsonRemove'), args);
+    }
+    whereJsonObject(...args) {
+        return this.addOperation(new KnexOperation('whereJsonObject'), args);
+    }
+    orWhereJsonObject(...args) {
+        return this.addOperation(new KnexOperation('orWhereJsonObject'), args);
+    }
+    andWhereJsonObject(...args) {
+        return this.addOperation(new KnexOperation('andWhereJsonObject'), args);
+    }
+    whereNotJsonObject(...args) {
+        return this.addOperation(new KnexOperation('whereNotJsonObject'), args);
+    }
+    orWhereNotJsonObject(...args) {
+        return this.addOperation(new KnexOperation('orWhereNotJsonObject'), args);
+    }
+    andWhereNotJsonObject(...args) {
+        return this.addOperation(new KnexOperation('andWhereNotJsonObject'), args);
+    }
+    whereJsonPath(...args) {
+        return this.addOperation(new KnexOperation('whereJsonPath'), args);
+    }
+    orWhereJsonPath(...args) {
+        return this.addOperation(new KnexOperation('orWhereJsonPath'), args);
+    }
+    andWhereJsonPath(...args) {
+        return this.addOperation(new KnexOperation('andWhereJsonPath'), args);
+    }
+    // whereJson(Not)SupersetOf / whereJson(Not)SubsetOf are now supported by knex >= 1.0, but for now
+    // objection handles them differently and only for postgres.
+    // Changing them to utilize knex methods directly may require a major version bump and upgrade guide.
+    whereJsonSupersetOf(...args) {
+        return this.addOperation(new WhereJsonOperation('whereJsonSupersetOf', { operator: '@>', bool: 'and' }), args);
+    }
+    andWhereJsonSupersetOf(...args) {
+        return this.whereJsonSupersetOf(...args);
+    }
+    orWhereJsonSupersetOf(...args) {
+        return this.addOperation(new WhereJsonOperation('orWhereJsonSupersetOf', { operator: '@>', bool: 'or' }), args);
+    }
+    whereJsonNotSupersetOf(...args) {
+        return this.addOperation(new WhereJsonOperation('whereJsonNotSupersetOf', {
+            operator: '@>',
+            bool: 'and',
+            prefix: 'not',
+        }), args);
+    }
+    andWhereJsonNotSupersetOf(...args) {
+        return this.whereJsonNotSupersetOf(...args);
+    }
+    orWhereJsonNotSupersetOf(...args) {
+        return this.addOperation(new WhereJsonOperation('orWhereJsonNotSupersetOf', {
+            operator: '@>',
+            bool: 'or',
+            prefix: 'not',
+        }), args);
+    }
+    whereJsonSubsetOf(...args) {
+        return this.addOperation(new WhereJsonOperation('whereJsonSubsetOf', { operator: '<@', bool: 'and' }), args);
+    }
+    andWhereJsonSubsetOf(...args) {
+        return this.whereJsonSubsetOf(...args);
+    }
+    orWhereJsonSubsetOf(...args) {
+        return this.addOperation(new WhereJsonOperation('orWhereJsonSubsetOf', { operator: '<@', bool: 'or' }), args);
+    }
+    whereJsonNotSubsetOf(...args) {
+        return this.addOperation(new WhereJsonOperation('whereJsonNotSubsetOf', {
+            operator: '<@',
+            bool: 'and',
+            prefix: 'not',
+        }), args);
+    }
+    andWhereJsonNotSubsetOf(...args) {
+        return this.whereJsonNotSubsetOf(...args);
+    }
+    orWhereJsonNotSubsetOf(...args) {
+        return this.addOperation(new WhereJsonOperation('orWhereJsonNotSubsetOf', {
+            operator: '<@',
+            bool: 'or',
+            prefix: 'not',
+        }), args);
+    }
+    whereJsonNotArray(...args) {
+        return this.addOperation(new WhereJsonNotObjectOperation('whereJsonNotArray', {
+            bool: 'and',
+            compareValue: [],
+        }), args);
+    }
+    orWhereJsonNotArray(...args) {
+        return this.addOperation(new WhereJsonNotObjectOperation('orWhereJsonNotArray', {
+            bool: 'or',
+            compareValue: [],
+        }), args);
+    }
+    whereJsonNotObject(...args) {
+        return this.addOperation(new WhereJsonNotObjectOperation('whereJsonNotObject', {
+            bool: 'and',
+            compareValue: {},
+        }), args);
+    }
+    orWhereJsonNotObject(...args) {
+        return this.addOperation(new WhereJsonNotObjectOperation('orWhereJsonNotObject', {
+            bool: 'or',
+            compareValue: {},
+        }), args);
+    }
+    whereJsonHasAny(...args) {
+        return this.addOperation(new WhereJsonHasOperation('whereJsonHasAny', { bool: 'and', operator: '?|' }), args);
+    }
+    orWhereJsonHasAny(...args) {
+        return this.addOperation(new WhereJsonHasOperation('orWhereJsonHasAny', { bool: 'or', operator: '?|' }), args);
+    }
+    whereJsonHasAll(...args) {
+        return this.addOperation(new WhereJsonHasOperation('whereJsonHasAll', { bool: 'and', operator: '?&' }), args);
+    }
+    orWhereJsonHasAll(...args) {
+        return this.addOperation(new WhereJsonHasOperation('orWhereJsonHasAll', { bool: 'or', operator: '?&' }), args);
+    }
+    whereJsonOverlaps(...args) {
+        return this.addOperation(new WhereJsonOverlapsOperation('whereJsonOverlaps', { bool: 'and' }), args);
+    }
+    andWhereJsonOverlaps(...args) {
+        return this.whereJsonOverlaps(...args);
+    }
+    orWhereJsonOverlaps(...args) {
+        return this.addOperation(new WhereJsonOverlapsOperation('orWhereJsonOverlaps', { bool: 'or' }), args);
+    }
+    whereJsonNotOverlaps(...args) {
+        return this.addOperation(new WhereJsonOverlapsOperation('whereJsonNotOverlaps', { bool: 'and', prefix: 'not' }), args);
+    }
+    andWhereJsonNotOverlaps(...args) {
+        return this.whereJsonNotOverlaps(...args);
+    }
+    orWhereJsonNotOverlaps(...args) {
+        return this.addOperation(new WhereJsonOverlapsOperation('orWhereJsonNotOverlaps', { bool: 'or', prefix: 'not' }), args);
+    }
+    whereJsonIsArray(fieldExpression) {
+        return this.whereJsonSupersetOf(fieldExpression, []);
+    }
+    orWhereJsonIsArray(fieldExpression) {
+        return this.orWhereJsonSupersetOf(fieldExpression, []);
+    }
+    whereJsonIsObject(fieldExpression) {
+        return this.whereJsonSupersetOf(fieldExpression, {});
+    }
+    orWhereJsonIsObject(fieldExpression) {
+        return this.orWhereJsonSupersetOf(fieldExpression, {});
+    }
+    whereColumn(...args) {
+        return this.addOperation(new KnexOperation('whereColumn'), args);
+    }
+    andWhereColumn(...args) {
+        return this.addOperation(new KnexOperation('andWhereColumn'), args);
+    }
+    orWhereColumn(...args) {
+        return this.addOperation(new KnexOperation('orWhereColumn'), args);
+    }
+    whereNotColumn(...args) {
+        return this.addOperation(new KnexOperation('whereNotColumn'), args);
+    }
+    andWhereNotColumn(...args) {
+        return this.addOperation(new KnexOperation('andWhereNotColumn'), args);
+    }
+    orWhereNotColumn(...args) {
+        return this.addOperation(new KnexOperation('orWhereNotColumn'), args);
+    }
+    onConflict(...args) {
+        return this.addOperation(new KnexOperation('onConflict'), args);
+    }
+    ignore(...args) {
+        return this.addOperation(new KnexOperation('ignore'), args);
+    }
+    merge(...args) {
+        return this.addOperation(new MergeOperation('merge'), args);
+    }
+}
+Object.defineProperties(QueryBuilderBase.prototype, {
+    isObjectionQueryBuilderBase: {
+        enumerable: false,
+        writable: false,
+        value: true,
+    },
+});
+module.exports = {
+    QueryBuilderBase,
+};

package/lib/queryBuilder/QueryBuilderContext.js

@@ -0,0 +1,20 @@
+'use strict';
+const { QueryBuilderContextBase } = require('./QueryBuilderContextBase');
+class QueryBuilderContext extends QueryBuilderContextBase {
+    constructor(builder) {
+        super(builder);
+        this.runBefore = [];
+        this.runAfter = [];
+        this.onBuild = [];
+    }
+    clone() {
+        const ctx = super.clone();
+        ctx.runBefore = this.runBefore.slice();
+        ctx.runAfter = this.runAfter.slice();
+        ctx.onBuild = this.onBuild.slice();
+        return ctx;
+    }
+}
+module.exports = {
+    QueryBuilderContext,
+};