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

package/lib/model/modelValidate.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const { clone } = require('./modelClone');
+
+function validate(model, json, options = {}) {
+  json = json || model;
+
+  const inputJson = json;
+  const validatingModelInstance = inputJson && inputJson.$isObjectionModel;
+
+  if (options.skipValidation) {
+    return json;
+  }
+
+  if (validatingModelInstance) {
+    // Strip away relations and other internal stuff.
+    // TODO 1: This should use `json.$toJson()` since we always validate the input representation!
+    // TODO 2: This should also keep the relations in the object because some validators may
+    //         depend on the relations.
+    json = clone(json, true, true);
+    // We can mutate `json` now that we took a copy of it.
+    options = Object.assign({}, options, { mutable: true });
+  }
+
+  const modelClass = model.constructor;
+  const validator = modelClass.getValidator();
+  const args = {
+    options,
+    model,
+    json,
+    ctx: Object.create(null),
+  };
+
+  validator.beforeValidate(args);
+  json = validator.validate(args);
+  validator.afterValidate(args);
+
+  if (validatingModelInstance) {
+    // If we cloned `json`, we need to copy the possible default values.
+    return inputJson.$set(json);
+  } else {
+    return json;
+  }
+}
+
+module.exports = {
+  validate,
+};

package/lib/model/modelValues.js

@@ -0,0 +1,126 @@
+'use strict';
+
+const { isObject } = require('../utils/objectUtils');
+
+// Property keys needs to be prefixed with a non-numeric character so that
+// they are not considered indexes when used as object keys.
+const PROP_KEY_PREFIX = 'k_';
+
+function values(model, args) {
+  switch (args.length) {
+    case 1:
+      return values1(model, args);
+    case 2:
+      return values2(model, args);
+    case 3:
+      return values3(model, args);
+    default:
+      return valuesN(model, args);
+  }
+}
+
+function propKey(model, props) {
+  switch (props.length) {
+    case 1:
+      return propKey1(model, props);
+    case 2:
+      return propKey2(model, props);
+    case 3:
+      return propKey3(model, props);
+    default:
+      return propKeyN(model, props);
+  }
+}
+
+function hasProps(model, props) {
+  for (let i = 0; i < props.length; ++i) {
+    const value = model[props[i]];
+
+    if (isNullOrUndefined(value)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function values1(model, args) {
+  return [model[args[0]]];
+}
+
+function values2(model, args) {
+  return [model[args[0]], model[args[1]]];
+}
+
+function values3(model, args) {
+  return [model[args[0]], model[args[1]], model[args[2]]];
+}
+
+function valuesN(model, args) {
+  const ret = new Array(args.length);
+
+  for (let i = 0, l = args.length; i < l; ++i) {
+    ret[i] = model[args[i]];
+  }
+
+  return ret;
+}
+
+function propKey1(model, props) {
+  return PROP_KEY_PREFIX + propToStr(model[props[0]]);
+}
+
+function propKey2(model, props) {
+  return PROP_KEY_PREFIX + propToStr(model[props[0]]) + ',' + propToStr(model[props[1]]);
+}
+
+function propKey3(model, props) {
+  return (
+    PROP_KEY_PREFIX +
+    propToStr(model[props[0]]) +
+    ',' +
+    propToStr(model[props[1]]) +
+    ',' +
+    propToStr(model[props[2]])
+  );
+}
+
+function propKeyN(model, props) {
+  let key = PROP_KEY_PREFIX;
+
+  for (let i = 0, l = props.length; i < l; ++i) {
+    key += propToStr(model[props[i]]);
+
+    if (i < l - 1) {
+      key += ',';
+    }
+  }
+
+  return key;
+}
+
+function propToStr(value) {
+  if (value === null) {
+    return 'null';
+  } else if (value === undefined) {
+    return 'undefined';
+  } else if (Buffer.isBuffer(value)) {
+    return value.toString('hex');
+  } else if (isObject(value)) {
+    return JSON.stringify(value);
+  } else {
+    return `${value}`;
+  }
+}
+
+function isNullOrUndefined(val) {
+  return val === null || val === undefined;
+}
+
+module.exports = {
+  PROP_KEY_PREFIX,
+  propToStr,
+  values,
+  hasProps,
+  propKey,
+};

package/lib/model/modelVisitor.js

@@ -0,0 +1,41 @@
+'use strict';
+
+function visitModels(models, modelClass, visitor) {
+  doVisit(models, modelClass, null, null, visitor);
+}
+
+function doVisit(models, modelClass, parent, rel, visitor) {
+  if (Array.isArray(models)) {
+    visitMany(models, modelClass, parent, rel, visitor);
+  } else if (models) {
+    visitOne(models, modelClass, parent, rel, visitor);
+  }
+}
+
+function visitMany(models, modelClass, parent, rel, visitor) {
+  for (let i = 0, l = models.length; i < l; ++i) {
+    visitOne(models[i], modelClass, parent, rel, visitor);
+  }
+}
+
+function visitOne(model, modelClass, parent, rel, visitor) {
+  if (model) {
+    visitor(model, modelClass, parent, rel);
+  }
+
+  const relationNames = modelClass.getRelationNames();
+
+  for (let i = 0, l = relationNames.length; i < l; ++i) {
+    const relationName = relationNames[i];
+    const relatedObj = model[relationName];
+
+    if (relatedObj) {
+      const relation = modelClass.getRelation(relationName);
+      doVisit(relatedObj, relation.relatedModelClass, model, relation, visitor);
+    }
+  }
+}
+
+module.exports = {
+  visitModels,
+};

package/lib/objection.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const {
+  DBError,
+  UniqueViolationError,
+  NotNullViolationError,
+  ForeignKeyViolationError,
+  ConstraintViolationError,
+  CheckViolationError,
+  DataError,
+} = require('db-errors');
+const { Model: NativeModel } = require('./model/Model');
+const { QueryBuilder: NativeQueryBuilder } = require('./queryBuilder/QueryBuilder');
+const { QueryBuilderBase } = require('./queryBuilder/QueryBuilderBase');
+const { QueryBuilderOperation } = require('./queryBuilder/operations/QueryBuilderOperation');
+const { RelationExpression } = require('./queryBuilder/RelationExpression');
+const { ValidationError } = require('./model/ValidationError');
+const { NotFoundError } = require('./model/NotFoundError');
+const { AjvValidator: NativeAjvValidator } = require('./model/AjvValidator');
+const { Validator: NativeValidator } = require('./model/Validator');
+const { Relation } = require('./relations/Relation');
+const { HasOneRelation } = require('./relations/hasOne/HasOneRelation');
+const { HasManyRelation } = require('./relations/hasMany/HasManyRelation');
+const { BelongsToOneRelation } = require('./relations/belongsToOne/BelongsToOneRelation');
+const { HasOneThroughRelation } = require('./relations/hasOneThrough/HasOneThroughRelation');
+const { ManyToManyRelation } = require('./relations/manyToMany/ManyToManyRelation');
+const { transaction } = require('./transaction');
+const { initialize } = require('./initialize');
+
+const {
+  snakeCaseMappers,
+  knexSnakeCaseMappers,
+  knexIdentifierMapping,
+} = require('./utils/identifierMapping');
+const { compose, mixin } = require('./utils/mixin');
+const { ref } = require('./queryBuilder/ReferenceBuilder');
+const { val } = require('./queryBuilder/ValueBuilder');
+const { raw } = require('./queryBuilder/RawBuilder');
+const { fn } = require('./queryBuilder/FunctionBuilder');
+const { inherit } = require('../lib/utils/classUtils');
+
+// We need to wrap the classes, that people can inherit, with ES5 classes
+// so that babel is able to use ES5 inheritance. sigh... Maybe people
+// should stop transpiling node apps to ES5 in the year 2019? Node 6
+// with full class support was released three years ago.
+
+function Model() {
+  // Nothing to do here.
+}
+
+function QueryBuilder(...args) {
+  NativeQueryBuilder.init(this, ...args);
+}
+
+function Validator(...args) {
+  NativeValidator.init(this, ...args);
+}
+
+function AjvValidator(...args) {
+  NativeAjvValidator.init(this, ...args);
+}
+
+// Returns the relation mappings as is. This only exists for typescript: it
+// preserves the exact types of the mappings (like the names of `extra`
+// columns) so that the relation types can be inferred from them.
+function defineRelations(relationMappings) {
+  return relationMappings;
+}
+
+inherit(Model, NativeModel);
+inherit(QueryBuilder, NativeQueryBuilder);
+inherit(Validator, NativeValidator);
+inherit(AjvValidator, NativeAjvValidator);
+
+Model.QueryBuilder = QueryBuilder;
+
+module.exports = {
+  Model,
+  QueryBuilder,
+  QueryBuilderBase,
+  QueryBuilderOperation,
+  RelationExpression,
+  ValidationError,
+  NotFoundError,
+  AjvValidator,
+  Validator,
+  Relation,
+  HasOneRelation,
+  HasManyRelation,
+  BelongsToOneRelation,
+  HasOneThroughRelation,
+  ManyToManyRelation,
+
+  transaction,
+  initialize,
+  compose,
+  mixin,
+  defineRelations,
+  ref,
+  val,
+  raw,
+  fn,
+  snakeCaseMappers,
+  knexSnakeCaseMappers,
+  knexIdentifierMapping,
+
+  DBError,
+  UniqueViolationError,
+  NotNullViolationError,
+  ForeignKeyViolationError,
+  ConstraintViolationError,
+  CheckViolationError,
+  DataError,
+};

package/lib/queryBuilder/FunctionBuilder.js

@@ -0,0 +1,339 @@
+'use strict';
+
+const { RawBuilder, normalizeRawArgs } = require('./RawBuilder');
+const { ref } = require('./ReferenceBuilder');
+const { expression } = require('./expressions');
+const { asArray, asSingle, isNumber, isObject, isPlainObject } = require('../utils/objectUtils');
+const { getDialect, isMySql } = require('../utils/knexUtils');
+const { FUNCTIONS, buildOrderBy } = require('./functions/mysql');
+
+class FunctionBuilder extends RawBuilder {
+  constructor(sql, args) {
+    super(sql, args);
+    // The name of the `fn` helper of a MySQL only function.
+    this._mysqlFunction = null;
+    // For aggregate functions, the number of the first `?`s that are aggregated,
+    // or '*' for `COUNT(*)`.
+    this._aggregated = null;
+    // The name of the `fn` helper of a window function.
+    this._windowFunction = null;
+    this._filters = [];
+    this._over = null;
+  }
+
+  // Only aggregates the rows that match `condition`:
+  //
+  //   fn.count().filter(Pet.ref('species').eq('dog'))
+  //
+  // is `COUNT(CASE WHEN species = 'dog' THEN 1 END)`. That works on every
+  // database, unlike `FILTER (WHERE ...)`.
+  filter(condition) {
+    if (this._aggregated === null) {
+      throw new Error(
+        'filter() only works with the aggregate functions of fn, like fn.count() and fn.sum().',
+      );
+    }
+
+    this._filters.push(condition);
+    return this;
+  }
+
+  // `fn.rowNumber().over({ partitionBy: 'ownerId', orderBy: ['createdAt', 'desc'] })`.
+  over(window = {}) {
+    for (const key of Object.keys(window)) {
+      if (key !== 'partitionBy' && key !== 'orderBy') {
+        throw new Error(`over(): unknown option "${key}". Use partitionBy and orderBy.`);
+      }
+    }
+
+    this._over = window;
+    return this;
+  }
+
+  toKnexRaw(builder) {
+    const knex = builder.unsafeKnex();
+
+    if (this._mysqlFunction && knex && !isMySql(knex)) {
+      throw new Error(
+        `fn.${this._mysqlFunction}() is a MySQL function and can't be used with ${getDialect(knex)}.`,
+      );
+    }
+
+    if (this._windowFunction && !this._over) {
+      throw new Error(`fn.${this._windowFunction}() is a window function and needs over().`);
+    }
+
+    if (this._filters.length === 0 && !this._over) {
+      return super.toKnexRaw(builder);
+    }
+
+    return new RawBuilder(...this._buildFilterAndOver()).as(this._as).toKnexRaw(builder);
+  }
+
+  _buildFilterAndOver() {
+    let sql = this._sql;
+    let args = this._args;
+
+    if (this._filters.length !== 0) {
+      const condition =
+        this._filters.length === 1
+          ? this._filters[0]
+          : expression(`(${this._filters.map(() => '?').join(' AND ')})`, this._filters);
+
+      if (this._aggregated === '*') {
+        sql = sql.replace('*', 'CASE WHEN ? THEN 1 END');
+        args = [condition];
+      } else {
+        const filtered = [];
+        let i = 0;
+
+        sql = sql.replace(/\?/g, () => {
+          const arg = args[i++];
+
+          if (i <= this._aggregated) {
+            filtered.push(condition, arg);
+            return 'CASE WHEN ? THEN ? END';
+          } else {
+            filtered.push(arg);
+            return '?';
+          }
+        });
+
+        args = filtered;
+      }
+    }
+
+    if (this._over) {
+      const [overSql, overArgs] = buildOver(this._over);
+      sql = `${sql} OVER (${overSql})`;
+      args = [...args, ...overArgs];
+    }
+
+    return [sql, args];
+  }
+}
+
+// `fn.case()` is `CASE WHEN condition THEN result ... END` and `fn.case(value)` is
+// `CASE value WHEN other THEN result ... END`.
+class CaseBuilder extends FunctionBuilder {
+  constructor(hasValue, value) {
+    super('', []);
+    this._hasValue = hasValue;
+    this._value = value;
+    this._whens = [];
+    this._hasElse = false;
+    this._else = null;
+  }
+
+  when(condition, result) {
+    this._whens.push([condition, result]);
+    return this;
+  }
+
+  else(result) {
+    this._hasElse = true;
+    this._else = result;
+    return this;
+  }
+
+  toKnexRaw(builder) {
+    if (this._whens.length === 0) {
+      throw new Error('fn.case() needs at least one when().');
+    }
+
+    const args = this._hasValue ? [this._value] : [];
+    let sql = this._hasValue ? '(CASE ?' : '(CASE';
+
+    for (const [condition, result] of this._whens) {
+      sql += ' WHEN ? THEN ?';
+      args.push(condition, result);
+    }
+
+    if (this._hasElse) {
+      sql += ' ELSE ?';
+      args.push(this._else);
+    }
+
+    this._sql = `${sql} END)`;
+    this._args = args;
+
+    return super.toKnexRaw(builder);
+  }
+}
+
+// The value an upsert tried to insert: `VALUES(col)` on MySQL, `excluded.col` on
+// postgres and SQLite.
+class ExcludedBuilder extends FunctionBuilder {
+  constructor(column) {
+    super('', []);
+
+    if (isObject(column) && column.isObjectionReferenceBuilder) {
+      column = column.column;
+    }
+
+    if (typeof column !== 'string') {
+      throw new Error('fn.excluded() takes a column name.');
+    }
+
+    this._column = column;
+  }
+
+  toKnexRaw(builder) {
+    if (isMySql(builder.unsafeKnex())) {
+      this._sql = 'VALUES(??)';
+      this._args = [this._column];
+    } else {
+      this._sql = '??';
+      this._args = [`excluded.${this._column}`];
+    }
+
+    return super.toKnexRaw(builder);
+  }
+}
+
+function buildOver({ partitionBy, orderBy }) {
+  const parts = [];
+  const args = [];
+
+  if (partitionBy !== undefined) {
+    const columns = asArray(partitionBy).map((it) => (typeof it === 'string' ? ref(it) : it));
+    parts.push(`PARTITION BY ${columns.map(() => '?').join(', ')}`);
+    args.push(...columns);
+  }
+
+  if (orderBy !== undefined) {
+    const [orderBySql, orderByArgs] = buildOrderBy('over()', orderBy);
+    parts.push(`ORDER BY ${orderBySql}`);
+    args.push(...orderByArgs);
+  }
+
+  return [parts.join(' '), args];
+}
+
+function fn(...argsIn) {
+  const { sql, args } = normalizeRawArgs(argsIn);
+  return new FunctionBuilder(`${sql}(${args.map(() => '?').join(', ')})`, args);
+}
+
+for (const func of ['coalesce', 'concat', 'upper', 'lower']) {
+  fn[func] = (...args) => fn(func.toUpperCase(), args);
+}
+
+for (const func of ['sum', 'avg', 'min', 'max']) {
+  fn[func] = (...args) => aggregate(fn(func.toUpperCase(), args), args.length);
+}
+
+// `fn.count()` and `fn.count('*')` are `COUNT(*)`.
+fn.count = (...args) => {
+  if (args.length === 0 || (args.length === 1 && args[0] === '*')) {
+    return aggregate(new FunctionBuilder('COUNT(*)', []), '*');
+  }
+
+  return aggregate(fn('COUNT', args), args.length);
+};
+
+fn.now = (precision) => {
+  precision = parseInt(asSingle(precision), 10);
+
+  if (isNaN(precision) || !isNumber(precision)) {
+    precision = 6;
+  }
+
+  // We need to use a literal precision instead of a binding here
+  // for the CURRENT_TIMESTAMP to work. This is okay here since we
+  // make sure `precision` is a number. There's no chance of SQL
+  // injection here.
+  return new FunctionBuilder(`CURRENT_TIMESTAMP(${precision})`, []);
+};
+
+fn.case = (...args) => new CaseBuilder(args.length !== 0, args[0]);
+
+fn.exists = (subquery) => {
+  if (!isObject(subquery) || !subquery.isObjectionQueryBuilderBase) {
+    throw new Error('fn.exists() takes a query.');
+  }
+
+  return new FunctionBuilder('(EXISTS ?)', [subquery]);
+};
+
+fn.excluded = (column) => new ExcludedBuilder(column);
+
+for (const [name, sql, , , options = {}] of FUNCTIONS) {
+  // `defineProperty` since `fn.length` is a read-only property of functions.
+  Object.defineProperty(fn, name, {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    value: createMySqlFunction(name, sql, options),
+  });
+}
+
+function createMySqlFunction(name, sql, options) {
+  return (...args) => {
+    const [text, values] = options.build
+      ? options.build(name, sql, args)
+      : [`${sql}(${args.map(() => '?').join(', ')})`, args];
+
+    const builder = createWithJsonArgs(text, values, options.json);
+
+    if (!options.portable) {
+      builder._mysqlFunction = name;
+    }
+
+    if (options.window) {
+      builder._windowFunction = name;
+    }
+
+    if (options.aggregate) {
+      aggregate(builder, options.aggregate === true ? args.length : options.aggregate(args));
+    }
+
+    return builder;
+  };
+}
+
+function aggregate(builder, aggregated) {
+  builder._aggregated = aggregated;
+  return builder;
+}
+
+// Objects and arrays passed as JSON documents are cast to JSON. Without the cast
+// MySQL would get a string (or knex would expand an array into a list).
+function createWithJsonArgs(text, values, json) {
+  const casts = values.map((value, i) => isJsonArg(json, i) && isJsonValue(value));
+  let i = 0;
+
+  text = text.replace(/\?/g, () => (casts[i++] ? 'CAST(? AS JSON)' : '?'));
+  values = values.map((value, i) => (casts[i] ? JSON.stringify(value) : value));
+
+  return new FunctionBuilder(text, values);
+}
+
+function isJsonArg(json, i) {
+  if (json === 'all') {
+    return true;
+  } else if (json === 'even') {
+    return i % 2 === 0;
+  } else if (json === 'odd') {
+    return i % 2 === 1;
+  } else {
+    return Array.isArray(json) && json.includes(i);
+  }
+}
+
+function isJsonValue(value) {
+  return Array.isArray(value) || isPlainObject(value);
+}
+
+Object.defineProperties(FunctionBuilder.prototype, {
+  isObjectionFunctionBuilder: {
+    enumerable: false,
+    writable: false,
+    value: true,
+  },
+});
+
+module.exports = {
+  FunctionBuilder,
+  fn,
+};

package/lib/queryBuilder/InternalOptions.js

@@ -0,0 +1,29 @@
+'use strict';
+
+class InternalOptions {
+  constructor() {
+    this.skipUndefined = false;
+    this.keepImplicitJoinProps = false;
+    this.returnImmediatelyValue = undefined;
+    this.isInternalQuery = false;
+    this.debug = false;
+    this.schema = undefined;
+  }
+
+  clone() {
+    const copy = new this.constructor();
+
+    copy.skipUndefined = this.skipUndefined;
+    copy.keepImplicitJoinProps = this.keepImplicitJoinProps;
+    copy.returnImmediatelyValue = this.returnImmediatelyValue;
+    copy.isInternalQuery = this.isInternalQuery;
+    copy.debug = this.debug;
+    copy.schema = this.schema;
+
+    return copy;
+  }
+}
+
+module.exports = {
+  InternalOptions,
+};