objection 3.9.1 → 4.0.0-rc.2

package/lib/queryBuilder/QueryBuilderBase.js

@@ -1,32 +1,20 @@
-'use strict';
-
-const { QueryBuilderOperationSupport } = require('./QueryBuilderOperationSupport');
-const { isSqlite, isMsSql } = require('../utils/knexUtils');
-
-const { KnexOperation } = require('./operations/KnexOperation');
-const { MergeOperation } = require('./operations/MergeOperation');
-const { SelectOperation } = require('./operations/select/SelectOperation');
-const { ReturningOperation } = require('./operations/ReturningOperation');
-const { WhereCompositeOperation } = require('./operations/WhereCompositeOperation');
-const { WhereJsonPostgresOperation } = require('./operations/jsonApi/WhereJsonPostgresOperation');
-
-const {
-  WhereInCompositeOperation,
-} = require('./operations/whereInComposite/WhereInCompositeOperation');
-const {
-  WhereInCompositeSqliteOperation,
-} = require('./operations/whereInComposite/WhereInCompositeSqliteOperation');
-const {
-  WhereInCompositeMsSqlOperation,
-} = require('./operations/whereInComposite/WhereInCompositeMsSqlOperation');
-const {
-  WhereJsonHasPostgresOperation,
-} = require('./operations/jsonApi/WhereJsonHasPostgresOperation');
-const {
-  WhereJsonNotObjectPostgresOperation,
-} = require('./operations/jsonApi/WhereJsonNotObjectPostgresOperation');
-
-class QueryBuilderBase extends QueryBuilderOperationSupport {
+import { QueryBuilderOperationSupport } from './QueryBuilderOperationSupport.js';
+import { isSqlite, isMsSql } from '../utils/knexUtils.js';
+
+import { KnexOperation } from './operations/KnexOperation.js';
+import { MergeOperation } from './operations/MergeOperation.js';
+import { SelectOperation } from './operations/select/SelectOperation.js';
+import { ReturningOperation } from './operations/ReturningOperation.js';
+import { WhereCompositeOperation } from './operations/WhereCompositeOperation.js';
+import { WhereJsonOperation } from './operations/jsonApi/WhereJsonOperation.js';
+
+import { WhereInCompositeOperation } from './operations/whereInComposite/WhereInCompositeOperation.js';
+import { WhereInCompositeSqliteOperation } from './operations/whereInComposite/WhereInCompositeSqliteOperation.js';
+import { WhereInCompositeMsSqlOperation } from './operations/whereInComposite/WhereInCompositeMsSqlOperation.js';
+import { WhereJsonHasOperation } from './operations/jsonApi/WhereJsonHasOperation.js';
+import { WhereJsonTypeOperation } from './operations/jsonApi/WhereJsonTypeOperation.js';
+
+export class QueryBuilderBase extends QueryBuilderOperationSupport {
   modify(...args) {
     const func = args[0];
 
@@ -613,19 +601,8 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
     return this.addOperation(new KnexOperation('andWhereJsonPath'), args);
   }
 
-  // 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',
-        knexMethod: 'whereJsonSupersetOf',
-      }),
-      args,
-    );
+    return this.addOperation(new WhereJsonOperation('whereJsonSupersetOf', { bool: 'and' }), args);
   }
 
   andWhereJsonSupersetOf(...args) {
@@ -633,24 +610,12 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
   }
 
   orWhereJsonSupersetOf(...args) {
-    return this.addOperation(
-      new WhereJsonPostgresOperation('orWhereJsonSupersetOf', {
-        operator: '@>',
-        bool: 'or',
-        knexMethod: 'whereJsonSupersetOf',
-      }),
-      args,
-    );
+    return this.addOperation(new WhereJsonOperation('orWhereJsonSupersetOf', { bool: 'or' }), args);
   }
 
   whereJsonNotSupersetOf(...args) {
     return this.addOperation(
-      new WhereJsonPostgresOperation('whereJsonNotSupersetOf', {
-        operator: '@>',
-        bool: 'and',
-        prefix: 'not',
-        knexMethod: 'whereJsonNotSupersetOf',
-      }),
+      new WhereJsonOperation('whereJsonNotSupersetOf', { bool: 'and', not: true }),
       args,
     );
   }
@@ -661,23 +626,14 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
 
   orWhereJsonNotSupersetOf(...args) {
     return this.addOperation(
-      new WhereJsonPostgresOperation('orWhereJsonNotSupersetOf', {
-        operator: '@>',
-        bool: 'or',
-        prefix: 'not',
-        knexMethod: 'whereJsonNotSupersetOf',
-      }),
+      new WhereJsonOperation('orWhereJsonNotSupersetOf', { bool: 'or', not: true }),
       args,
     );
   }
 
   whereJsonSubsetOf(...args) {
     return this.addOperation(
-      new WhereJsonPostgresOperation('whereJsonSubsetOf', {
-        operator: '<@',
-        bool: 'and',
-        knexMethod: 'whereJsonSubsetOf',
-      }),
+      new WhereJsonOperation('whereJsonSubsetOf', { bool: 'and', subset: true }),
       args,
     );
   }
@@ -688,23 +644,14 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
 
   orWhereJsonSubsetOf(...args) {
     return this.addOperation(
-      new WhereJsonPostgresOperation('orWhereJsonSubsetOf', {
-        operator: '<@',
-        bool: 'or',
-        knexMethod: 'whereJsonSubsetOf',
-      }),
+      new WhereJsonOperation('orWhereJsonSubsetOf', { bool: 'or', subset: true }),
       args,
     );
   }
 
   whereJsonNotSubsetOf(...args) {
     return this.addOperation(
-      new WhereJsonPostgresOperation('whereJsonNotSubsetOf', {
-        operator: '<@',
-        bool: 'and',
-        prefix: 'not',
-        knexMethod: 'whereJsonNotSubsetOf',
-      }),
+      new WhereJsonOperation('whereJsonNotSubsetOf', { bool: 'and', subset: true, not: true }),
       args,
     );
   }
@@ -715,111 +662,86 @@ class QueryBuilderBase extends QueryBuilderOperationSupport {
 
   orWhereJsonNotSubsetOf(...args) {
     return this.addOperation(
-      new WhereJsonPostgresOperation('orWhereJsonNotSubsetOf', {
-        operator: '<@',
-        bool: 'or',
-        prefix: 'not',
-        knexMethod: 'whereJsonNotSubsetOf',
-      }),
+      new WhereJsonOperation('orWhereJsonNotSubsetOf', { bool: 'or', subset: true, not: true }),
       args,
     );
   }
 
   whereJsonNotArray(...args) {
     return this.addOperation(
-      new WhereJsonNotObjectPostgresOperation('whereJsonNotArray', {
-        bool: 'and',
-        compareValue: [],
-      }),
+      new WhereJsonTypeOperation('whereJsonNotArray', { bool: 'and', type: 'array', not: true }),
       args,
     );
   }
 
   orWhereJsonNotArray(...args) {
     return this.addOperation(
-      new WhereJsonNotObjectPostgresOperation('orWhereJsonNotArray', {
-        bool: 'or',
-        compareValue: [],
-      }),
+      new WhereJsonTypeOperation('orWhereJsonNotArray', { bool: 'or', type: 'array', not: true }),
       args,
     );
   }
 
   whereJsonNotObject(...args) {
     return this.addOperation(
-      new WhereJsonNotObjectPostgresOperation('whereJsonNotObject', {
-        bool: 'and',
-        compareValue: {},
-      }),
+      new WhereJsonTypeOperation('whereJsonNotObject', { bool: 'and', type: 'object', not: true }),
       args,
     );
   }
 
   orWhereJsonNotObject(...args) {
     return this.addOperation(
-      new WhereJsonNotObjectPostgresOperation('orWhereJsonNotObject', {
-        bool: 'or',
-        compareValue: {},
-      }),
+      new WhereJsonTypeOperation('orWhereJsonNotObject', { bool: 'or', type: 'object', not: true }),
       args,
     );
   }
 
   whereJsonHasAny(...args) {
-    return this.addOperation(
-      new WhereJsonHasPostgresOperation('whereJsonHasAny', { bool: 'and', operator: '?|' }),
-      args,
-    );
+    return this.addOperation(new WhereJsonHasOperation('whereJsonHasAny', { bool: 'and' }), args);
   }
 
   orWhereJsonHasAny(...args) {
-    return this.addOperation(
-      new WhereJsonHasPostgresOperation('orWhereJsonHasAny', { bool: 'or', operator: '?|' }),
-      args,
-    );
+    return this.addOperation(new WhereJsonHasOperation('orWhereJsonHasAny', { bool: 'or' }), args);
   }
 
   whereJsonHasAll(...args) {
     return this.addOperation(
-      new WhereJsonHasPostgresOperation('whereJsonHasAll', { bool: 'and', operator: '?&' }),
+      new WhereJsonHasOperation('whereJsonHasAll', { bool: 'and', all: true }),
       args,
     );
   }
 
   orWhereJsonHasAll(...args) {
     return this.addOperation(
-      new WhereJsonHasPostgresOperation('orWhereJsonHasAll', { bool: 'or', operator: '?&' }),
+      new WhereJsonHasOperation('orWhereJsonHasAll', { bool: 'or', all: true }),
       args,
     );
   }
 
-  // Not passed on to knex like `whereJsonSupersetOf()`, as MySQL's `json_contains()`
-  // also matches `{}` in arrays of objects.
   whereJsonIsArray(fieldExpression) {
     return this.addOperation(
-      new WhereJsonPostgresOperation('whereJsonSupersetOf', { operator: '@>', bool: 'and' }),
-      [fieldExpression, []],
+      new WhereJsonTypeOperation('whereJsonIsArray', { bool: 'and', type: 'array' }),
+      [fieldExpression],
     );
   }
 
   orWhereJsonIsArray(fieldExpression) {
     return this.addOperation(
-      new WhereJsonPostgresOperation('orWhereJsonSupersetOf', { operator: '@>', bool: 'or' }),
-      [fieldExpression, []],
+      new WhereJsonTypeOperation('orWhereJsonIsArray', { bool: 'or', type: 'array' }),
+      [fieldExpression],
     );
   }
 
   whereJsonIsObject(fieldExpression) {
     return this.addOperation(
-      new WhereJsonPostgresOperation('whereJsonSupersetOf', { operator: '@>', bool: 'and' }),
-      [fieldExpression, {}],
+      new WhereJsonTypeOperation('whereJsonIsObject', { bool: 'and', type: 'object' }),
+      [fieldExpression],
     );
   }
 
   orWhereJsonIsObject(fieldExpression) {
     return this.addOperation(
-      new WhereJsonPostgresOperation('orWhereJsonSupersetOf', { operator: '@>', bool: 'or' }),
-      [fieldExpression, {}],
+      new WhereJsonTypeOperation('orWhereJsonIsObject', { bool: 'or', type: 'object' }),
+      [fieldExpression],
     );
   }
 
@@ -867,7 +789,3 @@ Object.defineProperties(QueryBuilderBase.prototype, {
     value: true,
   },
 });
-
-module.exports = {
-  QueryBuilderBase,
-};

package/lib/queryBuilder/QueryBuilderContext.js

@@ -1,8 +1,6 @@
-'use strict';
+import { QueryBuilderContextBase } from './QueryBuilderContextBase.js';
 
-const { QueryBuilderContextBase } = require('./QueryBuilderContextBase');
-
-class QueryBuilderContext extends QueryBuilderContextBase {
+export class QueryBuilderContext extends QueryBuilderContextBase {
   constructor(builder) {
     super(builder);
 
@@ -21,7 +19,3 @@ class QueryBuilderContext extends QueryBuilderContextBase {
     return ctx;
   }
 }
-
-module.exports = {
-  QueryBuilderContext,
-};

package/lib/queryBuilder/QueryBuilderContextBase.js

@@ -1,8 +1,6 @@
-'use strict';
+import { InternalOptions } from './InternalOptions.js';
 
-const { InternalOptions } = require('./InternalOptions');
-
-class QueryBuilderContextBase {
+export class QueryBuilderContextBase {
   constructor(builder) {
     this.userContext = builder ? new builder.constructor.QueryBuilderUserContext(builder) : null;
     this.options = builder ? new this.constructor.InternalOptions() : null;
@@ -29,7 +27,3 @@ class QueryBuilderContextBase {
     return ctx;
   }
 }
-
-module.exports = {
-  QueryBuilderContextBase,
-};

package/lib/queryBuilder/QueryBuilderOperationSupport.js

@@ -1,10 +1,7 @@
-'use strict';
-
-const { isString, isFunction, isRegExp, mergeMaps, last } = require('../utils/objectUtils');
-const { QueryBuilderContextBase } = require('./QueryBuilderContextBase');
-const { QueryBuilderUserContext } = require('./QueryBuilderUserContext');
-const { deprecate } = require('../utils/warnings');
-const { getWhereGroupOperations } = require('./whereGroups');
+import { isString, isFunction, isRegExp, mergeMaps, last } from '../utils/objectUtils.js';
+import { QueryBuilderContextBase } from './QueryBuilderContextBase.js';
+import { QueryBuilderUserContext } from './QueryBuilderUserContext.js';
+import { getWhereGroupOperations } from './whereGroups.js';
 
 const AllSelector = () => true;
 const SelectSelector =
@@ -15,7 +12,7 @@ const OrderBySelector = /orderBy/;
 const JoinSelector = /(join|joinRaw|joinRelated)$/i;
 const FromSelector = /^(from|fromRaw|into|table)$/;
 
-class QueryBuilderOperationSupport {
+export class QueryBuilderOperationSupport {
   constructor(...args) {
     this.constructor.init(this, ...args);
   }
@@ -415,9 +412,8 @@ class QueryBuilderOperationSupport {
     const shouldAdd = this.callOperationMethod(operation, 'onAdd', [this, args]);
 
     if (shouldAdd) {
-      if (this._whereGroup) {
-        operation.whereGroup = this._whereGroup;
-      }
+      // Operations with their own where group, like `findById()`, keep it.
+      operation.whereGroup ??= this._whereGroup;
 
       if (this._activeOperations.length) {
         const { operation: parentOperation, hookName } = last(this._activeOperations);
@@ -520,12 +516,6 @@ class QueryBuilderOperationSupport {
   toSql() {
     return this.toString();
   }
-
-  skipUndefined() {
-    deprecate('skipUndefined() is deprecated and will be removed in objection 4.0');
-    this.internalOptions().skipUndefined = true;
-    return this;
-  }
 }
 
 function buildFunctionForOperationSelector(operationSelector) {
@@ -546,7 +536,3 @@ function buildFunctionForOperationSelector(operationSelector) {
     return () => false;
   }
 }
-
-module.exports = {
-  QueryBuilderOperationSupport,
-};

package/lib/queryBuilder/QueryBuilderUserContext.js

@@ -1,8 +1,6 @@
-'use strict';
-
 const SYMBOL_BUILDER = Symbol();
 
-class QueryBuilderUserContext {
+export class QueryBuilderUserContext {
   constructor(builder) {
     // This should never ever be accessed outside this class. We only
     // store it so that we can access builder.knex() lazily.
@@ -25,7 +23,3 @@ class QueryBuilderUserContext {
     return ctx;
   }
 }
-
-module.exports = {
-  QueryBuilderUserContext,
-};

package/lib/queryBuilder/RawBuilder.js

@@ -1,9 +1,7 @@
-'use strict';
+import { isPlainObject } from '../utils/objectUtils.js';
+import { buildArg } from '../utils/buildUtils.js';
 
-const { isPlainObject } = require('../utils/objectUtils');
-const { buildArg } = require('../utils/buildUtils');
-
-class RawBuilder {
+export class RawBuilder {
   constructor(sql, args) {
     this._sql = `${sql}`;
     this._args = args;
@@ -62,7 +60,7 @@ function buildObject(obj, builder) {
   }, {});
 }
 
-function normalizeRawArgs(argsIn) {
+export function normalizeRawArgs(argsIn) {
   const [sql, ...restArgs] = argsIn;
 
   if (restArgs.length === 1 && Array.isArray(restArgs[0])) {
@@ -78,13 +76,7 @@ function normalizeRawArgs(argsIn) {
   }
 }
 
-function raw(...argsIn) {
+export function raw(...argsIn) {
   const { sql, args } = normalizeRawArgs(argsIn);
   return new RawBuilder(sql, args);
 }
-
-module.exports = {
-  RawBuilder,
-  normalizeRawArgs,
-  raw,
-};

package/lib/queryBuilder/ReferenceBuilder.js

@@ -1,13 +1,8 @@
-'use strict';
+import { parseFieldExpression } from '../utils/parseFieldExpression.js';
+import { isObject } from '../utils/objectUtils.js';
+import { getJsonDialect } from './jsonDialects/index.js';
 
-const {
-  parseFieldExpression,
-  toPostgresJsonPathLiteral,
-} = require('../utils/parseFieldExpression');
-const { isObject } = require('../utils/objectUtils');
-const { warnIfNotPostgres } = require('./operations/jsonApi/postgresJsonApi');
-
-class ReferenceBuilder {
+export class ReferenceBuilder {
   constructor(expr) {
     this._expr = expr;
     this._parsedExpr = null;
@@ -164,13 +159,7 @@ class ReferenceBuilder {
   }
 
   toKnexRaw(builder) {
-    const knex = builder.knex();
-
-    if (this._parsedExpr.access.length > 0) {
-      warnIfNotPostgres(knex);
-    }
-
-    return knex.raw(...this._createRawArgs(builder));
+    return builder.knex().raw(...this._createRawArgs(builder));
   }
 
   _parseExpression(expr) {
@@ -180,41 +169,29 @@ class ReferenceBuilder {
   }
 
   _createRawArgs(builder) {
-    let bindings = [];
-    let sql = this._createReferenceSql(builder, bindings);
-
-    sql = this._maybeCast(sql, bindings);
-    sql = this._maybeToJsonb(sql, bindings);
-    sql = this._maybeAlias(sql, bindings);
+    const dialect = getJsonDialect(builder.knex());
+    const { access } = this._parsedExpr;
+    const bindings = [this.fullColumn(builder)];
+    let sql = '??';
 
-    return [sql, bindings];
-  }
-
-  _createReferenceSql(builder, bindings) {
-    bindings.push(this.fullColumn(builder));
+    if (access.length > 0 || this._toJson) {
+      dialect.checkSupport();
+    }
 
-    if (this._parsedExpr.access.length > 0) {
-      const extractor = this._cast ? '#>>' : '#>';
-      return `??${extractor}${toPostgresJsonPathLiteral(this._parsedExpr.access)}`;
-    } else {
-      return '??';
+    if (access.length > 0) {
+      sql = dialect.extract(sql, access, this._cast);
     }
-  }
 
-  _maybeCast(sql) {
     if (this._cast) {
-      return `CAST(${sql} AS ${this._cast})`;
-    } else {
-      return sql;
+      sql = dialect.cast(sql, this._cast);
     }
-  }
 
-  _maybeToJsonb(sql) {
     if (this._toJson) {
-      return `to_jsonb(${sql})`;
-    } else {
-      return sql;
+      sql = dialect.toJson(sql, access.length === 0 && !this._cast);
     }
+
+    sql = this._maybeAlias(sql, bindings);
+    return [sql, bindings];
   }
 
   _maybeAlias(sql, bindings) {
@@ -247,15 +224,10 @@ Object.defineProperties(ReferenceBuilder.prototype, {
   },
 });
 
-const ref = (reference) => {
+export const ref = (reference) => {
   if (isObject(reference) && reference.isObjectionReferenceBuilder) {
     return reference;
   } else {
     return new ReferenceBuilder(reference);
   }
 };
-
-module.exports = {
-  ReferenceBuilder,
-  ref,
-};

package/lib/queryBuilder/RelationExpression.js

@@ -1,18 +1,24 @@
-'use strict';
+import * as parser from './parsers/relationExpressionParser.js';
+import { isObject, isNumber, isString, union } from '../utils/objectUtils.js';
+import { RelationDoesNotExistError } from '../model/RelationDoesNotExistError.js';
 
-const parser = require('./parsers/relationExpressionParser');
-const { isObject, isNumber, isString, union } = require('../utils/objectUtils');
-const { RelationDoesNotExistError } = require('../model/RelationDoesNotExistError');
-
-class RelationExpressionParseError extends Error {}
-class DuplicateRelationError extends RelationExpressionParseError {
+export class RelationExpressionParseError extends Error {}
+export class DuplicateRelationError extends RelationExpressionParseError {
   constructor(relationName) {
-    super();
-    this.relationName = relationName;
+    super(
+      `Duplicate relation name "${relationName}". For example, use "${relationName}.[foo, bar]" ` +
+        `instead of "[${relationName}.foo, ${relationName}.bar]".`,
+    );
+  }
+}
+
+export class MisplacedTokenError extends RelationExpressionParseError {
+  constructor(token) {
+    super(`"${token}" is only supported at the end of a relation path.`);
   }
 }
 
-class RelationExpression {
+export class RelationExpression {
   constructor(node = newNode(), recursionDepth = 0) {
     this.node = node;
     this.recursionDepth = recursionDepth;
@@ -36,6 +42,8 @@ class RelationExpression {
         } catch (err) {
           if (err.duplicateRelationName) {
             throw new DuplicateRelationError(err.duplicateRelationName);
+          } else if (err.misplacedToken) {
+            throw new MisplacedTokenError(err.misplacedToken);
           } else {
             throw new RelationExpressionParseError(err.message);
           }
@@ -437,9 +445,3 @@ Object.defineProperties(RelationExpression.prototype, {
     value: true,
   },
 });
-
-module.exports = {
-  RelationExpression,
-  RelationExpressionParseError,
-  DuplicateRelationError,
-};