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

package/lib/queryBuilder/StaticHookArguments.js

@@ -0,0 +1,122 @@
+'use strict';
+const { asArray } = require('../utils/objectUtils');
+const BUILDER_SYMBOL = Symbol();
+// The static hooks of `Model`, which do nothing. Queries skip creating the
+// arguments and calling the hook when a model class hasn't overridden it.
+const defaultStaticHooks = new WeakSet();
+function markDefaultStaticHook(hook) {
+    defaultStaticHooks.add(hook);
+}
+function hasStaticHook(modelClass, hookName) {
+    return !defaultStaticHooks.has(modelClass[hookName]);
+}
+class StaticHookArguments {
+    constructor({ builder, result = null }) {
+        // The builder should never be accessed through the arguments.
+        // Hide it as well as possible to discourage people from
+        // digging it out.
+        Object.defineProperty(this, BUILDER_SYMBOL, {
+            value: builder,
+        });
+        Object.defineProperty(this, 'result', {
+            value: asArray(result),
+        });
+    }
+    static create(args) {
+        return new StaticHookArguments(args);
+    }
+    get asFindQuery() {
+        return () => {
+            return this[BUILDER_SYMBOL].toFindQuery().clearWithGraphFetched().runAfter(asArray);
+        };
+    }
+    get context() {
+        return this[BUILDER_SYMBOL].context();
+    }
+    get transaction() {
+        return this[BUILDER_SYMBOL].unsafeKnex();
+    }
+    get relation() {
+        const op = this[BUILDER_SYMBOL].findOperation(hasRelation);
+        if (op) {
+            return getRelation(op);
+        }
+        else {
+            return undefined;
+        }
+    }
+    get modelOptions() {
+        const op = this[BUILDER_SYMBOL].findOperation(hasModelOptions);
+        if (op) {
+            return getModelOptions(op);
+        }
+        else {
+            return undefined;
+        }
+    }
+    get items() {
+        const op = this[BUILDER_SYMBOL].findOperation(hasItems);
+        if (op) {
+            return asArray(getItems(op));
+        }
+        else {
+            return [];
+        }
+    }
+    get inputItems() {
+        const op = this[BUILDER_SYMBOL].findOperation(hasInputItems);
+        if (op) {
+            return asArray(getInputItems(op));
+        }
+        else {
+            return [];
+        }
+    }
+    get cancelQuery() {
+        const args = this;
+        return (cancelValue) => {
+            const builder = this[BUILDER_SYMBOL];
+            if (cancelValue === undefined) {
+                if (builder.isInsert()) {
+                    cancelValue = args.inputItems;
+                }
+                else if (builder.isFind()) {
+                    cancelValue = [];
+                }
+                else {
+                    cancelValue = 0;
+                }
+            }
+            builder.resolve(cancelValue);
+        };
+    }
+}
+function getRelation(op) {
+    return op.relation;
+}
+function hasRelation(op) {
+    return !!getRelation(op);
+}
+function getModelOptions(op) {
+    return op.modelOptions;
+}
+function hasModelOptions(op) {
+    return !!getModelOptions(op);
+}
+function getItems(op) {
+    return op.instance || (op.owner && op.owner.isModels && op.owner.modelArray);
+}
+function hasItems(op) {
+    return !!getItems(op);
+}
+function getInputItems(op) {
+    return op.models || op.model;
+}
+function hasInputItems(op) {
+    return !!getInputItems(op);
+}
+module.exports = {
+    StaticHookArguments,
+    markDefaultStaticHook,
+    hasStaticHook,
+};

package/lib/queryBuilder/ValueBuilder.js

@@ -0,0 +1,115 @@
+'use strict';
+const { asArray, isObject } = require('../utils/objectUtils');
+const { buildArg } = require('../utils/buildUtils');
+const { isMySql } = require('../utils/knexUtils');
+const { toMySqlCastType, isBooleanType, toJsonSql } = require('../utils/mysqlJsonPath');
+const { addExpressionMethods } = require('./expressions');
+class ValueBuilder {
+    constructor(value) {
+        this._value = value;
+        this._cast = null;
+        // Cast objects and arrays to json by default.
+        this._toJson = isObject(value);
+        this._toArray = false;
+        this._alias = null;
+    }
+    get cast() {
+        return this._cast;
+    }
+    castText() {
+        return this.castTo('text');
+    }
+    castInt() {
+        return this.castTo('integer');
+    }
+    castBigInt() {
+        return this.castTo('bigint');
+    }
+    castFloat() {
+        return this.castTo('float');
+    }
+    castDecimal() {
+        return this.castTo('decimal');
+    }
+    castReal() {
+        return this.castTo('real');
+    }
+    castBool() {
+        return this.castTo('boolean');
+    }
+    castJson() {
+        this._toArray = false;
+        this._toJson = true;
+        this._cast = 'jsonb';
+        return this;
+    }
+    castTo(sqlType) {
+        this._cast = sqlType;
+        return this;
+    }
+    asArray() {
+        this._toJson = false;
+        this._toArray = true;
+        return this;
+    }
+    as(alias) {
+        this._alias = alias;
+        return this;
+    }
+    toKnexRaw(builder) {
+        return builder.knex().raw(...this._createRawArgs(builder));
+    }
+    _createRawArgs(builder) {
+        let sql = null;
+        const bindings = [];
+        if (this._toJson) {
+            bindings.push(JSON.stringify(this._value));
+            sql = '?';
+        }
+        else if (this._toArray) {
+            const values = asArray(this._value);
+            bindings.push(...values.map((it) => buildArg(it, builder)));
+            sql = `ARRAY[${values.map(() => '?').join(', ')}]`;
+        }
+        else {
+            bindings.push(this._value);
+            sql = '?';
+        }
+        const knex = builder.unsafeKnex();
+        const mysql = isMySql(knex);
+        if (this._toJson && !this._cast && mysql) {
+            // MySQL compares strings and JSON values as strings, so `{}` is never
+            // equal to a JSON column without the cast. Postgres casts it implicitly.
+            sql = toJsonSql(sql, knex);
+        }
+        else if (this._cast && mysql) {
+            const type = toMySqlCastType(this._cast);
+            // MySQL can't cast to a boolean.
+            if (isBooleanType(this._cast)) {
+                sql = `(${sql} <> 0)`;
+            }
+            else if (type === 'JSON') {
+                sql = toJsonSql(sql, knex);
+            }
+            else {
+                sql = `CAST(${sql} AS ${type})`;
+            }
+        }
+        else if (this._cast) {
+            sql = `CAST(${sql} AS ${this._cast})`;
+        }
+        if (this._alias) {
+            bindings.push(this._alias);
+            sql = `${sql} as ??`;
+        }
+        return [sql, bindings];
+    }
+}
+addExpressionMethods(ValueBuilder.prototype);
+function val(val) {
+    return new ValueBuilder(val);
+}
+module.exports = {
+    ValueBuilder,
+    val,
+};

package/lib/queryBuilder/expressions.js

@@ -0,0 +1,121 @@
+'use strict';
+const { isObject } = require('../utils/objectUtils');
+// Comparison, logic and arithmetic methods for `ref()`, `val()`, `fn()` and
+// `raw()`, so that expressions can be written without raw sql:
+//
+//   Person.ref('age').gte(18).as('isAdult')
+//   Pet.ref('order').plus(1)
+//   Person.ref('firstName').isNotBlank().or(Person.ref('lastName').isNotBlank())
+//
+// Every method returns a new `FunctionBuilder`. The sql is wrapped in parentheses,
+// so expressions can be nested without thinking about operator precedence. The
+// arguments are bindings like the arguments of `fn()`: strings are values and
+// columns are passed with `ref()` or `Model.ref()`.
+const COMPARISONS = {
+    eq: '=',
+    ne: '<>',
+    gt: '>',
+    gte: '>=',
+    lt: '<',
+    lte: '<=',
+};
+const ARITHMETIC = {
+    plus: '+',
+    minus: '-',
+    times: '*',
+    div: '/',
+};
+const methods = {
+    // `eq(null)` and `ne(null)` are `IS NULL` and `IS NOT NULL`, like `where(col, null)`.
+    eq(value) {
+        return value === null ? this.isNull() : expression('(? = ?)', [this, value]);
+    },
+    ne(value) {
+        return value === null ? this.isNotNull() : expression('(? <> ?)', [this, value]);
+    },
+    in(values) {
+        return createIn(this, values, 'IN');
+    },
+    notIn(values) {
+        return createIn(this, values, 'NOT IN');
+    },
+    like(pattern) {
+        return expression('(? LIKE ?)', [this, pattern]);
+    },
+    between(min, max) {
+        return expression('(? BETWEEN ? AND ?)', [this, min, max]);
+    },
+    isNull() {
+        return expression('(? IS NULL)', [this]);
+    },
+    isNotNull() {
+        return expression('(? IS NOT NULL)', [this]);
+    },
+    // NULL, an empty string or a string of only spaces.
+    isBlank() {
+        return expression("(COALESCE(TRIM(?), '') = '')", [this]);
+    },
+    isNotBlank() {
+        return expression("(COALESCE(TRIM(?), '') <> '')", [this]);
+    },
+    and(...conditions) {
+        return createLogic(this, conditions, 'AND');
+    },
+    or(...conditions) {
+        return createLogic(this, conditions, 'OR');
+    },
+    not() {
+        return expression('(NOT ?)', [this]);
+    },
+};
+for (const [name, operator] of Object.entries(COMPARISONS)) {
+    if (!methods[name]) {
+        methods[name] = function (value) {
+            return expression(`(? ${operator} ?)`, [this, value]);
+        };
+    }
+}
+for (const [name, operator] of Object.entries(ARITHMETIC)) {
+    methods[name] = function (value) {
+        return expression(`(? ${operator} ?)`, [this, value]);
+    };
+}
+function createIn(left, values, operator) {
+    if (isSubquery(values)) {
+        return expression(`(? ${operator} ?)`, [left, values]);
+    }
+    if (!Array.isArray(values)) {
+        throw new Error(`${operator.toLowerCase()}() takes an array or a subquery.`);
+    }
+    if (values.length === 0) {
+        // Like knex's `whereIn(col, [])`.
+        return expression(operator === 'IN' ? '(1 = 0)' : '(1 = 1)', []);
+    }
+    return expression(`(? ${operator} (${values.map(() => '?').join(', ')}))`, [left, ...values]);
+}
+function createLogic(first, rest, operator) {
+    const conditions = [first, ...rest];
+    return expression(`(${conditions.map(() => '?').join(` ${operator} `)})`, conditions);
+}
+function isSubquery(value) {
+    return (isObject(value) && (value.isObjectionQueryBuilderBase || typeof value.toSQL === 'function'));
+}
+function expression(sql, args) {
+    // Required here because `FunctionBuilder` itself gets these methods.
+    const { FunctionBuilder } = require('./FunctionBuilder');
+    return new FunctionBuilder(sql, args);
+}
+function addExpressionMethods(prototype) {
+    for (const [name, method] of Object.entries(methods)) {
+        Object.defineProperty(prototype, name, {
+            configurable: true,
+            enumerable: false,
+            writable: true,
+            value: method,
+        });
+    }
+}
+module.exports = {
+    addExpressionMethods,
+    expression,
+};