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

package/lib/queryBuilder/parsers/relationExpressionParser.pegjs

@@ -0,0 +1,141 @@
+{
+  function assertDuplicateRelation(node, expr) {
+    if (expr.$name in node) {
+      console.warn(`Duplicate relation "${expr.$name}" in a relation expression. You should use "a.[b, c]" instead of "[a.b, a.c]". This will cause an error in objection 2.0`);
+
+      // TODO: enable for v2.0.
+      // const err = new Error();
+      // err.duplicateRelationName = expr.$name;
+      // throw err;
+    }
+  }
+
+  function newNode() {
+    return {
+      $name: null,
+      $relation: null,
+      $modify: [],
+      $recursive: false,
+      $allRecursive: false,
+      $childNames: []
+    };
+  }
+}
+
+start =
+  expr:expression {
+    const node = newNode()
+
+    if (expr.$name === '*') {
+      node.$allRecursive = true;
+    } else {
+      assertDuplicateRelation(node, expr);
+      node[expr.$name] = expr;
+      node.$childNames.push(expr.$name)
+    }
+
+    return node;
+  }
+  /
+  list:listExpression {
+    const node = newNode()
+
+    list.forEach(expr => {
+      assertDuplicateRelation(node, expr);
+      node[expr.$name] = expr;
+      node.$childNames.push(expr.$name)
+    });
+
+    return node;
+  }
+
+expression =
+  name:name args:args? alias:alias? list:subListExpression {
+    const node = newNode()
+
+    node.$name = alias || name;
+    node.$relation = name;
+    node.$modify = args || [];
+
+    list.forEach(expr => {
+      assertDuplicateRelation(node, expr);
+      node[expr.$name] = expr;
+      node.$childNames.push(expr.$name)
+    });
+
+    return node;
+  }
+  /
+  name:name args:args? alias:alias? expr:subExpression? {
+    const node = newNode()
+
+    node.$name = alias || name;
+    node.$relation = name;
+    node.$modify = args || [];
+
+    if (expr) {
+      const match = /^\^(\d*)$/.exec(expr.$name);
+
+      if (match) {
+        if (match[1]) {
+          node.$recursive = parseInt(match[1], 10);
+        } else {
+          node.$recursive = true;
+        }
+      } else if (expr.$name === '*') {
+        node.$allRecursive = true;
+      } else {
+        assertDuplicateRelation(node, expr);
+        node[expr.$name] = expr;
+        node.$childNames.push(expr.$name)
+      }
+    }
+
+    return node;
+  }
+
+alias =
+  ws+ "as" ws+ alias:name {
+    return alias;
+  }
+
+name =
+  name:char+ {
+    return name.join('');
+  }
+
+char =
+  [^\[\]\(\),\. \t\r\n]
+
+args =
+  ws* "(" args:argListItem* ws* ")" {
+    return args;
+  }
+
+argListItem =
+  ws* arg:name ws* ","? {
+    return arg;
+  }
+
+ws =
+  [ \t\r\n]
+
+subListExpression =
+  ws* "." list:listExpression {
+    return list;
+  }
+
+listExpression =
+  ws* "[" items:listExpressionItem* ws* "]" ws* {
+    return items;
+  }
+
+listExpressionItem =
+  ws* expr:expression ws* ","? {
+    return expr;
+  }
+
+subExpression =
+  ws* "." ws* sub:expression ws* {
+    return sub;
+  }

package/lib/queryBuilder/transformations/CompositeQueryTransformation.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const { QueryTransformation } = require('./QueryTransformation');
+
+class CompositeQueryTransformation extends QueryTransformation {
+  constructor(transformations) {
+    super();
+    this.transformations = transformations;
+  }
+
+  onConvertQueryBuilderBase(item, builder) {
+    for (const transformation of this.transformations) {
+      item = transformation.onConvertQueryBuilderBase(item, builder);
+    }
+
+    return item;
+  }
+}
+
+module.exports = {
+  CompositeQueryTransformation,
+};

package/lib/queryBuilder/transformations/QueryTransformation.js

@@ -0,0 +1,11 @@
+'use strict';
+
+class QueryTransformation {
+  onConvertQueryBuilderBase(item, builder) {
+    return item;
+  }
+}
+
+module.exports = {
+  QueryTransformation,
+};

package/lib/queryBuilder/transformations/WrapMysqlModifySubqueryTransformation.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const { QueryTransformation } = require('./QueryTransformation');
+const { isMySql } = require('../../utils/knexUtils');
+
+/**
+ * Mysql doesn't allow queries like this:
+ *
+ *   update foo set bar = 1 where id in (select id from foo)
+ *
+ * because the subquery is for the same table `foo` as the parent update query.
+ * The same goes for delete queries too.
+ *
+ * This transformation wraps those subqueries like this:
+ *
+ *   update foo set bar = 1 where id in (select * from (select id from foo))
+ */
+class WrapMysqlModifySubqueryTransformation extends QueryTransformation {
+  onConvertQueryBuilderBase(query, parentQuery) {
+    const knex = parentQuery.unsafeKnex();
+
+    // Cannot detect anything if, for whatever reason, a knex instance
+    // or a transaction is not registered at this point.
+    if (!knex) {
+      return query;
+    }
+
+    // This transformation only applies to MySQL.
+    if (!isMySql(knex)) {
+      return query;
+    }
+
+    // A subquery in a join callback belongs to the query of the join.
+    while (parentQuery && typeof parentQuery.isUpdate !== 'function') {
+      parentQuery = parentQuery.parentQuery();
+    }
+
+    // This transformation only applies to update and delete queries.
+    if (!parentQuery || (!parentQuery.isUpdate() && !parentQuery.isDelete())) {
+      return query;
+    }
+
+    // If the subquery is for another table and the query doesn't join the
+    // parent query's table, we're good to go.
+    if (
+      parentQuery.tableName() !== query.tableName() &&
+      !hasJoinsToTable(query, parentQuery.tableName())
+    ) {
+      return query;
+    }
+
+    return query.modelClass().query().from(query.as('mysql_subquery_fix'));
+  }
+}
+
+function hasJoinsToTable(query, tableName) {
+  let found = false;
+
+  query.forEachOperation(query.constructor.JoinSelector, (op) => {
+    if (op.args[0] === tableName) {
+      found = true;
+      return false;
+    }
+  });
+
+  return found;
+}
+
+module.exports = {
+  WrapMysqlModifySubqueryTransformation,
+};

package/lib/queryBuilder/transformations/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const { CompositeQueryTransformation } = require('./CompositeQueryTransformation');
+
+const {
+  WrapMysqlModifySubqueryTransformation,
+} = require('./WrapMysqlModifySubqueryTransformation');
+
+const transformation = new CompositeQueryTransformation([
+  new WrapMysqlModifySubqueryTransformation(),
+]);
+
+module.exports = {
+  transformation,
+};

package/lib/queryBuilder/whereScopes.js

@@ -0,0 +1,227 @@
+'use strict';
+
+const { isObject, isFunction } = require('../utils/objectUtils');
+const { isKnexRaw } = require('../utils/knexUtils');
+
+// Where clauses objection adds on its own, like the owner condition of a relation
+// query or the id condition of `$query()`, are tagged with a "where scope". When
+// a query has where clauses from more than one scope, the clauses of each scope
+// are wrapped in parentheses so that an `orWhere` in one scope can't escape the
+// conditions of the others. Without this, `$relatedQuery('pets').where(a).orWhere(b)`
+// would produce `owner and a or b` and match other owners' pets.
+//
+// The scopes are only used when the knex query is built. The operation tree is
+// never modified.
+
+const WhereSelector = /^(where|orWhere|andWhere|find\w+)/;
+
+// Where operations that only ever produce a single predicate or predicates
+// joined with `and`. A scope that only contains these (and no raw arguments)
+// doesn't need to be wrapped in parentheses.
+const AND_ONLY_OPERATIONS = new Set([
+  'where',
+  'andWhere',
+  'whereNot',
+  'andWhereNot',
+  'whereIn',
+  'whereNotIn',
+  'whereNull',
+  'whereNotNull',
+  'whereBetween',
+  'whereNotBetween',
+  'whereExists',
+  'whereNotExists',
+  'whereColumn',
+  'andWhereColumn',
+  'whereNotColumn',
+  'andWhereNotColumn',
+  'whereLike',
+  'whereILike',
+  'whereWrapped',
+  'whereComposite',
+  'whereInComposite',
+  'whereJsonSupersetOf',
+  'whereJsonSubsetOf',
+  'whereJsonNotSupersetOf',
+  'whereJsonNotSubsetOf',
+  'whereJsonHasAny',
+  'whereJsonHasAll',
+  'whereJsonNotArray',
+  'whereJsonNotObject',
+  'whereJsonOverlaps',
+  'whereJsonNotOverlaps',
+  'whereJsonObject',
+  'whereNotJsonObject',
+  'whereJsonPath',
+  'findById',
+  'findByIds',
+]);
+
+function withWhereScope(builder, callback) {
+  const previous = builder._whereScope;
+  // A fresh object works as a unique token.
+  builder._whereScope = {};
+
+  try {
+    return callback();
+  } finally {
+    builder._whereScope = previous;
+  }
+}
+
+function effectiveWhereScope(op) {
+  while (op) {
+    if (op.whereScope !== null) {
+      return op.whereScope;
+    }
+
+    op = op.parentOperation;
+  }
+
+  return null;
+}
+
+// Returns null if no where clauses need to be grouped. Otherwise returns an
+// object that tells, for each operation, whether the operation is built as
+// part of a group.
+function createWhereGrouping(builder) {
+  const scopes = new Map();
+
+  builder.forEachOperation(WhereSelector, (op) => {
+    if (!hasWhereAncestor(op)) {
+      const scope = effectiveWhereScope(op);
+      const ops = scopes.get(scope) || [];
+
+      ops.push(op);
+      scopes.set(scope, ops);
+    }
+  });
+
+  if (scopes.size < 2) {
+    return null;
+  }
+
+  const groupByFirstOp = new Map();
+  const groupedOps = new Set();
+
+  for (const ops of scopes.values()) {
+    if (ops.every(isAndOnlyTree)) {
+      continue;
+    }
+
+    groupByFirstOp.set(ops[0], ops);
+
+    for (const op of ops) {
+      groupedOps.add(op);
+      op.forEachDescendantOperation((it) => {
+        groupedOps.add(it);
+      });
+    }
+  }
+
+  if (groupedOps.size === 0) {
+    return null;
+  }
+
+  return {
+    isGrouped(op) {
+      return groupedOps.has(op);
+    },
+
+    // Builds the whole group if `op` is the first operation of a group.
+    build(op, knexBuilder) {
+      const ops = groupByFirstOp.get(op);
+
+      if (!ops) {
+        return knexBuilder;
+      }
+
+      return knexBuilder.where(function () {
+        let groupBuilder = this;
+
+        for (const groupOp of ops) {
+          groupBuilder = buildOperationTree(builder, groupOp, groupBuilder);
+        }
+      });
+    },
+  };
+}
+
+function buildOperationTree(builder, op, knexBuilder) {
+  const ops = [op];
+
+  op.forEachDescendantOperation((it) => {
+    ops.push(it);
+  });
+
+  for (const it of ops) {
+    if (it.hasOnBuildKnex()) {
+      knexBuilder =
+        builder.callOperationMethod(it, 'onBuildKnex', [knexBuilder, builder]) || knexBuilder;
+    }
+  }
+
+  return knexBuilder;
+}
+
+function hasWhereAncestor(op) {
+  for (let parent = op.parentOperation; parent; parent = parent.parentOperation) {
+    if (WhereSelector.test(parent.name)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function isAndOnlyTree(op) {
+  if (!isAndOnly(op)) {
+    return false;
+  }
+
+  let andOnly = true;
+
+  op.forEachDescendantOperation((it) => {
+    if (it.hasOnBuildKnex() && !isAndOnly(it)) {
+      andOnly = false;
+      return false;
+    }
+  });
+
+  return andOnly;
+}
+
+function isAndOnly(op) {
+  return AND_ONLY_OPERATIONS.has(op.name) && !containsRaw(op.args);
+}
+
+function containsRaw(value) {
+  if (Array.isArray(value)) {
+    return value.some(containsRaw);
+  } else if (!isObject(value)) {
+    return false;
+  } else if (value.isObjectionReferenceBuilder) {
+    // A reference is always a single (possibly casted) column or json path.
+    return false;
+  } else if (value.isObjectionFunctionBuilder) {
+    // `fn()` calls and expressions like `ref('a').eq(1)` are wrapped in parentheses,
+    // so only their arguments can contain anything.
+    return containsRaw(value._args);
+  } else if (isKnexRaw(value) || isFunction(value.toKnexRaw)) {
+    // Raw sql (and anything that is converted into it) can contain anything.
+    return true;
+  } else if (value.isObjectionQueryBuilderBase || isFunction(value.toSQL)) {
+    // Subqueries are always wrapped in parentheses.
+    return false;
+  } else if (Object.getPrototypeOf(value) === Object.prototype) {
+    return Object.values(value).some(containsRaw);
+  } else {
+    return false;
+  }
+}
+
+module.exports = {
+  withWhereScope,
+  effectiveWhereScope,
+  createWhereGrouping,
+};