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

package/lib/queryBuilder/transformations/CompositeQueryTransformation.js

@@ -1,22 +1,17 @@
 '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);
+    constructor(transformations) {
+        super();
+        this.transformations = transformations;
+    }
+    onConvertQueryBuilderBase(item, builder) {
+        for (const transformation of this.transformations) {
+            item = transformation.onConvertQueryBuilderBase(item, builder);
+        }
+        return item;
     }
-
-    return item;
-  }
 }
-
 module.exports = {
-  CompositeQueryTransformation,
+    CompositeQueryTransformation,
 };

package/lib/queryBuilder/transformations/QueryTransformation.js

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

package/lib/queryBuilder/transformations/WrapMysqlModifySubqueryTransformation.js

@@ -1,8 +1,6 @@
 'use strict';
-
 const { QueryTransformation } = require('./QueryTransformation');
 const { isMySql } = require('../../utils/knexUtils');
-
 /**
  * Mysql doesn't allow queries like this:
  *
@@ -16,56 +14,44 @@ const { isMySql } = require('../../utils/knexUtils');
  *   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;
+    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'));
     }
-
-    // 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;
+    let found = false;
+    query.forEachOperation(query.constructor.JoinSelector, (op) => {
+        if (op.args[0] === tableName) {
+            found = true;
+            return false;
+        }
+    });
+    return found;
 }
-
 module.exports = {
-  WrapMysqlModifySubqueryTransformation,
+    WrapMysqlModifySubqueryTransformation,
 };

package/lib/queryBuilder/transformations/index.js

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

package/lib/queryBuilder/whereScopes.js

@@ -1,8 +1,6 @@
 '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
@@ -12,216 +10,190 @@ const { isKnexRaw } = require('../utils/knexUtils');
 //
 // 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',
+    '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;
-  }
+    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;
+    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);
+    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;
+    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;
+    for (let parent = op.parentOperation; parent; parent = parent.parentOperation) {
+        if (WhereSelector.test(parent.name)) {
+            return true;
+        }
     }
-  }
-
-  return false;
+    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;
+    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);
+    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;
-  }
+    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,
+    withWhereScope,
+    effectiveWhereScope,
+    createWhereGrouping,
 };