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

package/lib/queryBuilder/join/TableNode.js

@@ -1,163 +1,136 @@
 '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);
+    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();
     }
-
-    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;
+    static create(args) {
+        const node = new TableNode(args);
+        if (node.parentNode) {
+            node.parentNode.childNodes.push(node);
+        }
+        return node;
     }
-  }
-
-  getColumnForColumnAlias(columnAlias) {
-    const lastSepIndex = columnAlias.lastIndexOf(this.options.separator);
-
-    if (lastSepIndex === -1) {
-      return columnAlias;
-    } else {
-      return columnAlias.slice(lastSepIndex + this.options.separator.length);
+    get options() {
+        return this.tableTree.options;
     }
-  }
-
-  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;
+    get relationProperty() {
+        return this.expression.node.$name;
     }
-  }
-
-  _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;
+    getReferenceForColumn(column) {
+        return `${this.alias}.${column}`;
     }
-  }
-
-  _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);
+    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}`;
-  };
+    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);
-  }
+    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}`;
-  };
+    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;
-  };
+    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,
+    TableNode,
 };

package/lib/queryBuilder/join/TableTree.js

@@ -1,85 +1,69 @@
 '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);
+    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 });
     }
-  }
-
-  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);
+    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,
+            });
+        });
     }
-  }
-
-  _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,
+    TableTree,
 };

package/lib/queryBuilder/join/utils.js

@@ -1,25 +1,19 @@
 '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);
+    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,
+    ID_LENGTH_LIMIT,
+    RELATION_RECURSION_LIMIT,
+    forEachChildExpression,
 };