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

package/lib/queryBuilder/join/TableNode.js

@@ -0,0 +1,163 @@
+'use strict';
+
+class TableNode {
+  constructor({ tableTree, modelClass, expression, parentNode = null, relation = null }) {
+    this.tableTree = tableTree;
+    this.modelClass = modelClass;
+    this.parentNode = parentNode;
+    this.relation = relation;
+    this.expression = expression;
+    this.childNodes = [];
+
+    this.alias = this._calculateAlias();
+    this.idGetter = this._createIdGetter();
+  }
+
+  static create(args) {
+    const node = new TableNode(args);
+
+    if (node.parentNode) {
+      node.parentNode.childNodes.push(node);
+    }
+
+    return node;
+  }
+
+  get options() {
+    return this.tableTree.options;
+  }
+
+  get relationProperty() {
+    return this.expression.node.$name;
+  }
+
+  getReferenceForColumn(column) {
+    return `${this.alias}.${column}`;
+  }
+
+  getColumnAliasForColumn(column) {
+    if (this.parentNode) {
+      return `${this.alias}${this.options.separator}${column}`;
+    } else {
+      return column;
+    }
+  }
+
+  getColumnForColumnAlias(columnAlias) {
+    const lastSepIndex = columnAlias.lastIndexOf(this.options.separator);
+
+    if (lastSepIndex === -1) {
+      return columnAlias;
+    } else {
+      return columnAlias.slice(lastSepIndex + this.options.separator.length);
+    }
+  }
+
+  getIdFromFlatRow(flatRow) {
+    return this.idGetter(flatRow);
+  }
+
+  getJoinTableAlias(builder) {
+    if (this.relation.isObjectionManyToManyRelation) {
+      return (
+        builder.aliasFor(this.relation.joinTableModelClass) ||
+        this.modelClass.joinTableAlias(this.alias)
+      );
+    } else {
+      return undefined;
+    }
+  }
+
+  _calculateAlias() {
+    if (this.parentNode) {
+      const relationName = this.expression.node.$name;
+      const alias = this.options.aliases[relationName] || relationName;
+
+      if (this.options.minimize) {
+        return `_t${this.tableTree.createNextUid()}`;
+      } else if (this.parentNode.parentNode) {
+        return `${this.parentNode.alias}${this.options.separator}${alias}`;
+      } else {
+        return alias;
+      }
+    } else {
+      return this.tableTree.rootTableAlias;
+    }
+  }
+
+  _createIdGetter() {
+    const idColumns = this.modelClass.getIdColumnArray();
+    const columnAliases = idColumns.map((column) => this.getColumnAliasForColumn(column));
+
+    if (idColumns.length === 1) {
+      return createIdGetter(columnAliases);
+    } else {
+      return createCompositeIdGetter(columnAliases);
+    }
+  }
+}
+
+function createIdGetter(columnAliases) {
+  const columnAlias = columnAliases[0];
+
+  return (flatRow) => {
+    const id = flatRow[columnAlias];
+
+    if (id === null) {
+      return null;
+    }
+
+    return `${id}`;
+  };
+}
+
+function createCompositeIdGetter(columnAliases) {
+  if (columnAliases.length === 2) {
+    return createTwoIdGetter(columnAliases);
+  } else {
+    return createMultiIdGetter(columnAliases);
+  }
+}
+
+function createTwoIdGetter(columnAliases) {
+  const columnAlias1 = columnAliases[0];
+  const columnAlias2 = columnAliases[1];
+
+  return (flatRow) => {
+    const id1 = flatRow[columnAlias1];
+    const id2 = flatRow[columnAlias2];
+
+    if (id1 === null || id2 === null) {
+      return null;
+    }
+
+    return `${id1},${id2}`;
+  };
+}
+
+function createMultiIdGetter(columnAliases) {
+  return (flatRow) => {
+    let idStr = '';
+
+    for (let i = 0, l = columnAliases.length; i < l; ++i) {
+      const columnAlias = columnAliases[i];
+      const id = flatRow[columnAlias];
+
+      if (id === null) {
+        return null;
+      }
+
+      idStr += id;
+
+      if (i !== l - 1) {
+        idStr += ',';
+      }
+    }
+
+    return idStr;
+  };
+}
+
+module.exports = {
+  TableNode,
+};

package/lib/queryBuilder/join/TableTree.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const { forEachChildExpression } = require('./utils');
+const { TableNode } = require('./TableNode');
+
+class TableTree {
+  constructor({ expression, rootModelClass, rootTableAlias, options }) {
+    this.options = options;
+    this.rootModelClass = rootModelClass;
+    this.rootTableAlias = rootTableAlias;
+    this.nodes = [];
+    this.nodesByAlias = new Map();
+    this.uidCounter = 0;
+
+    this._createNodes({ expression, modelClass: rootModelClass });
+  }
+
+  static create(args) {
+    return new TableTree(args);
+  }
+
+  get rootNode() {
+    return this.nodes[0];
+  }
+
+  getNodeForColumnAlias(columnAlias) {
+    const lastSepIndex = columnAlias.lastIndexOf(this.options.separator);
+
+    if (lastSepIndex === -1) {
+      return this.rootNode;
+    } else {
+      const tableAlias = columnAlias.slice(0, lastSepIndex);
+      return this.nodesByAlias.get(tableAlias);
+    }
+  }
+
+  createNextUid() {
+    return this.uidCounter++;
+  }
+
+  _createNodes({ expression, modelClass }) {
+    const rootNode = this._createRootNode({ expression, modelClass });
+    this._createChildNodes({ expression, modelClass, parentNode: rootNode });
+
+    for (const node of this.nodes) {
+      this.nodesByAlias.set(node.alias, node);
+    }
+  }
+
+  _createRootNode({ expression, modelClass }) {
+    const node = TableNode.create({
+      tableTree: this,
+      modelClass,
+      expression,
+    });
+
+    this.nodes.push(node);
+    return node;
+  }
+
+  _createChildNodes({ expression, modelClass, parentNode }) {
+    forEachChildExpression(expression, modelClass, (childExpr, relation) => {
+      const node = TableNode.create({
+        tableTree: this,
+        modelClass: relation.relatedModelClass,
+        expression: childExpr,
+
+        parentNode,
+        relation,
+      });
+
+      this.nodes.push(node);
+
+      this._createChildNodes({
+        expression: childExpr,
+        modelClass: relation.relatedModelClass,
+        parentNode: node,
+      });
+    });
+  }
+}
+
+module.exports = {
+  TableTree,
+};

package/lib/queryBuilder/join/utils.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const { ValidationErrorType } = require('../../model/ValidationError');
+
+const ID_LENGTH_LIMIT = 63;
+const RELATION_RECURSION_LIMIT = 64;
+
+// Given a relation expression, goes through all first level children.
+function forEachChildExpression(expr, modelClass, callback) {
+  if (expr.node.$allRecursive || expr.maxRecursionDepth > RELATION_RECURSION_LIMIT) {
+    throw modelClass.createValidationError({
+      type: ValidationErrorType.RelationExpression,
+      message: `recursion depth of eager expression ${expr.toString()} too big for JoinEagerAlgorithm`,
+    });
+  }
+
+  expr.forEachChildExpression(modelClass, callback);
+}
+
+module.exports = {
+  ID_LENGTH_LIMIT,
+  RELATION_RECURSION_LIMIT,
+
+  forEachChildExpression,
+};

package/lib/queryBuilder/operations/DelegateOperation.js

@@ -0,0 +1,141 @@
+'use strict';
+
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+
+// Operation that simply delegates all calls to the operation passed
+// to to the constructor in `opt.delegate`.
+class DelegateOperation extends QueryBuilderOperation {
+  constructor(name, opt) {
+    super(name, opt);
+
+    this.delegate = opt.delegate;
+  }
+
+  get modelOptions() {
+    return this.delegate.modelOptions;
+  }
+
+  is(OperationClass) {
+    return super.is(OperationClass) || this.delegate.is(OperationClass);
+  }
+
+  onAdd(builder, args) {
+    return this.delegate.onAdd(builder, args);
+  }
+
+  onBefore1(builder, result) {
+    return this.delegate.onBefore1(builder, result);
+  }
+
+  hasOnBefore1() {
+    return this.onBefore1 !== DelegateOperation.prototype.onBefore1 || this.delegate.hasOnBefore1();
+  }
+
+  onBefore2(builder, result) {
+    return this.delegate.onBefore2(builder, result);
+  }
+
+  hasOnBefore2() {
+    return this.onBefore2 !== DelegateOperation.prototype.onBefore2 || this.delegate.hasOnBefore2();
+  }
+
+  onBefore3(builder, result) {
+    return this.delegate.onBefore3(builder, result);
+  }
+
+  hasOnBefore3() {
+    return this.onBefore3 !== DelegateOperation.prototype.onBefore3 || this.delegate.hasOnBefore3();
+  }
+
+  onBuild(builder) {
+    return this.delegate.onBuild(builder);
+  }
+
+  hasOnBuild() {
+    return this.onBuild !== DelegateOperation.prototype.onBuild || this.delegate.hasOnBuild();
+  }
+
+  onBuildKnex(knexBuilder, builder) {
+    return this.delegate.onBuildKnex(knexBuilder, builder);
+  }
+
+  hasOnBuildKnex() {
+    return (
+      this.onBuildKnex !== DelegateOperation.prototype.onBuildKnex || this.delegate.hasOnBuildKnex()
+    );
+  }
+
+  onRawResult(builder, result) {
+    return this.delegate.onRawResult(builder, result);
+  }
+
+  hasOnRawResult() {
+    return (
+      this.onRawResult !== DelegateOperation.prototype.onRawResult || this.delegate.hasOnRawResult()
+    );
+  }
+
+  onAfter1(builder, result) {
+    return this.delegate.onAfter1(builder, result);
+  }
+
+  hasOnAfter1() {
+    return this.onAfter1 !== DelegateOperation.prototype.onAfter1 || this.delegate.hasOnAfter1();
+  }
+
+  onAfter2(builder, result) {
+    return this.delegate.onAfter2(builder, result);
+  }
+
+  hasOnAfter2() {
+    return this.onAfter2 !== DelegateOperation.prototype.onAfter2 || this.delegate.hasOnAfter2();
+  }
+
+  onAfter3(builder, result) {
+    return this.delegate.onAfter3(builder, result);
+  }
+
+  hasOnAfter3() {
+    return this.onAfter3 !== DelegateOperation.prototype.onAfter3 || this.delegate.hasOnAfter3();
+  }
+
+  queryExecutor(builder) {
+    return this.delegate.queryExecutor(builder);
+  }
+
+  hasQueryExecutor() {
+    return (
+      this.queryExecutor !== DelegateOperation.prototype.queryExecutor ||
+      this.delegate.hasQueryExecutor()
+    );
+  }
+
+  onError(builder, error) {
+    return this.delegate.onError(builder, error);
+  }
+
+  hasOnError() {
+    return this.onError !== DelegateOperation.prototype.onError || this.delegate.hasOnError();
+  }
+
+  toFindOperation(builder) {
+    return this.delegate.toFindOperation(builder);
+  }
+
+  hasToFindOperation() {
+    return (
+      this.hasToFindOperation !== DelegateOperation.prototype.hasToFindOperation ||
+      this.delegate.hasToFindOperation()
+    );
+  }
+
+  clone() {
+    const clone = super.clone();
+    clone.delegate = this.delegate && this.delegate.clone();
+    return clone;
+  }
+}
+
+module.exports = {
+  DelegateOperation,
+};

package/lib/queryBuilder/operations/DeleteOperation.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+const { StaticHookArguments } = require('../StaticHookArguments');
+
+class DeleteOperation extends QueryBuilderOperation {
+  async onBefore2(builder, result) {
+    await callBeforeDelete(builder);
+    return result;
+  }
+
+  onBuildKnex(knexBuilder) {
+    return knexBuilder.delete();
+  }
+
+  onAfter2(builder, result) {
+    return callAfterDelete(builder, result);
+  }
+
+  toFindOperation() {
+    return null;
+  }
+}
+
+function callBeforeDelete(builder) {
+  return callStaticBeforeDelete(builder);
+}
+
+function callStaticBeforeDelete(builder) {
+  const args = StaticHookArguments.create({ builder });
+  return builder.modelClass().beforeDelete(args);
+}
+
+function callAfterDelete(builder, result) {
+  return callStaticAfterDelete(builder, result);
+}
+
+async function callStaticAfterDelete(builder, result) {
+  const args = StaticHookArguments.create({ builder, result });
+  const maybeResult = await builder.modelClass().afterDelete(args);
+
+  if (maybeResult === undefined) {
+    return result;
+  } else {
+    return maybeResult;
+  }
+}
+
+module.exports = {
+  DeleteOperation,
+};

package/lib/queryBuilder/operations/FindByIdOperation.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+const { assertIdNotUndefined } = require('../../utils/assert');
+
+class FindByIdOperation extends QueryBuilderOperation {
+  constructor(name, opt) {
+    super(name, opt);
+    this.id = this.opt.id;
+  }
+
+  onAdd(builder, args) {
+    if (this.id === null || this.id === undefined) {
+      this.id = args[0];
+    }
+
+    return super.onAdd(builder, args);
+  }
+
+  onBuild(builder) {
+    if (!builder.internalOptions().skipUndefined) {
+      assertIdNotUndefined(this.id, `undefined was passed to ${this.name}`);
+    }
+
+    builder.whereComposite(builder.fullIdColumn(), this.id);
+  }
+
+  clone() {
+    const clone = super.clone();
+    clone.id = this.id;
+    return clone;
+  }
+}
+
+module.exports = {
+  FindByIdOperation,
+};

package/lib/queryBuilder/operations/FindByIdsOperation.js

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

package/lib/queryBuilder/operations/FindOperation.js

@@ -0,0 +1,164 @@
+'use strict';
+
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+const { StaticHookArguments } = require('../StaticHookArguments');
+const { isPromise, after, afterReturn } = require('../../utils/promiseUtils');
+const { isObject } = require('../../utils/objectUtils');
+
+class FindOperation extends QueryBuilderOperation {
+  onBefore2(builder, result) {
+    return afterReturn(callStaticBeforeFind(builder), result);
+  }
+
+  onAfter3(builder, results) {
+    const opt = builder.findOptions();
+
+    if (opt.dontCallFindHooks) {
+      return results;
+    } else {
+      return callAfterFind(builder, results);
+    }
+  }
+}
+
+function callStaticBeforeFind(builder) {
+  const args = StaticHookArguments.create({ builder });
+  return builder.modelClass().beforeFind(args);
+}
+
+function callAfterFind(builder, result) {
+  const opt = builder.findOptions();
+  const maybePromise = callInstanceAfterFind(builder.context(), result, opt.callAfterFindDeeply);
+
+  return after(maybePromise, () => callStaticAfterFind(builder, result));
+}
+
+function callStaticAfterFind(builder, result) {
+  const args = StaticHookArguments.create({ builder, result });
+  const maybePromise = builder.modelClass().afterFind(args);
+
+  return after(maybePromise, (maybeResult) => {
+    if (maybeResult === undefined) {
+      return result;
+    } else {
+      return maybeResult;
+    }
+  });
+}
+
+function callInstanceAfterFind(ctx, results, deep) {
+  if (Array.isArray(results)) {
+    if (results.length === 1) {
+      return callAfterFindForOne(ctx, results[0], results, deep);
+    } else {
+      return callAfterFindArray(ctx, results, deep);
+    }
+  } else {
+    return callAfterFindForOne(ctx, results, results, deep);
+  }
+}
+
+function callAfterFindArray(ctx, results, deep) {
+  if (results.length === 0 || !isObject(results[0])) {
+    return results;
+  }
+
+  const mapped = new Array(results.length);
+  let containsPromise = false;
+
+  for (let i = 0, l = results.length; i < l; ++i) {
+    mapped[i] = callAfterFindForOne(ctx, results[i], results[i], deep);
+
+    if (isPromise(mapped[i])) {
+      containsPromise = true;
+    }
+  }
+
+  if (containsPromise) {
+    return Promise.all(mapped);
+  } else {
+    return mapped;
+  }
+}
+
+function callAfterFindForOne(ctx, model, result, deep) {
+  if (!isObject(model) || !model.$isObjectionModel) {
+    return result;
+  }
+
+  if (deep) {
+    const results = [];
+    const containsPromise = callAfterFindForRelations(ctx, model, results);
+
+    if (containsPromise) {
+      return Promise.all(results).then(() => {
+        return doCallAfterFind(ctx, model, result);
+      });
+    } else {
+      return doCallAfterFind(ctx, model, result);
+    }
+  } else {
+    return doCallAfterFind(ctx, model, result);
+  }
+}
+
+function callAfterFindForRelations(ctx, model, results) {
+  const keys = Object.keys(model);
+  let containsPromise = false;
+
+  for (let i = 0, l = keys.length; i < l; ++i) {
+    const key = keys[i];
+    const value = model[key];
+
+    if (isRelation(value)) {
+      const maybePromise = callInstanceAfterFind(ctx, value, true);
+
+      if (isPromise(maybePromise)) {
+        containsPromise = true;
+      }
+
+      results.push(maybePromise);
+    }
+  }
+
+  return containsPromise;
+}
+
+function isRelation(value) {
+  return (
+    (isObject(value) && value.$isObjectionModel) ||
+    (isNonEmptyObjectArray(value) && value[0].$isObjectionModel)
+  );
+}
+
+function isNonEmptyObjectArray(value) {
+  return Array.isArray(value) && value.length > 0 && isObject(value[0]);
+}
+
+function doCallAfterFind(ctx, model, result) {
+  const afterFind = getAfterFindHook(model);
+
+  if (afterFind !== null) {
+    const maybePromise = afterFind.call(model, ctx);
+
+    if (isPromise(maybePromise)) {
+      return maybePromise.then(() => result);
+    } else {
+      return result;
+    }
+  } else {
+    return result;
+  }
+}
+
+function getAfterFindHook(model) {
+  if (model.$afterFind !== model.$objectionModelClass.prototype.$afterFind) {
+    return model.$afterFind;
+  } else {
+    return null;
+  }
+}
+
+module.exports = {
+  FindOperation,
+};