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

package/lib/queryBuilder/operations/JoinRelatedOperation.js

@@ -0,0 +1,103 @@
+'use strict';
+
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+const { RelationExpression } = require('../RelationExpression');
+const { RelationJoiner } = require('../join/RelationJoiner');
+const { isString } = require('../../utils/objectUtils');
+
+class JoinRelatedOperation extends QueryBuilderOperation {
+  constructor(name, opt) {
+    super(name, opt);
+    this.calls = [];
+  }
+
+  get joinOperation() {
+    return this.opt.joinOperation;
+  }
+
+  addCall(call) {
+    this.calls.push(call);
+  }
+
+  onBuild(builder) {
+    const modelClass = builder.modelClass();
+    const joinOperation = this.joinOperation;
+    let mergedExpr = RelationExpression.create();
+
+    for (const call of this.calls) {
+      const expr = RelationExpression.create(call.expression).toPojo();
+      const childNames = expr.$childNames;
+      const options = call.options || {};
+
+      if (childNames.length === 1) {
+        applyAlias(expr, modelClass, builder, options);
+      }
+
+      if (options.aliases) {
+        applyAliases(expr, modelClass, options);
+      }
+
+      mergedExpr = mergedExpr.merge(expr);
+    }
+
+    const joiner = new RelationJoiner({
+      modelClass,
+    });
+
+    joiner.setOptions({ joinOperation });
+    joiner.setExpression(mergedExpr);
+    joiner.setModifiers(builder.modifiers());
+    joiner.build(builder, false);
+  }
+
+  clone() {
+    const clone = super.clone();
+    clone.calls = this.calls.slice();
+    return clone;
+  }
+}
+
+function applyAlias(expr, modelClass, builder, options) {
+  const childNames = expr.$childNames;
+  const childName = childNames[0];
+  const childExpr = expr[childName];
+  const relation = modelClass.getRelation(childExpr.$relation);
+
+  let alias = childName;
+
+  if (options.alias === false) {
+    alias = builder.tableRefFor(relation.relatedModelClass);
+  } else if (isString(options.alias)) {
+    alias = options.alias;
+  }
+
+  if (childName !== alias) {
+    renameRelationExpressionNode(expr, childName, alias);
+  }
+}
+
+function applyAliases(expr, modelClass, options) {
+  for (const childName of expr.$childNames) {
+    const childExpr = expr[childName];
+    const relation = modelClass.getRelation(childExpr.$relation);
+    const alias = options.aliases[childExpr.$relation];
+
+    if (alias && alias !== childName) {
+      renameRelationExpressionNode(expr, childName, alias);
+    }
+
+    applyAliases(childExpr, relation.relatedModelClass, options);
+  }
+}
+
+function renameRelationExpressionNode(expr, oldName, newName) {
+  const childExpr = expr[oldName];
+  delete expr[oldName];
+  expr[newName] = childExpr;
+  childExpr.$name = newName;
+  expr.$childNames = expr.$childNames.map((it) => (it === oldName ? newName : it));
+}
+
+module.exports = {
+  JoinRelatedOperation,
+};

package/lib/queryBuilder/operations/KnexOperation.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const { ObjectionToKnexConvertingOperation } = require('./ObjectionToKnexConvertingOperation');
+
+// An operation that simply calls the equivalent knex method.
+class KnexOperation extends ObjectionToKnexConvertingOperation {
+  onBuildKnex(knexBuilder, builder) {
+    return knexBuilder[this.name].apply(knexBuilder, this.getKnexArgs(builder));
+  }
+}
+
+module.exports = {
+  KnexOperation,
+};

package/lib/queryBuilder/operations/MergeOperation.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const { isFunction, isEmpty, isObject } = require('../../utils/objectUtils');
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+const { convertFieldExpressionsToRaw } = require('./UpdateOperation');
+
+class MergeOperation extends QueryBuilderOperation {
+  constructor(name, opt) {
+    super(name, opt);
+    this.model = null;
+    this.args = null;
+  }
+
+  onAdd(builder, args) {
+    this.args = args;
+
+    if (!isEmpty(args) && isObject(args[0]) && !Array.isArray(args[0])) {
+      const json = args[0];
+      const modelClass = builder.modelClass();
+
+      this.model = modelClass.ensureModel(json, { patch: true });
+    }
+
+    return true;
+  }
+
+  onBuildKnex(knexBuilder, builder) {
+    if (!isFunction(knexBuilder.merge)) {
+      throw new Error('merge method can only be chained right after onConflict method');
+    }
+
+    if (this.model) {
+      const json = this.model.$toDatabaseJson(builder);
+      const convertedJson = convertFieldExpressionsToRaw(builder, this.model, json);
+
+      return knexBuilder.merge(convertedJson);
+    }
+
+    return knexBuilder.merge(...this.args);
+  }
+
+  toFindOperation() {
+    return null;
+  }
+
+  clone() {
+    const clone = super.clone();
+    clone.model = this.model;
+    clone.args = this.args;
+    return clone;
+  }
+}
+
+module.exports = {
+  MergeOperation,
+};

package/lib/queryBuilder/operations/ObjectionToKnexConvertingOperation.js

@@ -0,0 +1,192 @@
+'use strict';
+
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+const { isPlainObject, isObject, isFunction, once } = require('../../utils/objectUtils');
+const { isKnexQueryBuilder, isKnexJoinBuilder } = require('../../utils/knexUtils');
+const { transformation } = require('../transformations');
+const { isModelClass } = require('../../utils/resolveModel');
+const getJoinBuilder = once(() => require('../JoinBuilder').JoinBuilder);
+
+// An abstract operation base class that converts all arguments from objection types
+// to knex types. For example objection query builders are converted into knex query
+// builders and objection RawBuilder instances are converted into knex Raw instances.
+class ObjectionToKnexConvertingOperation extends QueryBuilderOperation {
+  constructor(name, opt) {
+    super(name, opt);
+    this.args = null;
+  }
+
+  getKnexArgs(builder) {
+    return convertArgs(this.name, builder, this.args);
+  }
+
+  onAdd(builder, args) {
+    this.args = Array.from(args);
+    return shouldBeAdded(this.name, builder, this.args);
+  }
+
+  clone() {
+    const clone = super.clone();
+    clone.args = this.args;
+    return clone;
+  }
+}
+
+function shouldBeAdded(opName, builder, args) {
+  const skipUndefined = builder.internalOptions().skipUndefined;
+
+  for (let i = 0, l = args.length; i < l; ++i) {
+    const arg = args[i];
+
+    if (isUndefined(arg)) {
+      if (skipUndefined) {
+        return false;
+      } else {
+        throw new Error(
+          `undefined passed as argument #${i} for '${opName}' operation. Call skipUndefined() method to ignore the undefined values.`,
+        );
+      }
+    }
+  }
+
+  return true;
+}
+
+function convertArgs(opName, builder, args) {
+  const skipUndefined = builder.internalOptions().skipUndefined;
+
+  return args.map((arg, i) => {
+    if (hasToKnexRawMethod(arg)) {
+      return convertToKnexRaw(arg, builder);
+    } else if (isObjectionQueryBuilderBase(arg)) {
+      return convertQueryBuilderBase(arg, builder);
+    } else if (isArray(arg)) {
+      return convertArray(arg, builder, i, opName, skipUndefined);
+    } else if (isModelClass(arg)) {
+      // Model classes can be used in place of their table names, for example
+      // `join(Pet, ...)`. They are functions, so this check must come first.
+      return arg.getTableName();
+    } else if (isFunction(arg)) {
+      return convertFunction(arg, builder);
+    } else if (isModel(arg)) {
+      return convertModel(arg);
+    } else if (isPlainObject(arg)) {
+      return convertPlainObject(arg, builder, i, opName, skipUndefined);
+    } else {
+      return arg;
+    }
+  });
+}
+
+function isUndefined(item) {
+  return item === undefined;
+}
+
+function hasToKnexRawMethod(item) {
+  return isObject(item) && isFunction(item.toKnexRaw);
+}
+
+function convertToKnexRaw(item, builder) {
+  return item.toKnexRaw(builder);
+}
+
+function isObjectionQueryBuilderBase(item) {
+  return isObject(item) && item.isObjectionQueryBuilderBase === true;
+}
+
+function convertQueryBuilderBase(item, builder) {
+  item = transformation.onConvertQueryBuilderBase(item, builder);
+  return item.subqueryOf(builder).toKnexQuery();
+}
+
+function isArray(item) {
+  return Array.isArray(item);
+}
+
+function convertArray(arr, builder, i, opName, skipUndefined) {
+  return arr.map((item) => {
+    if (item === undefined) {
+      if (!skipUndefined) {
+        throw new Error(
+          `undefined passed as an item in argument #${i} for '${opName}' operation. Call skipUndefined() method to ignore the undefined values.`,
+        );
+      }
+    } else if (hasToKnexRawMethod(item)) {
+      return convertToKnexRaw(item, builder);
+    } else if (isObjectionQueryBuilderBase(item)) {
+      return convertQueryBuilderBase(item, builder);
+    } else if (isModelClass(item)) {
+      return item.getTableName();
+    } else {
+      return item;
+    }
+  });
+}
+
+function convertFunction(func, builder) {
+  return function convertedKnexArgumentFunction(...args) {
+    if (isKnexQueryBuilder(this)) {
+      convertQueryBuilderFunction(this, func, builder);
+    } else if (isKnexJoinBuilder(this)) {
+      convertJoinBuilderFunction(this, func, builder);
+    } else {
+      return func.apply(this, args);
+    }
+  };
+}
+
+function convertQueryBuilderFunction(knexQueryBuilder, func, builder) {
+  const convertedQueryBuilder = builder.constructor.forClass(builder.modelClass());
+
+  convertedQueryBuilder.isPartial(true).subqueryOf(builder);
+  func.call(convertedQueryBuilder, convertedQueryBuilder);
+
+  convertedQueryBuilder.toKnexQuery(knexQueryBuilder);
+}
+
+function convertJoinBuilderFunction(knexJoinBuilder, func, builder) {
+  const JoinBuilder = getJoinBuilder();
+  const joinClauseBuilder = JoinBuilder.forClass(builder.modelClass());
+
+  joinClauseBuilder.isPartial(true).subqueryOf(builder);
+  func.call(joinClauseBuilder, joinClauseBuilder);
+
+  joinClauseBuilder.toKnexQuery(knexJoinBuilder);
+}
+
+function isModel(item) {
+  return isObject(item) && item.$isObjectionModel;
+}
+
+function convertModel(model) {
+  return model.$toDatabaseJson();
+}
+
+function convertPlainObject(obj, builder, i, opName, skipUndefined) {
+  return Object.keys(obj).reduce((out, key) => {
+    const item = obj[key];
+
+    if (item === undefined) {
+      if (!skipUndefined) {
+        throw new Error(
+          `undefined passed as a property in argument #${i} for '${opName}' operation. Call skipUndefined() method to ignore the undefined values.`,
+        );
+      }
+    } else if (hasToKnexRawMethod(item)) {
+      out[key] = convertToKnexRaw(item, builder);
+    } else if (isObjectionQueryBuilderBase(item)) {
+      out[key] = convertQueryBuilderBase(item, builder);
+    } else if (isModelClass(item)) {
+      // `{ alias: ModelClass }`.
+      out[key] = item.getTableName();
+    } else {
+      out[key] = item;
+    }
+
+    return out;
+  }, {});
+}
+
+module.exports = {
+  ObjectionToKnexConvertingOperation,
+};

package/lib/queryBuilder/operations/OnBuildKnexOperation.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+
+class OnBuildKnexOperation extends QueryBuilderOperation {
+  constructor(name, opt) {
+    super(name, opt);
+    this.func = null;
+  }
+
+  onAdd(_, args) {
+    this.func = args[0];
+    return true;
+  }
+
+  onBuildKnex(knexBuilder, builder) {
+    return this.func.call(knexBuilder, knexBuilder, builder);
+  }
+
+  clone() {
+    const clone = super.clone();
+    clone.func = this.func;
+    return clone;
+  }
+}
+
+module.exports = {
+  OnBuildKnexOperation,
+};

package/lib/queryBuilder/operations/OnBuildOperation.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+
+class OnBuildOperation extends QueryBuilderOperation {
+  constructor(name, opt) {
+    super(name, opt);
+    this.func = null;
+  }
+
+  onAdd(_, args) {
+    this.func = args[0];
+    return true;
+  }
+
+  onBuild(builder) {
+    return this.func.call(builder, builder);
+  }
+
+  clone() {
+    const clone = super.clone();
+    clone.func = this.func;
+    return clone;
+  }
+}
+
+module.exports = {
+  OnBuildOperation,
+};

package/lib/queryBuilder/operations/OnErrorOperation.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+
+class OnErrorOperation extends QueryBuilderOperation {
+  constructor(name, opt) {
+    super(name, opt);
+    this.func = null;
+  }
+
+  onAdd(_, args) {
+    this.func = args[0];
+    return true;
+  }
+
+  onError(builder, error) {
+    return this.func.call(builder, error, builder);
+  }
+
+  clone() {
+    const clone = super.clone();
+    clone.func = this.func;
+    return clone;
+  }
+}
+
+module.exports = {
+  OnErrorOperation,
+};