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

package/lib/queryBuilder/QueryBuilderContextBase.js

@@ -0,0 +1,26 @@
+'use strict';
+const { InternalOptions } = require('./InternalOptions');
+class QueryBuilderContextBase {
+    constructor(builder) {
+        this.userContext = builder ? new builder.constructor.QueryBuilderUserContext(builder) : null;
+        this.options = builder ? new this.constructor.InternalOptions() : null;
+        this.knex = null;
+        this.aliasMap = null;
+        this.tableMap = null;
+    }
+    static get InternalOptions() {
+        return InternalOptions;
+    }
+    clone() {
+        const ctx = new this.constructor();
+        ctx.userContext = this.userContext;
+        ctx.options = this.options.clone();
+        ctx.knex = this.knex;
+        ctx.aliasMap = this.aliasMap;
+        ctx.tableMap = this.tableMap;
+        return ctx;
+    }
+}
+module.exports = {
+    QueryBuilderContextBase,
+};

package/lib/queryBuilder/QueryBuilderOperationSupport.js

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

package/lib/queryBuilder/QueryBuilderUserContext.js

@@ -0,0 +1,25 @@
+'use strict';
+const SYMBOL_BUILDER = Symbol();
+class QueryBuilderUserContext {
+    constructor(builder) {
+        // This should never ever be accessed outside this class. We only
+        // store it so that we can access builder.knex() lazily.
+        this[SYMBOL_BUILDER] = builder;
+    }
+    get transaction() {
+        return this[SYMBOL_BUILDER].knex();
+    }
+    newFromObject(builder, obj) {
+        const ctx = new this.constructor(builder);
+        Object.assign(ctx, obj);
+        return ctx;
+    }
+    newMerge(builder, obj) {
+        const ctx = new this.constructor(builder);
+        Object.assign(ctx, this, obj);
+        return ctx;
+    }
+}
+module.exports = {
+    QueryBuilderUserContext,
+};

package/lib/queryBuilder/RawBuilder.js

@@ -0,0 +1,78 @@
+'use strict';
+const { isPlainObject } = require('../utils/objectUtils');
+const { buildArg } = require('../utils/buildUtils');
+const { addExpressionMethods } = require('./expressions');
+class RawBuilder {
+    constructor(sql, args) {
+        this._sql = `${sql}`;
+        this._args = args;
+        this._as = null;
+    }
+    get alias() {
+        return this._as;
+    }
+    as(as) {
+        this._as = as;
+        return this;
+    }
+    toKnexRaw(builder) {
+        let args = null;
+        let sql = this._sql;
+        if (this._args.length === 1 && isPlainObject(this._args[0])) {
+            args = buildObject(this._args[0], builder);
+            if (this._as) {
+                args.__alias__ = this._as;
+                sql += ' as :__alias__:';
+            }
+        }
+        else {
+            args = buildArray(this._args, builder);
+            if (this._as) {
+                args.push(this._as);
+                sql += ' as ??';
+            }
+        }
+        return builder.knex().raw(sql, args);
+    }
+}
+Object.defineProperties(RawBuilder.prototype, {
+    isObjectionRawBuilder: {
+        enumerable: false,
+        writable: false,
+        value: true,
+    },
+});
+addExpressionMethods(RawBuilder.prototype);
+function buildArray(arr, builder) {
+    return arr.map((it) => buildArg(it, builder));
+}
+function buildObject(obj, builder) {
+    return Object.keys(obj).reduce((args, key) => {
+        args[key] = buildArg(obj[key], builder);
+        return args;
+    }, {});
+}
+function normalizeRawArgs(argsIn) {
+    const [sql, ...restArgs] = argsIn;
+    if (restArgs.length === 1 && Array.isArray(restArgs[0])) {
+        return {
+            sql,
+            args: restArgs[0],
+        };
+    }
+    else {
+        return {
+            sql,
+            args: restArgs,
+        };
+    }
+}
+function raw(...argsIn) {
+    const { sql, args } = normalizeRawArgs(argsIn);
+    return new RawBuilder(sql, args);
+}
+module.exports = {
+    RawBuilder,
+    normalizeRawArgs,
+    raw,
+};