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

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

@@ -1,31 +1,30 @@
 'use strict';
-
 const postgresJsonApi = require('./postgresJsonApi');
 const mysqlJsonApi = require('./mysqlJsonApi');
 const { getJsonDialect } = require('../../../utils/postgresJsonPath');
+const { jsonCastsForDialect } = require('../../../utils/mysqlJsonPath');
 const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
-
 // `whereJsonSupersetOf`, `whereJsonSubsetOf` and their variants.
 class WhereJsonOperation extends ObjectionToKnexConvertingOperation {
-  onBuildKnex(knexBuilder, builder) {
-    const dialect = getJsonDialect(builder.unsafeKnex(), this.name);
-    const args = this.getKnexArgs(builder);
-    const jsonApi =
-      dialect === 'mysql'
-        ? mysqlJsonApi.whereJsonContains
-        : postgresJsonApi.whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams;
-    const rawArgs = jsonApi(args[0], this.opt.operator, args[1], this.opt.prefix);
-
-    if (this.opt.bool === 'or') {
-      knexBuilder = knexBuilder.orWhereRaw.apply(knexBuilder, rawArgs);
-    } else {
-      knexBuilder = knexBuilder.whereRaw.apply(knexBuilder, rawArgs);
+    onBuildKnex(knexBuilder, builder) {
+        const dialect = getJsonDialect(builder.unsafeKnex(), this.name);
+        const args = this.getKnexArgs(builder);
+        const jsonApi = dialect === 'mysql'
+            ? mysqlJsonApi.whereJsonContains
+            : postgresJsonApi.whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams;
+        const rawArgs = jsonApi(args[0], this.opt.operator, args[1], this.opt.prefix);
+        if (dialect === 'mysql') {
+            rawArgs[0] = jsonCastsForDialect(rawArgs[0], builder.unsafeKnex());
+        }
+        if (this.opt.bool === 'or') {
+            knexBuilder = knexBuilder.orWhereRaw.apply(knexBuilder, rawArgs);
+        }
+        else {
+            knexBuilder = knexBuilder.whereRaw.apply(knexBuilder, rawArgs);
+        }
+        return knexBuilder;
     }
-
-    return knexBuilder;
-  }
 }
-
 module.exports = {
-  WhereJsonOperation,
+    WhereJsonOperation,
 };

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

@@ -1,31 +1,33 @@
 'use strict';
-
 const mysqlJsonApi = require('./mysqlJsonApi');
 const { getJsonDialect } = require('../../../utils/postgresJsonPath');
+const { getMariaDbVersion } = require('../../../utils/knexUtils');
+const { jsonCastsForDialect } = require('../../../utils/mysqlJsonPath');
 const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
-
 // `whereJsonOverlaps` and its variants. Postgres has no operator for this.
 class WhereJsonOverlapsOperation extends ObjectionToKnexConvertingOperation {
-  onBuildKnex(knexBuilder, builder) {
-    const knex = builder.unsafeKnex();
-
-    if (knex && getJsonDialect(knex, this.name) !== 'mysql') {
-      throw new Error(`${this.name} is only supported on mysql.`);
+    onBuildKnex(knexBuilder, builder) {
+        const knex = builder.unsafeKnex();
+        if (knex && getJsonDialect(knex, this.name) !== 'mysql') {
+            throw new Error(`${this.name} is only supported on mysql.`);
+        }
+        const mariaDbVersion = knex && getMariaDbVersion(knex);
+        if (mariaDbVersion &&
+            (mariaDbVersion[0] < 10 || (mariaDbVersion[0] === 10 && mariaDbVersion[1] < 9))) {
+            throw new Error(`${this.name} needs MariaDB 10.9 or newer, which has JSON_OVERLAPS().`);
+        }
+        const args = this.getKnexArgs(builder);
+        const [rawSql, bindings] = mysqlJsonApi.whereJsonOverlaps(args[0], args[1], this.opt.prefix);
+        const sql = jsonCastsForDialect(rawSql, knex);
+        if (this.opt.bool === 'or') {
+            knexBuilder = knexBuilder.orWhereRaw(sql, bindings);
+        }
+        else {
+            knexBuilder = knexBuilder.whereRaw(sql, bindings);
+        }
+        return knexBuilder;
     }
-
-    const args = this.getKnexArgs(builder);
-    const [sql, bindings] = mysqlJsonApi.whereJsonOverlaps(args[0], args[1], this.opt.prefix);
-
-    if (this.opt.bool === 'or') {
-      knexBuilder = knexBuilder.orWhereRaw(sql, bindings);
-    } else {
-      knexBuilder = knexBuilder.whereRaw(sql, bindings);
-    }
-
-    return knexBuilder;
-  }
 }
-
 module.exports = {
-  WhereJsonOverlapsOperation,
+    WhereJsonOverlapsOperation,
 };

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

@@ -1,167 +1,155 @@
 'use strict';
-
 const { parseFieldExpression } = require('../../../utils/parseFieldExpression');
 const { asArray, isObject, isPlainObject, isString } = require('../../../utils/objectUtils');
 const { toMySqlJsonPath } = require('../../../utils/mysqlJsonPath');
-
+const { isMariaDb } = require('../../../utils/knexUtils');
 // The MySQL versions of the `whereJson*` methods. They mirror the postgres
 // operators (`@>`, `<@`, `?|`, `?&`) so that the methods find the same rows on
 // both databases.
 //
 // The parts of the queries are `{ sql, bindings, type }` objects. `type` is
 // `'object'` or `'nonObject'` when the JSON type of the part is known.
-
 // Joins sql parts: sql`JSON_CONTAINS(${target}, ${candidate})`.
 function sql(strings, ...parts) {
-  let text = strings[0];
-  const bindings = [];
-
-  parts.forEach((part, i) => {
-    text += part.sql + strings[i + 1];
-    bindings.push(...part.bindings);
-  });
-
-  return { sql: text, bindings };
+    let text = strings[0];
+    const bindings = [];
+    parts.forEach((part, i) => {
+        text += part.sql + strings[i + 1];
+        bindings.push(...part.bindings);
+    });
+    return { sql: text, bindings };
 }
-
 function literal(text) {
-  return { sql: text, bindings: [] };
+    return { sql: text, bindings: [] };
 }
-
 // A field expression like `Table.column:a.b[0]`.
 function field(expression) {
-  const parsed = parseFieldExpression(expression);
-
-  if (parsed.access.length === 0) {
-    return { sql: '??', bindings: [parsed.columnName] };
-  } else {
-    return {
-      sql: 'JSON_EXTRACT(??, ?)',
-      bindings: [parsed.columnName, toMySqlJsonPath(parsed.access)],
-    };
-  }
+    const parsed = parseFieldExpression(expression);
+    if (parsed.access.length === 0) {
+        return { sql: '??', bindings: [parsed.columnName] };
+    }
+    else {
+        return {
+            sql: 'JSON_EXTRACT(??, ?)',
+            bindings: [parsed.columnName, toMySqlJsonPath(parsed.access)],
+        };
+    }
 }
-
 function jsonValue(value) {
-  return {
-    sql: 'CAST(? AS JSON)',
-    bindings: [JSON.stringify(value)],
-    type: isPlainObject(value) ? 'object' : 'nonObject',
-  };
+    return {
+        sql: 'CAST(? AS JSON)',
+        bindings: [JSON.stringify(value)],
+        type: isPlainObject(value) ? 'object' : 'nonObject',
+    };
 }
-
 // The right hand side of the methods: a field expression or a JSON value.
 function fieldOrValue(value) {
-  if (isString(value)) {
-    return field(value);
-  } else if (isObject(value)) {
-    return jsonValue(value);
-  } else {
-    throw new Error('Invalid right hand expression.');
-  }
+    if (isString(value)) {
+        return field(value);
+    }
+    else if (isObject(value)) {
+        return jsonValue(value);
+    }
+    else {
+        throw new Error('Invalid right hand expression.');
+    }
 }
-
 // `target @> candidate`. On postgres an object is only contained in an object, but
 // MySQL's `JSON_CONTAINS()` also finds objects inside arrays.
 function contains(target, candidate) {
-  const containsSql = sql`JSON_CONTAINS(${target}, ${candidate})`;
-  let guard = null;
-
-  if (candidate.type === 'nonObject' || target.type === 'object') {
-    guard = null;
-  } else if (candidate.type === 'object') {
-    guard = target.type === 'nonObject' ? literal('FALSE') : sql`JSON_TYPE(${target}) = 'OBJECT'`;
-  } else if (target.type === 'nonObject') {
-    guard = sql`JSON_TYPE(${candidate}) <> 'OBJECT'`;
-  } else {
-    guard = sql`(JSON_TYPE(${candidate}) <> 'OBJECT' OR JSON_TYPE(${target}) = 'OBJECT')`;
-  }
-
-  return guard ? sql`(${containsSql} AND ${guard})` : containsSql;
+    const containsSql = sql `JSON_CONTAINS(${target}, ${candidate})`;
+    let guard = null;
+    if (candidate.type === 'nonObject' || target.type === 'object') {
+        guard = null;
+    }
+    else if (candidate.type === 'object') {
+        guard = target.type === 'nonObject' ? literal('FALSE') : sql `JSON_TYPE(${target}) = 'OBJECT'`;
+    }
+    else if (target.type === 'nonObject') {
+        guard = sql `JSON_TYPE(${candidate}) <> 'OBJECT'`;
+    }
+    else {
+        guard = sql `(JSON_TYPE(${candidate}) <> 'OBJECT' OR JSON_TYPE(${target}) = 'OBJECT')`;
+    }
+    return guard ? sql `(${containsSql} AND ${guard})` : containsSql;
 }
-
 function not(part, prefix) {
-  return prefix === 'not' ? sql`NOT ${part}` : part;
+    return prefix === 'not' ? sql `NOT ${part}` : part;
 }
-
 function toRawArgs(part) {
-  return [part.sql, part.bindings];
+    return [part.sql, part.bindings];
 }
-
 // `whereJsonSupersetOf` (`@>`) and `whereJsonSubsetOf` (`<@`).
 function whereJsonContains(fieldExpression, operator, jsonObjectOrFieldExpression, prefix) {
-  const left = field(fieldExpression);
-  const right = fieldOrValue(jsonObjectOrFieldExpression);
-  const condition = operator === '@>' ? contains(left, right) : contains(right, left);
-
-  return toRawArgs(not(condition, prefix));
+    const left = field(fieldExpression);
+    const right = fieldOrValue(jsonObjectOrFieldExpression);
+    const condition = operator === '@>' ? contains(left, right) : contains(right, left);
+    return toRawArgs(not(condition, prefix));
 }
-
 // `whereJsonNotArray` and `whereJsonNotObject`. Like on postgres, NULL is neither
 // an array nor an object.
 function whereJsonNotContains(fieldExpression, compareValue) {
-  const left = field(fieldExpression);
-  return toRawArgs(sql`(NOT ${contains(left, jsonValue(compareValue))} OR ${left} IS NULL)`);
+    const left = field(fieldExpression);
+    return toRawArgs(sql `(NOT ${contains(left, jsonValue(compareValue))} OR ${left} IS NULL)`);
 }
-
 // `whereJsonHasAny` (`?|`) and `whereJsonHasAll` (`?&`). Like on postgres, the keys
 // are looked for in the keys of objects, in the string items of arrays and in
 // strings.
-function whereJsonHas(fieldExpression, operator, keys) {
-  const left = field(fieldExpression);
-  const all = operator === '?&';
-
-  keys = asArray(keys);
-
-  for (const key of keys) {
-    if (!isString(key)) {
-      throw new Error('All keys to find must be strings.');
+function whereJsonHas(fieldExpression, operator, keys, knex = null) {
+    const left = field(fieldExpression);
+    const all = operator === '?&';
+    keys = asArray(keys);
+    for (const key of keys) {
+        if (!isString(key)) {
+            throw new Error('All keys to find must be strings.');
+        }
+    }
+    if (keys.length === 0) {
+        return toRawArgs(all ? sql `${left} IS NOT NULL` : literal('FALSE'));
+    }
+    const paths = {
+        sql: keys.map(() => '?').join(', '),
+        bindings: keys.map((key) => toMySqlJsonPath([{ type: 'object', ref: key }])),
+    };
+    const keysJson = jsonValue(keys);
+    const stringChecks = keys.map((key) => ({
+        sql: `JSON_UNQUOTE(${left.sql}) = ?`,
+        bindings: [...left.bindings, key],
+    }));
+    const stringCheck = {
+        sql: `(${stringChecks.map((it) => it.sql).join(all ? ' AND ' : ' OR ')})`,
+        bindings: stringChecks.flatMap((it) => it.bindings),
+    };
+    const objectCheck = sql `JSON_CONTAINS_PATH(${left}, ${literal(all ? "'all'" : "'one'")}, ${paths})`;
+    let arrayCheck;
+    if (all) {
+        arrayCheck = sql `JSON_CONTAINS(${left}, ${keysJson})`;
+    }
+    else if (knex && isMariaDb(knex)) {
+        // MariaDB has JSON_OVERLAPS() only since 10.9.
+        const containsChecks = keys.map((key) => ({
+            sql: `JSON_CONTAINS(${left.sql}, ?)`,
+            bindings: [...left.bindings, JSON.stringify(key)],
+        }));
+        arrayCheck = {
+            sql: `(${containsChecks.map((it) => it.sql).join(' OR ')})`,
+            bindings: containsChecks.flatMap((it) => it.bindings),
+        };
+    }
+    else {
+        arrayCheck = sql `JSON_OVERLAPS(${left}, ${keysJson})`;
     }
-  }
-
-  if (keys.length === 0) {
-    return toRawArgs(all ? sql`${left} IS NOT NULL` : literal('FALSE'));
-  }
-
-  const paths = {
-    sql: keys.map(() => '?').join(', '),
-    bindings: keys.map((key) => toMySqlJsonPath([{ type: 'object', ref: key }])),
-  };
-
-  const keysJson = jsonValue(keys);
-  const stringChecks = keys.map((key) => ({
-    sql: `JSON_UNQUOTE(${left.sql}) = ?`,
-    bindings: [...left.bindings, key],
-  }));
-
-  const stringCheck = {
-    sql: `(${stringChecks.map((it) => it.sql).join(all ? ' AND ' : ' OR ')})`,
-    bindings: stringChecks.flatMap((it) => it.bindings),
-  };
-
-  const objectCheck = sql`JSON_CONTAINS_PATH(${left}, ${literal(all ? "'all'" : "'one'")}, ${paths})`;
-  const arrayCheck = all
-    ? sql`JSON_CONTAINS(${left}, ${keysJson})`
-    : sql`JSON_OVERLAPS(${left}, ${keysJson})`;
-
-  return toRawArgs(
-    sql`(CASE JSON_TYPE(${left}) WHEN 'OBJECT' THEN ${objectCheck} WHEN 'ARRAY' THEN ${arrayCheck} WHEN 'STRING' THEN ${stringCheck} ELSE FALSE END)`,
-  );
+    return toRawArgs(sql `(CASE JSON_TYPE(${left}) WHEN 'OBJECT' THEN ${objectCheck} WHEN 'ARRAY' THEN ${arrayCheck} WHEN 'STRING' THEN ${stringCheck} ELSE FALSE END)`);
 }
-
 // `whereJsonOverlaps`. A NULL or missing field doesn't overlap anything, so
 // `whereJsonNotOverlaps` finds it.
 function whereJsonOverlaps(fieldExpression, jsonObjectOrFieldExpression, prefix) {
-  const overlaps = sql`JSON_OVERLAPS(${field(fieldExpression)}, ${fieldOrValue(
-    jsonObjectOrFieldExpression,
-  )})`;
-
-  return toRawArgs(prefix === 'not' ? sql`NOT COALESCE(${overlaps}, FALSE)` : overlaps);
+    const overlaps = sql `JSON_OVERLAPS(${field(fieldExpression)}, ${fieldOrValue(jsonObjectOrFieldExpression)})`;
+    return toRawArgs(prefix === 'not' ? sql `NOT COALESCE(${overlaps}, FALSE)` : overlaps);
 }
-
 module.exports = {
-  whereJsonContains,
-  whereJsonNotContains,
-  whereJsonHas,
-  whereJsonOverlaps,
+    whereJsonContains,
+    whereJsonNotContains,
+    whereJsonHas,
+    whereJsonOverlaps,
 };

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

@@ -1,9 +1,7 @@
 'use strict';
-
 const parser = require('../../../utils/parseFieldExpression');
 const { asArray, isObject, isString } = require('../../../utils/objectUtils');
 const { toPgJsonPathLiteral, toPgQuotedColumn } = require('../../../utils/postgresJsonPath');
-
 /**
  * @typedef {String} FieldExpression
  *
@@ -42,123 +40,96 @@ const { toPgJsonPathLiteral, toPgQuotedColumn } = require('../../../utils/postgr
  * 99. Keys containing dots, square brackets, single quotes and double quotes in one json key is
  *     not currently supported
  */
-
 function parseFieldExpression(expression, extractAsText) {
-  let parsed = parser.parseFieldExpression(expression);
-  let extractor = extractAsText ? '#>>' : '#>';
-  return `${toPgQuotedColumn(parsed.columnName)}${extractor}${toPgJsonPathLiteral(parsed.access)}`;
+    const parsed = parser.parseFieldExpression(expression);
+    const extractor = extractAsText ? '#>>' : '#>';
+    return `${toPgQuotedColumn(parsed.columnName)}${extractor}${toPgJsonPathLiteral(parsed.access)}`;
 }
-
-function whereJsonbRefOnLeftJsonbValOrRefOnRight(
-  builder,
-  fieldExpression,
-  operator,
-  jsonObjectOrFieldExpression,
-  queryPrefix,
-) {
-  let queryParams = whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams(
-    fieldExpression,
-    operator,
-    jsonObjectOrFieldExpression,
-    queryPrefix,
-  );
-  return builder.whereRaw.apply(builder, queryParams);
+function whereJsonbRefOnLeftJsonbValOrRefOnRight(builder, fieldExpression, operator, jsonObjectOrFieldExpression, queryPrefix) {
+    const queryParams = whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams(fieldExpression, operator, jsonObjectOrFieldExpression, queryPrefix);
+    return builder.whereRaw.apply(builder, queryParams);
 }
-
-function whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams(
-  fieldExpression,
-  operator,
-  jsonObjectOrFieldExpression,
-  queryPrefix,
-) {
-  let fieldReference = parseFieldExpression(fieldExpression);
-
-  if (isString(jsonObjectOrFieldExpression)) {
-    let rightHandReference = parseFieldExpression(jsonObjectOrFieldExpression);
-    let refRefQuery = [
-      '(',
-      fieldReference,
-      ')::jsonb',
-      operator,
-      '(',
-      rightHandReference,
-      ')::jsonb',
-    ];
-    if (queryPrefix) {
-      refRefQuery.unshift(queryPrefix);
+function whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams(fieldExpression, operator, jsonObjectOrFieldExpression, queryPrefix) {
+    const fieldReference = parseFieldExpression(fieldExpression);
+    if (isString(jsonObjectOrFieldExpression)) {
+        const rightHandReference = parseFieldExpression(jsonObjectOrFieldExpression);
+        const refRefQuery = [
+            '(',
+            fieldReference,
+            ')::jsonb',
+            operator,
+            '(',
+            rightHandReference,
+            ')::jsonb',
+        ];
+        if (queryPrefix) {
+            refRefQuery.unshift(queryPrefix);
+        }
+        return [refRefQuery.join(' ')];
     }
-    return [refRefQuery.join(' ')];
-  } else if (isObject(jsonObjectOrFieldExpression)) {
-    let refValQuery = ['(', fieldReference, ')::jsonb', operator, '?::jsonb'];
-    if (queryPrefix) {
-      refValQuery.unshift(queryPrefix);
+    else if (isObject(jsonObjectOrFieldExpression)) {
+        const refValQuery = ['(', fieldReference, ')::jsonb', operator, '?::jsonb'];
+        if (queryPrefix) {
+            refValQuery.unshift(queryPrefix);
+        }
+        return [refValQuery.join(' '), JSON.stringify(jsonObjectOrFieldExpression)];
     }
-    return [refValQuery.join(' '), JSON.stringify(jsonObjectOrFieldExpression)];
-  }
-
-  throw new Error('Invalid right hand expression.');
+    throw new Error('Invalid right hand expression.');
 }
-
 function whereJsonFieldRightStringArrayOnLeftQuery(knex, fieldExpression, operator, keys) {
-  let fieldReference = parseFieldExpression(fieldExpression);
-  keys = asArray(keys);
-
-  let questionMarksArray = keys.map((key) => {
-    if (!isString(key)) {
-      throw new Error('All keys to find must be strings.');
-    }
-    return '?';
-  });
-
-  let rightHandExpression = 'array[' + questionMarksArray.join(',') + ']';
-
-  return [`${fieldReference} ${operator.replace('?', '\\?')} ${rightHandExpression}`, keys];
+    const fieldReference = parseFieldExpression(fieldExpression);
+    keys = asArray(keys);
+    const questionMarksArray = keys.map((key) => {
+        if (!isString(key)) {
+            throw new Error('All keys to find must be strings.');
+        }
+        return '?';
+    });
+    const rightHandExpression = 'array[' + questionMarksArray.join(',') + ']';
+    return [`${fieldReference} ${operator.replace('?', '\\?')} ${rightHandExpression}`, keys];
 }
-
 function whereJsonFieldQuery(knex, fieldExpression, operator, value) {
-  let fieldReference = parseFieldExpression(fieldExpression, true);
-  let normalizedOperator = normalizeOperator(knex, operator);
-
-  // json type comparison takes json type in string format
-  let cast;
-  let valuePlaceholder = '?';
-  let bindings = [value];
-  let type = typeof value;
-
-  if (type === 'number') {
-    cast = '::NUMERIC';
-  } else if (type === 'boolean') {
-    cast = '::BOOLEAN';
-  } else if (type === 'string') {
-    cast = '::TEXT';
-  } else if (value === null) {
-    cast = '::TEXT';
-    valuePlaceholder = 'NULL';
-    bindings = [];
-  } else {
-    throw new Error('Value must be string, number, boolean or null.');
-  }
-
-  return [`(${fieldReference})${cast} ${normalizedOperator} ${valuePlaceholder}`, bindings];
+    const fieldReference = parseFieldExpression(fieldExpression, true);
+    const normalizedOperator = normalizeOperator(knex, operator);
+    // json type comparison takes json type in string format
+    let cast;
+    let valuePlaceholder = '?';
+    let bindings = [value];
+    const type = typeof value;
+    if (type === 'number') {
+        cast = '::NUMERIC';
+    }
+    else if (type === 'boolean') {
+        cast = '::BOOLEAN';
+    }
+    else if (type === 'string') {
+        cast = '::TEXT';
+    }
+    else if (value === null) {
+        cast = '::TEXT';
+        valuePlaceholder = 'NULL';
+        bindings = [];
+    }
+    else {
+        throw new Error('Value must be string, number, boolean or null.');
+    }
+    return [`(${fieldReference})${cast} ${normalizedOperator} ${valuePlaceholder}`, bindings];
 }
-
 function normalizeOperator(knex, operator) {
-  let trimmedLowerCase = operator.trim().toLowerCase();
-
-  switch (trimmedLowerCase) {
-    case 'is':
-    case 'is not':
-      return trimmedLowerCase;
-    default:
-      return knex.client.formatter().operator(operator);
-  }
+    const trimmedLowerCase = operator.trim().toLowerCase();
+    switch (trimmedLowerCase) {
+        case 'is':
+        case 'is not':
+            return trimmedLowerCase;
+        default:
+            // knex has no public way to check an operator, and only `is` is used.
+            throw new Error(`unsupported operator "${operator}" in a JSON field query`);
+    }
 }
-
 module.exports = {
-  parseFieldExpression: parseFieldExpression,
-  whereJsonbRefOnLeftJsonbValOrRefOnRight: whereJsonbRefOnLeftJsonbValOrRefOnRight,
-  whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams:
-    whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams,
-  whereJsonFieldRightStringArrayOnLeftQuery: whereJsonFieldRightStringArrayOnLeftQuery,
-  whereJsonFieldQuery: whereJsonFieldQuery,
+    parseFieldExpression: parseFieldExpression,
+    whereJsonbRefOnLeftJsonbValOrRefOnRight: whereJsonbRefOnLeftJsonbValOrRefOnRight,
+    whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams: whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams,
+    whereJsonFieldRightStringArrayOnLeftQuery: whereJsonFieldRightStringArrayOnLeftQuery,
+    whereJsonFieldQuery: whereJsonFieldQuery,
 };