objection 3.4.0 → 3.4.1

package/lib/queryBuilder/QueryBuilderBase.js

@@ -616,9 +616,14 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
   // whereJson(Not)SupersetOf / whereJson(Not)SubsetOf are now supported by knex >= 1.0, but for now
   // objection handles them differently and only for postgres.
   // Changing them to utilize knex methods directly may require a major version bump and upgrade guide.
+  // On MySQL, the simple `(column, object | array)` form is passed on to knex (ditojs#113).
   whereJsonSupersetOf(...args) {
     return this.addOperation(
-      new WhereJsonPostgresOperation('whereJsonSupersetOf', { operator: '@>', bool: 'and' }),
+      new WhereJsonPostgresOperation('whereJsonSupersetOf', {
+        operator: '@>',
+        bool: 'and',
+        knexMethod: 'whereJsonSupersetOf',
+      }),
       args,
     );
   }
@@ -629,7 +634,11 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
 
   orWhereJsonSupersetOf(...args) {
     return this.addOperation(
-      new WhereJsonPostgresOperation('orWhereJsonSupersetOf', { operator: '@>', bool: 'or' }),
+      new WhereJsonPostgresOperation('orWhereJsonSupersetOf', {
+        operator: '@>',
+        bool: 'or',
+        knexMethod: 'whereJsonSupersetOf',
+      }),
       args,
     );
   }
@@ -640,13 +649,14 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
         operator: '@>',
         bool: 'and',
         prefix: 'not',
+        knexMethod: 'whereJsonNotSupersetOf',
       }),
       args,
     );
   }
 
   andWhereJsonNotSupersetOf(...args) {
-    return this.andWhereJsonNotSupersetOf(...args);
+    return this.whereJsonNotSupersetOf(...args);
   }
 
   orWhereJsonNotSupersetOf(...args) {
@@ -655,6 +665,7 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
         operator: '@>',
         bool: 'or',
         prefix: 'not',
+        knexMethod: 'whereJsonNotSupersetOf',
       }),
       args,
     );
@@ -662,7 +673,11 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
 
   whereJsonSubsetOf(...args) {
     return this.addOperation(
-      new WhereJsonPostgresOperation('whereJsonSubsetOf', { operator: '<@', bool: 'and' }),
+      new WhereJsonPostgresOperation('whereJsonSubsetOf', {
+        operator: '<@',
+        bool: 'and',
+        knexMethod: 'whereJsonSubsetOf',
+      }),
       args,
     );
   }
@@ -673,7 +688,11 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
 
   orWhereJsonSubsetOf(...args) {
     return this.addOperation(
-      new WhereJsonPostgresOperation('orWhereJsonSubsetOf', { operator: '<@', bool: 'or' }),
+      new WhereJsonPostgresOperation('orWhereJsonSubsetOf', {
+        operator: '<@',
+        bool: 'or',
+        knexMethod: 'whereJsonSubsetOf',
+      }),
       args,
     );
   }
@@ -684,6 +703,7 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
         operator: '<@',
         bool: 'and',
         prefix: 'not',
+        knexMethod: 'whereJsonNotSubsetOf',
       }),
       args,
     );
@@ -699,6 +719,7 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
         operator: '<@',
         bool: 'or',
         prefix: 'not',
+        knexMethod: 'whereJsonNotSubsetOf',
       }),
       args,
     );
@@ -772,20 +793,34 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
     );
   }
 
+  // Not passed on to knex like `whereJsonSupersetOf()`, as MySQL's `json_contains()`
+  // also matches `{}` in arrays of objects.
   whereJsonIsArray(fieldExpression) {
-    return this.whereJsonSupersetOf(fieldExpression, []);
+    return this.addOperation(
+      new WhereJsonPostgresOperation('whereJsonSupersetOf', { operator: '@>', bool: 'and' }),
+      [fieldExpression, []],
+    );
   }
 
   orWhereJsonIsArray(fieldExpression) {
-    return this.orWhereJsonSupersetOf(fieldExpression, []);
+    return this.addOperation(
+      new WhereJsonPostgresOperation('orWhereJsonSupersetOf', { operator: '@>', bool: 'or' }),
+      [fieldExpression, []],
+    );
   }
 
   whereJsonIsObject(fieldExpression) {
-    return this.whereJsonSupersetOf(fieldExpression, {});
+    return this.addOperation(
+      new WhereJsonPostgresOperation('whereJsonSupersetOf', { operator: '@>', bool: 'and' }),
+      [fieldExpression, {}],
+    );
   }
 
   orWhereJsonIsObject(fieldExpression) {
-    return this.orWhereJsonSupersetOf(fieldExpression, {});
+    return this.addOperation(
+      new WhereJsonPostgresOperation('orWhereJsonSupersetOf', { operator: '@>', bool: 'or' }),
+      [fieldExpression, {}],
+    );
   }
 
   whereColumn(...args) {

package/lib/queryBuilder/ReferenceBuilder.js

@@ -5,6 +5,7 @@ const {
   toPostgresJsonPathLiteral,
 } = require('../utils/parseFieldExpression');
 const { isObject } = require('../utils/objectUtils');
+const { warnIfNotPostgres } = require('./operations/jsonApi/postgresJsonApi');
 
 class ReferenceBuilder {
   constructor(expr) {
@@ -163,7 +164,13 @@ class ReferenceBuilder {
   }
 
   toKnexRaw(builder) {
-    return builder.knex().raw(...this._createRawArgs(builder));
+    const knex = builder.knex();
+
+    if (this._parsedExpr.access.length > 0) {
+      warnIfNotPostgres(knex);
+    }
+
+    return knex.raw(...this._createRawArgs(builder));
   }
 
   _parseExpression(expr) {

package/lib/queryBuilder/join/RelationJoiner.js

@@ -2,6 +2,7 @@
 
 const { uniqBy } = require('../../utils/objectUtils');
 const { Selection } = require('../operations/select/Selection');
+const { SelectOperation } = require('../operations/select/SelectOperation');
 const { createModifier } = require('../../utils/createModifier');
 const { map: mapPromise } = require('../../utils/promiseUtils');
 const { ValidationErrorType } = require('../../model/ValidationError');
@@ -124,7 +125,7 @@ class RelationJoiner {
     // also contain selects.
     userSelectQuery.modify(tableNode.relation.modify);
 
-    if (selectsOnlyAliasesKeepingSelectAll(userSelectQuery.findAllSelections())) {
+    if (selectsOnlyAliasesKeepingSelectAll(findJoinSelections(userSelectQuery))) {
       // All columns are selected from the joined subquery in the main query,
       // so the subquery needs to select them too.
       subqueryToJoin.select(`${subqueryToJoin.tableRef()}.*`);
@@ -268,7 +269,7 @@ function ensureIdAndRelationPropsAreSelected({ builder, tableNode }) {
   ];
 
   const selectStrings = uniqBy(cols)
-    .filter((col) => !builder.hasSelectionAs(col, col))
+    .filter((col) => !hasSelectionAs(builder, col))
     .map((col) => `${tableRef}.${col}`);
 
   return builder.select(selectStrings);
@@ -276,7 +277,7 @@ function ensureIdAndRelationPropsAreSelected({ builder, tableNode }) {
 
 function getSelectionsForNode({ builder, tableNode, userSelectQueries }) {
   const userSelectQuery = userSelectQueries.get(tableNode);
-  const userSelections = userSelectQuery.findAllSelections();
+  const userSelections = findUserSelections(userSelectQuery, tableNode);
   const userSelectedAllColumns = isSelectAllSelectionSet(userSelections);
 
   let selections = [];
@@ -298,7 +299,7 @@ function getSelectionsForNode({ builder, tableNode, userSelectQueries }) {
     const idSelections = getIdSelectionsForNode({ tableNode });
 
     for (const idSelection of idSelections) {
-      if (!userSelectQuery.hasSelectionAs(idSelection.column, idSelection.column)) {
+      if (!hasUserSelectionAs(userSelectQuery, tableNode, idSelection.column)) {
         selections.push(idSelection);
         internalSelections.push(idSelection);
       }
@@ -318,6 +319,54 @@ function getSelectionsForNode({ builder, tableNode, userSelectQueries }) {
   };
 }
 
+// Like `builder.findAllSelections()`, but aggregates select their aliases
+// instead of the columns they're passed. Aggregates without an alias are left
+// out, as their column name differs between databases.
+function findJoinSelections(builder) {
+  let selections = [];
+
+  builder.forEachOperation(true, (op) => {
+    if (op.constructor === SelectOperation) {
+      selections = selections.concat(op.aggregateSelections || op.selections);
+    }
+  });
+
+  return selections;
+}
+
+// Like `builder.hasSelectionAs(column, column)`, but ignoring the columns
+// passed to aggregates, as they don't select them.
+function hasSelectionAs(builder, column) {
+  if (builder.has(isAggregateOperation)) {
+    // Explicit, as a query with only aggregates doesn't select all columns.
+    return builder.clone().clear(isAggregateOperation).hasSelectionAs(column, column, true);
+  } else {
+    return builder.hasSelectionAs(column, column);
+  }
+}
+
+// Only the joined subqueries select aggregates by their aliases. The root
+// query keeps treating the columns passed to them as selected.
+function findUserSelections(builder, tableNode) {
+  if (tableNode.parentNode) {
+    return findJoinSelections(builder);
+  } else {
+    return builder.findAllSelections();
+  }
+}
+
+function hasUserSelectionAs(builder, tableNode, column) {
+  if (tableNode.parentNode) {
+    return hasSelectionAs(builder, column);
+  } else {
+    return builder.hasSelectionAs(column, column);
+  }
+}
+
+function isAggregateOperation(op) {
+  return op.constructor === SelectOperation && op.aggregateSelections !== null;
+}
+
 function mapUserSelectionsFromSubqueryToMainQuery({ userSelections, tableNode }) {
   return userSelections.filter(isNotSelectAll).map((selection) => {
     return new Selection(

package/lib/queryBuilder/operations/UpdateOperation.js

@@ -5,6 +5,7 @@ const { isEmpty } = require('../../utils/objectUtils');
 const { toPostgresJsonPathLiteral } = require('../../utils/parseFieldExpression');
 const { isKnexRaw, isKnexQueryBuilder } = require('../../utils/knexUtils');
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+const { warnIfNotPostgres } = require('./jsonApi/postgresJsonApi');
 const { StaticHookArguments } = require('../StaticHookArguments');
 
 class UpdateOperation extends QueryBuilderOperation {
@@ -103,6 +104,7 @@ function convertFieldExpressionsToRaw(builder, model, json) {
     if (key.indexOf(':') > -1) {
       // 'col:attr' : ref('other:lol') is transformed to
       // "col" : raw(`jsonb_set("col", '{attr}', to_jsonb("other"#>'{lol}'), true)`)
+      warnIfNotPostgres(knex);
 
       let parsed = ref(key);
       let jsonPath = toPostgresJsonPathLiteral(parsed.parsedExpr.access);

package/lib/queryBuilder/operations/jsonApi/WhereJsonHasPostgresOperation.js

@@ -5,6 +5,7 @@ const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConver
 
 class WhereJsonHasPostgresOperation extends ObjectionToKnexConvertingOperation {
   onBuildKnex(knexBuilder, builder) {
+    jsonApi.warnIfNotPostgres(builder.knex());
     const args = this.getKnexArgs(builder);
 
     const rawArgs = jsonApi.whereJsonFieldRightStringArrayOnLeftQuery(

package/lib/queryBuilder/operations/jsonApi/WhereJsonNotObjectPostgresOperation.js

@@ -5,6 +5,7 @@ const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConver
 
 class WhereJsonNotObjectPostgresOperation extends ObjectionToKnexConvertingOperation {
   onBuildKnex(knexBuilder, builder) {
+    jsonApi.warnIfNotPostgres(builder.knex());
     return this.whereJsonNotObject(knexBuilder, builder.knex(), this.getKnexArgs(builder)[0]);
   }
 

package/lib/queryBuilder/operations/jsonApi/WhereJsonPostgresOperation.js

@@ -2,9 +2,28 @@
 
 const jsonApi = require('./postgresJsonApi');
 const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
+const { parseFieldExpression } = require('../../../utils/parseFieldExpression');
+const { isPlainObject, isString, isFunction } = require('../../../utils/objectUtils');
+const { isMySql } = require('../../../utils/knexUtils');
 
 class WhereJsonPostgresOperation extends ObjectionToKnexConvertingOperation {
   onBuildKnex(knexBuilder, builder) {
+    const knex = builder.knex();
+
+    if (isMySql(knex) && this.canDelegateToKnex(knexBuilder)) {
+      // On MySQL, knex's version of the method works (ditojs#113). The `or`
+      // variants are wrapped in `orWhere()`, as knex < 3 ignores their `or`.
+      const [column, value] = this.getKnexArgs(builder);
+      const { knexMethod } = this.opt;
+
+      if (this.opt.bool === 'or') {
+        return knexBuilder.orWhere((qb) => qb[knexMethod](column, value));
+      } else {
+        return knexBuilder[knexMethod](column, value);
+      }
+    }
+
+    jsonApi.warnIfNotPostgres(knex);
     const args = this.getKnexArgs(builder);
 
     const rawArgs = jsonApi.whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams(
@@ -22,6 +41,20 @@ class WhereJsonPostgresOperation extends ObjectionToKnexConvertingOperation {
 
     return knexBuilder;
   }
+
+  // Only the simple form with a plain column and a plain object or array value
+  // can be passed on to knex, as knex doesn't understand field expressions.
+  canDelegateToKnex(knexBuilder) {
+    const [column, value] = this.args;
+
+    return (
+      !!this.opt.knexMethod &&
+      isFunction(knexBuilder[this.opt.knexMethod]) &&
+      isString(column) &&
+      parseFieldExpression(column).access.length === 0 &&
+      (isPlainObject(value) || Array.isArray(value))
+    );
+  }
 }
 
 module.exports = {

package/lib/queryBuilder/operations/jsonApi/postgresJsonApi.js

@@ -2,7 +2,8 @@
 
 const parser = require('../../../utils/parseFieldExpression');
 const { asArray, isObject, isString } = require('../../../utils/objectUtils');
-const { isKnexRaw, isKnexQueryBuilder } = require('../../../utils/knexUtils');
+const { isKnexRaw, isKnexQueryBuilder, isPostgres } = require('../../../utils/knexUtils');
+const { deprecate } = require('../../../utils/deprecate');
 
 /**
  * @typedef {String} FieldExpression
@@ -44,6 +45,19 @@ const { isKnexRaw, isKnexQueryBuilder } = require('../../../utils/knexUtils');
  *     not currently supported
  */
 
+// JSON field expressions and the `whereJson*()` methods generate Postgres-only
+// SQL (ditojs#113). As some of it happens to run on other databases, only warn.
+// TODO: Consider throwing an error instead in objection 4.0.
+function warnIfNotPostgres(knex) {
+  if (!isPostgres(knex)) {
+    deprecate(
+      'JSON field expressions and the whereJson*() methods of objection are only supported ' +
+        'on PostgreSQL. Use the JSON methods of knex like whereJsonPath() or jsonExtract() ' +
+        'with other databases.',
+    );
+  }
+}
+
 // Returns the SQL and bindings of a field expression. The column is passed as an
 // identifier binding (`??`), so that knex's `wrapIdentifier` (e.g. used by
 // `knexSnakeCaseMappers()`) is applied to it.
@@ -168,6 +182,7 @@ function normalizeOperator(knex, operator) {
 }
 
 module.exports = {
+  warnIfNotPostgres,
   parseFieldExpression: parseFieldExpression,
   whereJsonbRefOnLeftJsonbValOrRefOnRight: whereJsonbRefOnLeftJsonbValOrRefOnRight,
   whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams:

package/lib/queryBuilder/operations/select/SelectOperation.js

@@ -1,15 +1,30 @@
 'use strict';
 
-const { flatten } = require('../../../utils/objectUtils');
+const { flatten, isString, isPlainObject } = require('../../../utils/objectUtils');
 const { Selection } = require('./Selection');
 const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
 
 const COUNT_REGEX = /count/i;
+const ALIAS_REGEX = /\s+as\s+/i;
+
+const AGGREGATE_METHODS = new Set([
+  'count',
+  'countDistinct',
+  'min',
+  'max',
+  'sum',
+  'sumDistinct',
+  'avg',
+  'avgDistinct',
+]);
 
 class SelectOperation extends ObjectionToKnexConvertingOperation {
   constructor(name, opt) {
     super(name, opt);
     this.selections = [];
+    // The selections that aggregates select, by their aliases. `null` for
+    // non-aggregate operations.
+    this.aggregateSelections = AGGREGATE_METHODS.has(name) ? [] : null;
   }
 
   onAdd(builder, args) {
@@ -31,6 +46,12 @@ class SelectOperation extends ObjectionToKnexConvertingOperation {
       }
     }
 
+    if (this.aggregateSelections) {
+      this.aggregateSelections = getAggregateAliases(selections).map(
+        (alias) => new Selection(null, null, alias),
+      );
+    }
+
     return ret;
   }
 
@@ -57,10 +78,27 @@ class SelectOperation extends ObjectionToKnexConvertingOperation {
   clone() {
     const clone = super.clone();
     clone.selections = this.selections.slice();
+    clone.aggregateSelections = this.aggregateSelections && this.aggregateSelections.slice();
     return clone;
   }
 }
 
+// Returns the aliases of the columns an aggregate selects, supporting the same
+// argument forms as knex: `count('col as alias')`, `count('col', { as: 'alias' })`
+// and `count({ alias: 'col' })`. Aggregates without an alias are skipped, as
+// their column name differs between databases.
+function getAggregateAliases([column, options]) {
+  if (isString(column) && ALIAS_REGEX.test(column)) {
+    return [column.split(ALIAS_REGEX)[1].trim()];
+  } else if (isPlainObject(options) && isString(options.as)) {
+    return [options.as];
+  } else if (isPlainObject(column)) {
+    return Object.keys(column);
+  } else {
+    return [];
+  }
+}
+
 module.exports = {
   SelectOperation,
 };

package/lib/relations/RelationFindOperation.js

@@ -24,6 +24,7 @@ class RelationFindOperation extends FindOperation {
       this.warnOnMissingOwnerProps();
 
       if (this.assignResultToOwner) {
+        this.warnOnArrayOwnerProps();
         this.selectMissingJoinColumns(builder);
       }
     }
@@ -100,6 +101,25 @@ class RelationFindOperation extends FindOperation {
     }
   }
 
+  // Owner join properties holding an array of keys, e.g. a JSON array column,
+  // aren't supported: The query finds the related models, but they can't be
+  // assigned to their owners, so all owners silently get no related models
+  // (#2667). `$relatedQuery()` without assigning the results isn't affected.
+  warnOnArrayOwnerProps() {
+    const { ownerProp } = this.relation;
+
+    for (let c = 0, lc = ownerProp.size; c < lc; ++c) {
+      if (this.owner.modelArray.some((owner) => Array.isArray(ownerProp.getProp(owner, c)))) {
+        deprecate(
+          `Fetching relation "${this.relation.name}" of ${this.relation.ownerModelClass.name}: ` +
+            `the join property "${ownerProp.propDescription(c)}" of some owner models holds ` +
+            'an array, which is not supported, so no related models are found for them. ' +
+            'Use a ManyToManyRelation through a join table instead.',
+        );
+      }
+    }
+  }
+
   // Related models without the join properties can't be assigned to their
   // owners and are silently dropped (#2258). This happens for example when the
   // relation mapping uses column names but the rows come back with different

package/lib/relations/manyToMany/find/ManyToManyFindOperation.js

@@ -2,6 +2,7 @@
 
 const { RelationFindOperation } = require('../../RelationFindOperation');
 const { getTempColumn } = require('../../../utils/tmpColumnUtils');
+const { deprecate } = require('../../../utils/deprecate');
 
 class ManyToManyFindOperation extends RelationFindOperation {
   constructor(name, opt) {
@@ -34,8 +35,12 @@ class ManyToManyFindOperation extends RelationFindOperation {
       }
     }
 
-    if (this.assignResultToOwner && this.owner.isModels) {
-      this.selectMissingJoinColumns(builder);
+    if (this.owner.isModels) {
+      this.warnOnMissingOwnerProps();
+
+      if (this.assignResultToOwner) {
+        this.selectMissingJoinColumns(builder);
+      }
     }
   }
 
@@ -60,6 +65,8 @@ class ManyToManyFindOperation extends RelationFindOperation {
         arr.push(rel);
       }
 
+      this.warnOnMissingRelatedProps(related);
+
       for (let i = 0, l = owners.length; i < l; ++i) {
         const own = owners[i];
         const key = ownerProp.propKey(own);
@@ -76,6 +83,27 @@ class ManyToManyFindOperation extends RelationFindOperation {
     return related;
   }
 
+  // The related models are assigned to their owners by the owner join columns
+  // selected from the join table. If they get lost, e.g. in a custom
+  // `$parseDatabaseJson()`, the related models are silently dropped (#2258).
+  warnOnMissingRelatedProps(related) {
+    const { joinTableOwnerProp } = this.relation;
+
+    for (let c = 0, lc = this.ownerJoinColumnAlias.length; c < lc; ++c) {
+      const alias = this.ownerJoinColumnAlias[c];
+
+      if (related.some((rel) => rel[alias] === undefined)) {
+        deprecate(
+          `Fetching relation "${this.relation.name}" of ${this.relation.ownerModelClass.name}: ` +
+            `some related models are missing the join table column ` +
+            `"${joinTableOwnerProp.propDescription(c)}" selected as "${alias}", so they are not ` +
+            'assigned to any owner. Check that $parseDatabaseJson() and the column name mappers ' +
+            'of the related model keep it.',
+        );
+      }
+    }
+  }
+
   clone() {
     const clone = super.clone();
     clone.ownerJoinColumnAlias = this.ownerJoinColumnAlias.slice();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "objection",
-  "version": "3.4.0",
+  "version": "3.4.1",
   "description": "An SQL-friendly ORM for Node.js",
   "main": "lib/objection.js",
   "license": "MIT",