objection 3.9.1 → 4.0.0-rc.1

package/lib/queryBuilder/join/JoinResultColumn.js

@@ -1,6 +1,4 @@
-'use strict';
-
-class JoinResultColumn {
+export class JoinResultColumn {
   constructor({ columnAlias, tableNode, name }) {
     this.columnAlias = columnAlias;
     this.tableNode = tableNode;
@@ -17,7 +15,3 @@ class JoinResultColumn {
     });
   }
 }
-
-module.exports = {
-  JoinResultColumn,
-};

package/lib/queryBuilder/join/JoinResultParser.js

@@ -1,11 +1,10 @@
-'use strict';
+import { JoinResultColumn } from './JoinResultColumn.js';
+import { groupBy } from '../../utils/objectUtils.js';
 
-const { JoinResultColumn } = require('./JoinResultColumn');
-const { groupBy } = require('../../utils/objectUtils');
-
-class JoinResultParser {
-  constructor({ tableTree, omitColumnAliases = [] }) {
+export class JoinResultParser {
+  constructor({ tableTree, knex, omitColumnAliases = [] }) {
     this.tableTree = tableTree;
+    this.modelOptions = { knex };
     this.omitColumnAliases = new Set(omitColumnAliases);
 
     this.columnsByTableNode = null;
@@ -71,7 +70,7 @@ class JoinResultParser {
       }
     }
 
-    const model = tableNode.modelClass.fromDatabaseJson(row);
+    const model = tableNode.modelClass.fromDatabaseJson(row, this.modelOptions);
 
     for (const childNode of tableNode.childNodes) {
       if (childNode.relation.isOneToOne()) {
@@ -140,7 +139,3 @@ function getKey(parentKey, id) {
     return escapedId;
   }
 }
-
-module.exports = {
-  JoinResultParser,
-};

package/lib/queryBuilder/join/RelationJoiner.js

@@ -1,20 +1,18 @@
-'use strict';
+import { uniqBy } from '../../utils/objectUtils.js';
+import { Selection, isSameTable, mapIdentifier } from '../operations/select/Selection.js';
+import { SelectOperation } from '../operations/select/SelectOperation.js';
+import { createModifier } from '../../utils/createModifier.js';
+import { map as mapPromise } from '../../utils/promiseUtils/index.js';
+import { ValidationErrorType } from '../../model/ValidationError.js';
 
-const { uniqBy } = require('../../utils/objectUtils');
-const { Selection, isSameTable, mapIdentifier } = 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');
-
-const { TableTree } = require('./TableTree');
-const { JoinResultParser } = require('./JoinResultParser');
-const { getIdentifierLengthLimit } = require('./utils');
+import { TableTree } from './TableTree.js';
+import { JoinResultParser } from './JoinResultParser.js';
+import { getIdentifierLengthLimit } from './utils.js';
 
 /**
  * Given a relation expression, builds a query using joins to fetch it.
  */
-class RelationJoiner {
+export class RelationJoiner {
   constructor({ modelClass }) {
     this.rootModelClass = modelClass;
 
@@ -99,6 +97,7 @@ class RelationJoiner {
   parseResult(builder, flatRows) {
     const parser = JoinResultParser.create({
       tableTree: this._getTableTree(builder),
+      knex: builder.knex(),
       omitColumnAliases: this.internalSelections.map((it) => it.alias),
     });
 
@@ -132,7 +131,7 @@ class RelationJoiner {
     // also contain selects.
     userSelectQuery.modify(tableNode.relation.modify);
 
-    if (selectsOnlyAliasesKeepingSelectAll(findJoinSelections(userSelectQuery))) {
+    if (selectsOnlyAliasesKeepingSelectAll(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()}.*`);
@@ -142,8 +141,23 @@ class RelationJoiner {
     // for later use.
     userSelectQueries.set(tableNode, userSelectQuery);
 
+    const path = getRelationPath(tableNode);
+    // The `modifyJoin()` modifiers whose path ends at this relation:
+    const joinModifiers = builder
+      .joinModifiersAtPath()
+      .filter((it) => getExpressionAtPath(it.path, path)?.isEmpty)
+      .map((it) => it.modifier);
+
     tableNode.relation.join(builder, {
-      joinOperation: this._getJoinOperation(tableNode),
+      joinOperation: this._getJoinOperation(path),
+      modifyJoin:
+        joinModifiers.length > 0
+          ? (join, aliases) => {
+              for (const modifier of joinModifiers) {
+                modifier(join, aliases);
+              }
+            }
+          : undefined,
 
       ownerTable: tableNode.parentNode.alias,
       relatedTableAlias: tableNode.alias,
@@ -161,18 +175,12 @@ class RelationJoiner {
   }
 
   // Returns the `joinOperation` of the last `withGraphJoined` call that
-  // contains the relation of `tableNode`, falling back to the default.
-  _getJoinOperation(tableNode) {
-    const path = [];
-
-    for (let node = tableNode; node.parentNode; node = node.parentNode) {
-      path.unshift(node.relationProperty);
-    }
-
+  // contains the relation path, falling back to the default.
+  _getJoinOperation(path) {
     for (let i = this.joinOperations.length - 1; i >= 0; --i) {
       const { expression, joinOperation } = this.joinOperations[i];
 
-      if (containsPath(expression, path)) {
+      if (getExpressionAtPath(expression, path)) {
         return joinOperation;
       }
     }
@@ -216,7 +224,7 @@ class RelationJoiner {
     const tableTree = this._getTableTree(builder);
     const userSelectionsByName = new Map();
 
-    for (const selection of findJoinSelections(builder)) {
+    for (const selection of builder.findAllSelections()) {
       // Only the columns of the joined tables are known for `table.*`:
       const node = isSelectAll(selection) ? tableTree.nodesByAlias.get(selection.table) : null;
       const names = node
@@ -276,16 +284,26 @@ function defaultOptions() {
   };
 }
 
-function containsPath(expression, path) {
+function getRelationPath(tableNode) {
+  const path = [];
+
+  for (let node = tableNode; node.parentNode; node = node.parentNode) {
+    path.unshift(node.relationProperty);
+  }
+
+  return path;
+}
+
+function getExpressionAtPath(expression, path) {
   for (const name of path) {
     expression = expression.childExpression(name);
 
     if (!expression) {
-      return false;
+      return null;
     }
   }
 
-  return true;
+  return expression;
 }
 
 function createSubqueryToJoin({ builder, tableNode, modifiers }) {
@@ -328,9 +346,8 @@ function ensureIdAndRelationPropsAreSelected({ builder, tableNode }) {
     ),
   ];
 
-  const hasSelectionAs = createHasSelectionAs(builder);
   const selectStrings = uniqBy(cols)
-    .filter((col) => !hasSelectionAs(col))
+    .filter((col) => !builder.hasSelectionAs(col, col))
     .map((col) => `${tableRef}.${col}`);
 
   return builder.select(selectStrings);
@@ -338,8 +355,8 @@ function ensureIdAndRelationPropsAreSelected({ builder, tableNode }) {
 
 function getSelectionsForNode({ builder, tableNode, userSelectQueries }) {
   const userSelectQuery = userSelectQueries.get(tableNode);
-  const userSelections = findUserSelections(userSelectQuery, tableNode);
-  const userSelectedAllColumns = isSelectAllSelectionSet(userSelections);
+  const userSelections = userSelectQuery.findAllSelections();
+  const userSelectedAllColumns = isSelectAllSelectionSet(userSelectQuery);
 
   let selections = [];
   let internalSelections = [];
@@ -381,57 +398,15 @@ 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;
-}
-
-// Create a `(column) => builder.hasSelectionAs(column, column)` function that
-// ignores the columns passed to aggregates, as they don't select them. Clone
-// the builder once, not once per column.
-function createHasSelectionAs(builder) {
-  if (builder.has(isAggregateOperation)) {
-    const selectionQuery = builder.clone().clear(isAggregateOperation);
-    // Explicit, as a query with only aggregates doesn't select all columns.
-    return (column) => selectionQuery.hasSelectionAs(column, column, true);
-  } else {
-    return (column) => 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 createHasUserSelectionAs(builder, tableNode) {
   if (tableNode.parentNode) {
-    return createHasSelectionAs(builder);
+    return (column) => builder.hasSelectionAs(column, column);
   } else {
     // Qualified, as the root query can also select the columns of the joined tables.
     return (column) => builder.hasSelectionAs(`${tableNode.alias}.${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(
@@ -490,7 +465,7 @@ function removeRootSelectAll(builder) {
     selection.column === '*' &&
     (!selection.table || isSameTable(builder, selection.table, tableRef));
   const isSelect = (op) =>
-    op.constructor === SelectOperation && !isAggregateOperation(op) && !op.isDistinctOn;
+    op.constructor === SelectOperation && !op.isAggregate && !op.isDistinctOn;
 
   builder.forEachOperation(isSelect, (op) => {
     op.args = op.args.filter((arg) => {
@@ -524,17 +499,28 @@ function isNotSelectAll(selection) {
   return selection.column !== '*';
 }
 
-function isSelectAllSelectionSet(selections) {
-  selections = selections.filter(isNotKeepingSelectAll);
-  return selections.length === 0 || selections.some(isSelectAll);
+// Aggregates without an alias select no column that we can name, but they
+// still replace the select all.
+function isSelectAllSelectionSet(builder) {
+  const selections = builder.findAllSelections().filter(isNotKeepingSelectAll);
+  return (selections.length === 0 && !builder.has(isAggregate)) || selections.some(isSelectAll);
 }
 
 function isNotKeepingSelectAll(selection) {
   return !selection.keepsSelectAll;
 }
 
-function selectsOnlyAliasesKeepingSelectAll(selections) {
-  return selections.length > 0 && selections.every((it) => it.keepsSelectAll);
+function selectsOnlyAliasesKeepingSelectAll(builder) {
+  const selections = builder.findAllSelections();
+  return (
+    selections.length > 0 &&
+    selections.every((it) => it.keepsSelectAll) &&
+    !builder.has(isAggregate)
+  );
+}
+
+function isAggregate(op) {
+  return op.constructor === SelectOperation && op.isAggregate;
 }
 
 function checkAliasLength(modelClass, alias, lengthLimit) {
@@ -547,7 +533,3 @@ function checkAliasLength(modelClass, alias, lengthLimit) {
     });
   }
 }
-
-module.exports = {
-  RelationJoiner,
-};

package/lib/queryBuilder/join/TableNode.js

@@ -1,8 +1,6 @@
-'use strict';
+import { propKey, hasProps } from '../../model/modelValues.js';
 
-const { propKey, hasProps } = require('../../model/modelValues');
-
-class TableNode {
+export class TableNode {
   constructor({ tableTree, modelClass, expression, parentNode = null, relation = null }) {
     this.tableTree = tableTree;
     this.modelClass = modelClass;
@@ -95,7 +93,3 @@ class TableNode {
     return (flatRow) => (hasProps(flatRow, columnAliases) ? propKey(flatRow, columnAliases) : null);
   }
 }
-
-module.exports = {
-  TableNode,
-};

package/lib/queryBuilder/join/TableTree.js

@@ -1,9 +1,7 @@
-'use strict';
+import { forEachChildExpression } from './utils.js';
+import { TableNode } from './TableNode.js';
 
-const { forEachChildExpression } = require('./utils');
-const { TableNode } = require('./TableNode');
-
-class TableTree {
+export class TableTree {
   constructor({ expression, rootModelClass, rootTableAlias, options }) {
     this.options = options;
     this.rootModelClass = rootModelClass;
@@ -79,7 +77,3 @@ class TableTree {
     });
   }
 }
-
-module.exports = {
-  TableTree,
-};

package/lib/queryBuilder/join/utils.js

@@ -1,14 +1,12 @@
-'use strict';
+import { ValidationErrorType } from '../../model/ValidationError.js';
+import { isPostgres, isMySql, isMsSql, isSqlite } from '../../utils/knexUtils.js';
 
-const { ValidationErrorType } = require('../../model/ValidationError');
-const { isPostgres, isMySql, isMsSql, isSqlite } = require('../../utils/knexUtils');
-
-const RELATION_RECURSION_LIMIT = 64;
+export const RELATION_RECURSION_LIMIT = 64;
 
 // The maximum length of the column aliases of the joined relations, after
 // which the database would truncate them. Other databases keep the limit of
 // postgres, which isn't the strictest one: Oracle before 12.2 only allows 30.
-function getIdentifierLengthLimit(knex) {
+export function getIdentifierLengthLimit(knex) {
   if (isPostgres(knex)) {
     return 63;
   } else if (isMySql(knex)) {
@@ -23,7 +21,7 @@ function getIdentifierLengthLimit(knex) {
 }
 
 // Given a relation expression, goes through all first level children.
-function forEachChildExpression(expr, modelClass, callback) {
+export function forEachChildExpression(expr, modelClass, callback) {
   if (expr.node.$allRecursive || expr.maxRecursionDepth > RELATION_RECURSION_LIMIT) {
     throw modelClass.createValidationError({
       type: ValidationErrorType.RelationExpression,
@@ -33,11 +31,3 @@ function forEachChildExpression(expr, modelClass, callback) {
 
   expr.forEachChildExpression(modelClass, callback);
 }
-
-module.exports = {
-  RELATION_RECURSION_LIMIT,
-
-  getIdentifierLengthLimit,
-
-  forEachChildExpression,
-};

package/lib/queryBuilder/jsonDialects/JsonDialect.js

@@ -0,0 +1,51 @@
+// Renders the SQL of json field expressions like `ref('column:a.b')`, their
+// casts and the json values of `val()` for one database. The json methods are
+// implemented by the subclasses of the databases that support them.
+export class JsonDialect {
+  // Throw or warn for databases that can't render json field expressions.
+  // @overridable
+  checkSupport() {}
+
+  // @overridable
+  cast(sql, type) {
+    return `CAST(${sql} AS ${type})`;
+  }
+
+  // Turn the json text of a binding into a json value.
+  // @overridable
+  json(sql) {
+    return sql;
+  }
+
+  // Reference the bare column if there is no path, so that the database can use
+  // its indexes.
+  field(sql, access) {
+    return access.length > 0 ? this.extract(sql, access) : sql;
+  }
+
+  // Turn the operands of `superset()` and `subset()` into json values.
+  // @overridable
+  jsonOperand(sql) {
+    return sql;
+  }
+
+  // The operands are pairs of SQL and bindings, so they can swap places:
+  // @overridable
+  subset(left, right) {
+    return this.superset(right, left);
+  }
+
+  // Return the SQL and bindings, as the column may appear more than once.
+  // @overridable
+  hasKeys(column, access, keys, all) {
+    if (all) {
+      const parts = keys.map((key) => this.hasAnyKey(column, access, [key]));
+      return [
+        `(${parts.map(([sql]) => sql).join(' and ')})`,
+        parts.flatMap(([, bindings]) => bindings),
+      ];
+    } else {
+      return this.hasAnyKey(column, access, keys);
+    }
+  }
+}

package/lib/queryBuilder/jsonDialects/MySqlJsonDialect.js

@@ -0,0 +1,81 @@
+import { JsonDialect } from './JsonDialect.js';
+import { toJsonPath } from '../../utils/parseFieldExpression.js';
+
+// MySQL can only cast to these types, see `CAST()` in its manual. `float` is a
+// double precision number in Postgres, `real` a single precision one, and the
+// precision of `decimal` is the maximum, as MySQL's default rounds to integers.
+const castTypes = {
+  text: 'CHAR',
+  integer: 'SIGNED',
+  bigint: 'SIGNED',
+  boolean: 'SIGNED',
+  float: 'DOUBLE',
+  real: 'FLOAT',
+  decimal: 'DECIMAL(65,30)',
+  jsonb: 'JSON',
+};
+
+export class MySqlJsonDialect extends JsonDialect {
+  // Casting json values works for all types but text, where json strings need
+  // to be unquoted. Json null is cast to 0 or 'null', so turn it into NULL like
+  // Postgres and SQLite do.
+  extract(sql, access, cast) {
+    const value = `JSON_EXTRACT(${sql}, ${toMySqlJsonPathLiteral(access)})`;
+    if (cast) {
+      const nullable = `NULLIF(${value}, CAST('null' AS JSON))`;
+      return /^char\b/i.test(castTypes[cast] || cast) ? `JSON_UNQUOTE(${nullable})` : nullable;
+    } else {
+      return value;
+    }
+  }
+
+  // Like `to_jsonb()`, turn SQL values into json and keep json values as they are:
+  toJson(sql) {
+    return `JSON_EXTRACT(JSON_ARRAY(${sql}), '$[0]')`;
+  }
+
+  set(sql, access, value) {
+    return `JSON_SET(${sql}, ${toMySqlJsonPathLiteral(access)}, ${value})`;
+  }
+
+  superset([left, leftBindings], [right, rightBindings]) {
+    return [`JSON_CONTAINS(${left}, ${right})`, [...leftBindings, ...rightBindings]];
+  }
+
+  isType(sql, access, type) {
+    return `JSON_TYPE(${this.field(sql, access)}) = '${type.toUpperCase()}'`;
+  }
+
+  // Like the `?|` operator of Postgres, find the keys of objects, the strings in
+  // arrays and strings:
+  hasAnyKey(column, access, keys) {
+    const value = this.field('??', access);
+    return [
+      `JSON_OVERLAPS(COALESCE(JSON_KEYS(${value}), ${value}), ` +
+        `JSON_ARRAY(${keys.map(() => '?').join(', ')}))`,
+      [column, column, ...keys],
+    ];
+  }
+
+  // @override
+  cast(sql, type) {
+    return super.cast(sql, castTypes[type] || type);
+  }
+
+  // @override
+  json(sql) {
+    return `CAST(${sql} AS JSON)`;
+  }
+}
+
+// Formats the json path of a parsed field expression as a string literal, e.g.
+// `'$."a"[0]'`. Like in `toPostgresJsonPathLiteral()`, the path can't be a
+// binding. Paths with `?` or backslashes are written as hex literals: the mysql
+// driver reads every `?` as a binding placeholder, and whether backslashes
+// escape in string literals depends on the `NO_BACKSLASH_ESCAPES` SQL mode.
+function toMySqlJsonPathLiteral(access) {
+  const path = toJsonPath(access);
+  return /[?\\]/.test(path)
+    ? `_utf8mb4 X'${Buffer.from(path).toString('hex')}'`
+    : `'${path.replace(/'/g, "''")}'`;
+}

package/lib/queryBuilder/jsonDialects/PostgresJsonDialect.js

@@ -0,0 +1,45 @@
+import { JsonDialect } from './JsonDialect.js';
+import { toPostgresJsonPathLiteral } from '../../utils/parseFieldExpression.js';
+
+export class PostgresJsonDialect extends JsonDialect {
+  // Casts need the value as text, e.g. `CAST('"a"'::jsonb AS text)` would keep
+  // the quotes.
+  extract(sql, access, cast) {
+    return `${sql}${cast ? '#>>' : '#>'}${toPostgresJsonPathLiteral(access)}`;
+  }
+
+  toJson(sql) {
+    return `to_jsonb(${sql})`;
+  }
+
+  set(sql, access, value) {
+    return `jsonb_set(${sql}, ${toPostgresJsonPathLiteral(access)}, ${value}, true)`;
+  }
+
+  // The json operators need jsonb, also for json columns:
+  // @override
+  jsonOperand(sql) {
+    return `( ${sql} )::jsonb`;
+  }
+
+  superset([left, leftBindings], [right, rightBindings]) {
+    return [`${left} @> ${right}`, [...leftBindings, ...rightBindings]];
+  }
+
+  // @override
+  subset([left, leftBindings], [right, rightBindings]) {
+    return [`${left} <@ ${right}`, [...leftBindings, ...rightBindings]];
+  }
+
+  isType(sql, access, type) {
+    return `jsonb_typeof(${this.jsonOperand(this.field(sql, access))}) = '${type}'`;
+  }
+
+  // @override
+  hasKeys(column, access, keys, all) {
+    return [
+      `${this.field('??', access)} ${all ? '\\?&' : '\\?|'} array[${keys.map(() => '?').join(',')}]`,
+      [column, ...keys],
+    ];
+  }
+}

package/lib/queryBuilder/jsonDialects/SqliteJsonDialect.js

@@ -0,0 +1,67 @@
+import { JsonDialect } from './JsonDialect.js';
+import { toJsonPath } from '../../utils/parseFieldExpression.js';
+
+export class SqliteJsonDialect extends JsonDialect {
+  // `json_extract()` returns SQL values, which compare and sort like json
+  // values, unlike the json text that `->` returns.
+  extract(sql, access) {
+    return `json_extract(${sql}, ${toSqliteJsonPathLiteral(access)})`;
+  }
+
+  // `json_quote()` keeps the values of json functions as json, but SQLite can't
+  // tell json columns from text columns, which it would quote:
+  toJson(sql, isColumn) {
+    if (isColumn) {
+      throw new Error(
+        "ref().castJson() needs a json path or a cast on SQLite, which can't tell json columns " +
+          'from text columns.',
+      );
+    }
+    return `json_quote(${sql})`;
+  }
+
+  set(sql, access, value) {
+    return `json_set(${sql}, ${toSqliteJsonPathLiteral(access)}, ${value})`;
+  }
+
+  superset() {
+    throw new Error(
+      'whereJsonSupersetOf() and whereJsonSubsetOf() are not supported on SQLite, which has no ' +
+        'json containment.',
+    );
+  }
+
+  isType(sql, access, type) {
+    return `json_type(${sql}, ${toSqliteJsonPathLiteral(access)}) = '${type}'`;
+  }
+
+  // Like the `?|` operator of Postgres, find the keys of objects, the strings in
+  // arrays and strings. The keys of objects are text, those of arrays integers:
+  hasAnyKey(column, access, keys) {
+    return [
+      `exists (select 1 from json_each(??, ${toSqliteJsonPathLiteral(access)}) ` +
+        "where case when typeof(json_each.key) = 'text' then json_each.key " +
+        `when json_each.type = 'text' then json_each.value end in (${keys.map(() => '?').join(', ')}))`,
+      [column, ...keys],
+    ];
+  }
+
+  // SQLite accepts any type name, but not as json:
+  // @override
+  cast(sql, type) {
+    return type === 'jsonb' ? this.json(sql) : super.cast(sql, type);
+  }
+
+  // @override
+  json(sql) {
+    return `json(${sql})`;
+  }
+}
+
+// Formats the json path of a parsed field expression as a string literal, e.g.
+// `'$."a"[0]'`. Like in `toPostgresJsonPathLiteral()`, the path can't be a
+// binding, and knex reads every `?` in it as a binding placeholder. SQLite
+// understands json escapes in quoted keys, so `?` is written as `\u003f`.
+function toSqliteJsonPathLiteral(access) {
+  return `'${toJsonPath(access).replace(/\?/g, '\\u003f').replace(/'/g, "''")}'`;
+}

package/lib/queryBuilder/jsonDialects/index.js

@@ -0,0 +1,44 @@
+import { JsonDialect } from './JsonDialect.js';
+import { PostgresJsonDialect } from './PostgresJsonDialect.js';
+import { MySqlJsonDialect } from './MySqlJsonDialect.js';
+import { SqliteJsonDialect } from './SqliteJsonDialect.js';
+import { isPostgres, isMySql, isSqlite, isMsSql, isOracle } from '../../utils/knexUtils.js';
+import { warnOnce } from '../../utils/warnings.js';
+
+const message =
+  'JSON field expressions and the whereJson*() methods of objection are only supported on ' +
+  'PostgreSQL, MySQL and SQLite. Use the JSON methods of knex like whereJsonPath() or ' +
+  'jsonExtract() with other databases.';
+
+class UnsupportedJsonDialect extends JsonDialect {
+  // @override
+  checkSupport() {
+    throw new Error(message);
+  }
+}
+
+// Other databases may understand the SQL of Postgres, so only warn:
+class UnknownJsonDialect extends PostgresJsonDialect {
+  // @override
+  checkSupport() {
+    warnOnce(message);
+  }
+}
+
+const postgres = new PostgresJsonDialect();
+const mySql = new MySqlJsonDialect();
+const sqlite = new SqliteJsonDialect();
+const unsupported = new UnsupportedJsonDialect();
+const unknown = new UnknownJsonDialect();
+
+export function getJsonDialect(knex) {
+  return isPostgres(knex)
+    ? postgres
+    : isMySql(knex)
+      ? mySql
+      : isSqlite(knex)
+        ? sqlite
+        : isMsSql(knex) || isOracle(knex)
+          ? unsupported
+          : unknown;
+}