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

package/lib/queryBuilder/StaticHookArguments.js

@@ -1,134 +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;
+    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 modelOptions() {
-    const op = this[BUILDER_SYMBOL].findOperation(hasModelOptions);
-
-    if (op) {
-      return getModelOptions(op);
-    } else {
-      return undefined;
+    get context() {
+        return this[BUILDER_SYMBOL].context();
     }
-  }
-
-  get items() {
-    const op = this[BUILDER_SYMBOL].findOperation(hasItems);
-
-    if (op) {
-      return asArray(getItems(op));
-    } else {
-      return [];
+    get transaction() {
+        return this[BUILDER_SYMBOL].unsafeKnex();
     }
-  }
-
-  get inputItems() {
-    const op = this[BUILDER_SYMBOL].findOperation(hasInputItems);
-
-    if (op) {
-      return asArray(getInputItems(op));
-    } else {
-      return [];
+    get relation() {
+        const op = this[BUILDER_SYMBOL].findOperation(hasRelation);
+        if (op) {
+            return getRelation(op);
+        }
+        else {
+            return undefined;
+        }
     }
-  }
-
-  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;
+    get modelOptions() {
+        const op = this[BUILDER_SYMBOL].findOperation(hasModelOptions);
+        if (op) {
+            return getModelOptions(op);
         }
-      }
-
-      builder.resolve(cancelValue);
-    };
-  }
+        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;
+    return op.relation;
 }
-
 function hasRelation(op) {
-  return !!getRelation(op);
+    return !!getRelation(op);
 }
-
 function getModelOptions(op) {
-  return op.modelOptions;
+    return op.modelOptions;
 }
-
 function hasModelOptions(op) {
-  return !!getModelOptions(op);
+    return !!getModelOptions(op);
 }
-
 function getItems(op) {
-  return op.instance || (op.owner && op.owner.isModels && op.owner.modelArray);
+    return op.instance || (op.owner && op.owner.isModels && op.owner.modelArray);
 }
-
 function hasItems(op) {
-  return !!getItems(op);
+    return !!getItems(op);
 }
-
 function getInputItems(op) {
-  return op.models || op.model;
+    return op.models || op.model;
 }
-
 function hasInputItems(op) {
-  return !!getInputItems(op);
+    return !!getInputItems(op);
 }
-
 module.exports = {
-  StaticHookArguments,
+    StaticHookArguments,
+    markDefaultStaticHook,
+    hasStaticHook,
 };

package/lib/queryBuilder/ValueBuilder.js

@@ -1,127 +1,115 @@
 'use strict';
-
 const { asArray, isObject } = require('../utils/objectUtils');
 const { buildArg } = require('../utils/buildUtils');
 const { isMySql } = require('../utils/knexUtils');
-const { toMySqlCastType, isBooleanType } = require('../utils/mysqlJsonPath');
+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;
-    let 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 = '?';
+    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;
     }
-
-    const mysql = isMySql(builder.unsafeKnex());
-
-    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 = `CAST(${sql} AS JSON)`;
-    } else if (this._cast && mysql) {
-      // MySQL can't cast to a boolean.
-      sql = isBooleanType(this._cast)
-        ? `(${sql} <> 0)`
-        : `CAST(${sql} AS ${toMySqlCastType(this._cast)})`;
-    } else if (this._cast) {
-      sql = `CAST(${sql} AS ${this._cast})`;
+    get cast() {
+        return this._cast;
     }
-
-    if (this._alias) {
-      bindings.push(this._alias);
-      sql = `${sql} as ??`;
+    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];
     }
-
-    return [sql, bindings];
-  }
 }
-
 addExpressionMethods(ValueBuilder.prototype);
-
 function val(val) {
-  return new ValueBuilder(val);
+    return new ValueBuilder(val);
 }
-
 module.exports = {
-  ValueBuilder,
-  val,
+    ValueBuilder,
+    val,
 };

package/lib/queryBuilder/expressions.js

@@ -1,7 +1,5 @@
 '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:
 //
@@ -13,139 +11,111 @@ const { isObject } = require('../utils/objectUtils');
 // 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: '<=',
+    eq: '=',
+    ne: '<>',
+    gt: '>',
+    gte: '>=',
+    lt: '<',
+    lte: '<=',
 };
-
 const ARITHMETIC = {
-  plus: '+',
-  minus: '-',
-  times: '*',
-  div: '/',
+    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]);
-  },
+    // `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]);
-    };
-  }
+    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]);
-  };
+    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]);
+    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);
+    const conditions = [first, ...rest];
+    return expression(`(${conditions.map(() => '?').join(` ${operator} `)})`, conditions);
 }
-
 function isSubquery(value) {
-  return (
-    isObject(value) && (value.isObjectionQueryBuilderBase || typeof value.toSQL === 'function')
-  );
+    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);
+    // 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,
-    });
-  }
+    for (const [name, method] of Object.entries(methods)) {
+        Object.defineProperty(prototype, name, {
+            configurable: true,
+            enumerable: false,
+            writable: true,
+            value: method,
+        });
+    }
 }
-
 module.exports = {
-  addExpressionMethods,
-  expression,
+    addExpressionMethods,
+    expression,
 };