objection 3.2.0 → 3.4.0

package/lib/relations/hasMany/HasManyRelateOperation.js

@@ -2,6 +2,7 @@
 
 const { normalizeIds } = require('../../utils/normalizeIds');
 const { RelateOperation } = require('../../queryBuilder/operations/RelateOperation');
+const { addWhereGroup } = require('../../queryBuilder/whereGroups');
 
 class HasManyRelateOperation extends RelateOperation {
   onAdd(_, args) {
@@ -31,8 +32,10 @@ class HasManyRelateOperation extends RelateOperation {
       .copyFrom(builder, /returning/)
       .copyFrom(builder, builder.constructor.JoinSelector)
       .copyFrom(builder, builder.constructor.WhereSelector)
-      .findByIds(this.ids)
-      .modify(this.relation.modify);
+      .modify((query) => {
+        addWhereGroup(query, () => query.findByIds(this.ids));
+        addWhereGroup(query, () => query.modify(this.relation.modify));
+      });
   }
 }
 

package/lib/relations/hasMany/HasManyUnrelateOperation.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { UnrelateOperation } = require('../../queryBuilder/operations/UnrelateOperation');
+const { addWhereGroup } = require('../../queryBuilder/whereGroups');
 
 class HasManyUnrelateOperation extends UnrelateOperation {
   queryExecutor(builder) {
@@ -19,8 +20,10 @@ class HasManyUnrelateOperation extends UnrelateOperation {
       .patch(patch)
       .copyFrom(builder, builder.constructor.JoinSelector)
       .copyFrom(builder, builder.constructor.WhereSelector)
-      .whereInComposite(relatedRefs, ownerValues)
-      .modify(this.relation.modify);
+      .modify((query) => {
+        addWhereGroup(query, () => query.whereInComposite(relatedRefs, ownerValues));
+        addWhereGroup(query, () => query.modify(this.relation.modify));
+      });
   }
 }
 

package/lib/relations/manyToMany/ManyToManyModifyMixin.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { ManyToManyFindOperation } = require('./find/ManyToManyFindOperation');
+const { addWhereGroup } = require('../../queryBuilder/whereGroups');
 
 // This mixin contains the shared code for all modify operations (update, delete, relate, unrelate)
 // for ManyToManyRelation operations.
@@ -31,7 +32,7 @@ const ManyToManyModifyMixin = (Operation) => {
         this.removeFiltersFromMainQuery(builder);
 
         // Add a single where clause that uses the created subquery.
-        this.applyModifyFilterForRelatedTable(builder);
+        addWhereGroup(builder, () => this.applyModifyFilterForRelatedTable(builder));
       }
 
       return super.onBuild(builder);
@@ -70,6 +71,10 @@ const ManyToManyModifyMixin = (Operation) => {
       return builder.whereInComposite(idRefs, subquery);
     }
 
+    // Modifies the join rows of all related rows that match the filters. If the filters
+    // reference join table columns, this also modifies join rows that don't match them
+    // but share a related row with one that does (#1853). The dialect specific mixins
+    // override this to only modify the join rows that match the filters themselves.
     applyModifyFilterForJoinTable(builder) {
       const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
       const joinTableRelatedRefs = this.relation.joinTableRelatedProp.refs(builder);
@@ -85,10 +90,19 @@ const ManyToManyModifyMixin = (Operation) => {
     }
 
     toFindOperation() {
-      return new ManyToManyFindOperation('find', {
+      const opt = {
         relation: this.relation,
         owner: this.owner,
-      });
+      };
+
+      if (this.modifyMainQuery && this.modifyFilterSubquery) {
+        // `onBuild` has already moved the main query's filters into the
+        // subquery and removed them. Apply them to the find query too.
+        // See issue #2266.
+        return new ManyToManyModifyFindOperation('find', { ...opt, modifyOperation: this });
+      } else {
+        return new ManyToManyFindOperation('find', opt);
+      }
     }
 
     clone() {
@@ -99,6 +113,15 @@ const ManyToManyModifyMixin = (Operation) => {
   };
 };
 
+class ManyToManyModifyFindOperation extends ManyToManyFindOperation {
+  onBuild(builder) {
+    super.onBuild(builder);
+    addWhereGroup(builder, () =>
+      this.opt.modifyOperation.applyModifyFilterForRelatedTable(builder),
+    );
+  }
+}
+
 module.exports = {
   ManyToManyModifyMixin,
 };

package/lib/relations/manyToMany/ManyToManyMySqlModifyMixin.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const { ManyToManyModifyMixin } = require('./ManyToManyModifyMixin');
+const { isObject } = require('../../utils/objectUtils');
+
+// We need to override this mixin for mysql because mysql doesn't allow a
+// statement that modifies the join table to read the related table in a
+// subquery, if a trigger on the join table modifies the related table:
+//
+//   ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG
+//
+// So the join rows that match the filters are fetched in a separate query
+// before the main query, which then only modifies these rows (#1853). Mysql
+// has no row ids and the join table's primary key isn't known, so the rows are
+// identified by the values of all their columns.
+//
+// https://stackoverflow.com/a/2314264/3729316
+const ManyToManyMySqlModifyMixin = (Operation) => {
+  return class extends ManyToManyModifyMixin(Operation) {
+    applyModifyFilterForJoinTable(builder) {
+      const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
+      const tableRef = builder.tableRefFor(this.relation.getJoinModelClass(builder));
+
+      const ownerValues = this.owner.getProps(this.relation);
+      const subquery = this.modifyFilterSubquery.clone().select(`${tableRef}.*`);
+
+      return builder
+        .runBefore(async (_, builder) => {
+          // Fetch the raw rows: no models, so that no hooks run for them.
+          const rows = await subquery.toKnexQuery();
+
+          if (rows.length) {
+            builder.where((builder) => {
+              for (const row of rows) {
+                builder.orWhere((builder) => {
+                  for (const [column, value] of Object.entries(row)) {
+                    builder.whereRaw('?? <=> ?', [
+                      `${tableRef}.${column}`,
+                      toComparableValue(value),
+                    ]);
+                  }
+                });
+              }
+            });
+          } else {
+            // Still execute the query so that it returns the expected
+            // result for the dialect, e.g. a count of 0 for deletes.
+            builder.where(false);
+          }
+        })
+        .whereInComposite(joinTableOwnerRefs, ownerValues);
+    }
+  };
+};
+
+// Some drivers return JSON columns parsed. Mysql parses strings that are
+// compared to JSON columns, so the stringified value matches them again.
+function toComparableValue(value) {
+  return isObject(value) && !(value instanceof Date) && !Buffer.isBuffer(value)
+    ? JSON.stringify(value)
+    : value;
+}
+
+module.exports = {
+  ManyToManyMySqlModifyMixin,
+};

package/lib/relations/manyToMany/ManyToManyPostgresModifyMixin.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const { ManyToManyModifyMixin } = require('./ManyToManyModifyMixin');
+
+// Like `ManyToManySqliteModifyMixin`, this identifies the join rows to modify
+// by their physical row id, so that only the join rows that match the filters
+// are modified (#1853). `tableoid` makes `ctid` unique for partitioned tables.
+const ManyToManyPostgresModifyMixin = (Operation) => {
+  return class extends ManyToManyModifyMixin(Operation) {
+    applyModifyFilterForJoinTable(builder) {
+      const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
+      const tableRef = builder.tableRefFor(this.relation.getJoinModelClass(builder));
+      const rowIdRefs = [`${tableRef}.tableoid`, `${tableRef}.ctid`];
+
+      const ownerValues = this.owner.getProps(this.relation);
+      const subquery = this.modifyFilterSubquery.clone().select(rowIdRefs);
+
+      return builder
+        .whereInComposite(rowIdRefs, subquery)
+        .whereInComposite(joinTableOwnerRefs, ownerValues);
+    }
+  };
+};
+
+module.exports = {
+  ManyToManyPostgresModifyMixin,
+};

package/lib/relations/manyToMany/ManyToManyRelation.js

@@ -4,12 +4,13 @@ const { getModel } = require('../../model/getModel');
 const { Relation } = require('../Relation');
 const { RelationProperty } = require('../RelationProperty');
 
-const { isSqlite } = require('../../utils/knexUtils');
+const { isSqlite, isMySql, isPostgres } = require('../../utils/knexUtils');
 const { inheritModel } = require('../../model/inheritModel');
 const { resolveModel } = require('../../utils/resolveModel');
 const { mapAfterAllReturn } = require('../../utils/promiseUtils');
 const { isFunction, isObject, isString } = require('../../utils/objectUtils');
 const { createModifier } = require('../../utils/createModifier');
+const { addWhereGroup } = require('../../queryBuilder/whereGroups');
 
 const { ManyToManyFindOperation } = require('./find/ManyToManyFindOperation');
 const { ManyToManyInsertOperation } = require('./insert/ManyToManyInsertOperation');
@@ -19,9 +20,15 @@ const { ManyToManyUnrelateOperation } = require('./unrelate/ManyToManyUnrelateOp
 const {
   ManyToManyUnrelateSqliteOperation,
 } = require('./unrelate/ManyToManyUnrelateSqliteOperation');
+const { ManyToManyUnrelateMySqlOperation } = require('./unrelate/ManyToManyUnrelateMySqlOperation');
+const {
+  ManyToManyUnrelatePostgresOperation,
+} = require('./unrelate/ManyToManyUnrelatePostgresOperation');
 
 const { ManyToManyUpdateOperation } = require('./update/ManyToManyUpdateOperation');
 const { ManyToManyUpdateSqliteOperation } = require('./update/ManyToManyUpdateSqliteOperation');
+const { ManyToManyUpdateMySqlOperation } = require('./update/ManyToManyUpdateMySqlOperation');
+const { ManyToManyUpdatePostgresOperation } = require('./update/ManyToManyUpdatePostgresOperation');
 
 const { ManyToManyDeleteOperation } = require('./delete/ManyToManyDeleteOperation');
 const { ManyToManyDeleteSqliteOperation } = require('./delete/ManyToManyDeleteSqliteOperation');
@@ -68,10 +75,39 @@ class ManyToManyRelation extends Relation {
     return [];
   }
 
+  isJoinTableRelatedTable(builder) {
+    return builder.tableNameFor(this.joinTable) === builder.tableNameFor(this.relatedModelClass);
+  }
+
+  // Returns the alias of the join table in `findQuery`. If the join table is
+  // also the related table, it needs an alias of its own (#1803).
+  joinTableAliasFor(builder) {
+    const joinTableRef = builder.tableRefFor(this.joinTable);
+
+    if (this.isJoinTableRelatedTable(builder)) {
+      return this.ownerModelClass.joinTableAlias(joinTableRef);
+    } else {
+      return joinTableRef;
+    }
+  }
+
+  // The modify operations can't tell the join rows apart from the related rows
+  // if the join table is also the related table, so they would modify the
+  // wrong rows (#1803).
+  assertCanModifyJoinTable(builder, operationName) {
+    if (this.isJoinTableRelatedTable(builder)) {
+      throw this.createError(
+        `${operationName} is not supported when the join table is also the related table`,
+      );
+    }
+  }
+
   findQuery(builder, owner) {
-    const joinTableOwnerRefs = this.joinTableOwnerProp.refs(builder);
     const joinTable = builder.tableNameFor(this.joinTable);
-    const joinTableAlias = builder.tableRefFor(this.joinTable);
+    const joinTableAlias = this.joinTableAliasFor(builder);
+    const joinTableOwnerRefs = this.joinTableOwnerProp
+      .refs(builder)
+      .map((ref) => ref.table(joinTableAlias));
 
     let joinTableSelect = this.joinTableModelClass
       .query()
@@ -85,13 +121,13 @@ class ManyToManyRelation extends Relation {
     builder.join(joinTableSelect, (join) => {
       this.relatedProp.forEach((i) => {
         const relatedRef = this.relatedProp.ref(builder, i);
-        const joinTableRelatedRef = this.joinTableRelatedProp.ref(builder, i);
+        const joinTableRelatedRef = this.joinTableRelatedProp.ref(builder, i).table(joinTableAlias);
 
         join.on(relatedRef, joinTableRelatedRef);
       });
     });
 
-    owner.buildFindQuery(builder, this, joinTableOwnerRefs);
+    addWhereGroup(builder, () => owner.buildFindQuery(builder, this, joinTableOwnerRefs));
     return this.applyModify(builder);
   }
 
@@ -160,47 +196,25 @@ class ManyToManyRelation extends Relation {
   }
 
   update(builder, owner) {
-    if (isSqlite(builder.knex())) {
-      return new ManyToManyUpdateSqliteOperation('update', {
-        relation: this,
-        owner,
-      });
-    } else {
-      return new ManyToManyUpdateOperation('update', {
-        relation: this,
-        owner,
-      });
-    }
+    return new (getUpdateOperationClass(builder))('update', {
+      relation: this,
+      owner,
+    });
   }
 
   patch(builder, owner) {
-    if (isSqlite(builder.knex())) {
-      return new ManyToManyUpdateSqliteOperation('patch', {
-        modelOptions: { patch: true },
-        relation: this,
-        owner,
-      });
-    } else {
-      return new ManyToManyUpdateOperation('patch', {
-        modelOptions: { patch: true },
-        relation: this,
-        owner,
-      });
-    }
+    return new (getUpdateOperationClass(builder))('patch', {
+      modelOptions: { patch: true },
+      relation: this,
+      owner,
+    });
   }
 
   delete(builder, owner) {
-    if (isSqlite(builder.knex())) {
-      return new ManyToManyDeleteSqliteOperation('delete', {
-        relation: this,
-        owner,
-      });
-    } else {
-      return new ManyToManyDeleteOperation('delete', {
-        relation: this,
-        owner,
-      });
-    }
+    return new (getDeleteOperationClass(builder))('delete', {
+      relation: this,
+      owner,
+    });
   }
 
   relate(builder, owner) {
@@ -211,17 +225,12 @@ class ManyToManyRelation extends Relation {
   }
 
   unrelate(builder, owner) {
-    if (isSqlite(builder.knex())) {
-      return new ManyToManyUnrelateSqliteOperation('unrelate', {
-        relation: this,
-        owner,
-      });
-    } else {
-      return new ManyToManyUnrelateOperation('unrelate', {
-        relation: this,
-        owner,
-      });
-    }
+    this.assertCanModifyJoinTable(builder, 'unrelate');
+
+    return new (getUnrelateOperationClass(builder))('unrelate', {
+      relation: this,
+      owner,
+    });
   }
 
   createJoinModels(ownerId, related) {
@@ -498,6 +507,50 @@ function finalizeJoinModelClass(ctx) {
   return ctx;
 }
 
+// The modify operations need dialect specific code to only modify the join
+// rows that match the filters, see the `ManyToMany*ModifyMixin` classes.
+function getOperationClass(builder, { sqlite, mysql, postgres, other }) {
+  const knex = builder.knex();
+
+  if (isSqlite(knex)) {
+    return sqlite;
+  } else if (isMySql(knex)) {
+    return mysql;
+  } else if (isPostgres(knex)) {
+    return postgres;
+  } else {
+    return other;
+  }
+}
+
+function getUpdateOperationClass(builder) {
+  return getOperationClass(builder, {
+    sqlite: ManyToManyUpdateSqliteOperation,
+    mysql: ManyToManyUpdateMySqlOperation,
+    postgres: ManyToManyUpdatePostgresOperation,
+    other: ManyToManyUpdateOperation,
+  });
+}
+
+function getUnrelateOperationClass(builder) {
+  return getOperationClass(builder, {
+    sqlite: ManyToManyUnrelateSqliteOperation,
+    mysql: ManyToManyUnrelateMySqlOperation,
+    postgres: ManyToManyUnrelatePostgresOperation,
+    other: ManyToManyUnrelateOperation,
+  });
+}
+
+function getDeleteOperationClass(builder) {
+  // Deletes don't modify the join table, so only sqlite needs its own operation.
+  return getOperationClass(builder, {
+    sqlite: ManyToManyDeleteSqliteOperation,
+    mysql: ManyToManyDeleteOperation,
+    postgres: ManyToManyDeleteOperation,
+    other: ManyToManyDeleteOperation,
+  });
+}
+
 module.exports = {
   ManyToManyRelation,
 };

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

@@ -29,7 +29,7 @@ class ManyToManyFindOperation extends RelationFindOperation {
 
       // Also select all extra columns.
       for (const extra of this.relation.joinTableExtras) {
-        const joinTable = builder.tableRefFor(this.relation.joinTable);
+        const joinTable = this.relation.joinTableAliasFor(builder);
         builder.select(`${joinTable}.${extra.joinTableCol} as ${extra.aliasCol}`);
       }
     }
@@ -88,7 +88,9 @@ class ManyToManyFindOperation extends RelationFindOperation {
     // We must select the owner join columns so that we know for which owner model the related
     // models belong to after the requests.
     joinTableOwnerProp.forEach((i) => {
-      const joinTableOwnerRef = joinTableOwnerProp.ref(builder, i);
+      const joinTableOwnerRef = joinTableOwnerProp
+        .ref(builder, i)
+        .table(this.relation.joinTableAliasFor(builder));
       const propName = relatedModelClass.columnNameToPropertyName(this.ownerJoinColumnAlias[i]);
 
       builder.select(joinTableOwnerRef.as(this.ownerJoinColumnAlias[i]));

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelateMySqlOperation.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { ManyToManyUnrelateOperationBase } = require('./ManyToManyUnrelateOperationBase');
+const { ManyToManyMySqlModifyMixin } = require('../ManyToManyMySqlModifyMixin');
+
+class ManyToManyUnrelateMySqlOperation extends ManyToManyMySqlModifyMixin(
+  ManyToManyUnrelateOperationBase,
+) {
+  get modifyMainQuery() {
+    return false;
+  }
+}
+
+module.exports = {
+  ManyToManyUnrelateMySqlOperation,
+};

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelateOperationBase.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { UnrelateOperation } = require('../../../queryBuilder/operations/UnrelateOperation');
+const { addWhereGroup } = require('../../../queryBuilder/whereGroups');
 
 class ManyToManyUnrelateOperationBase extends UnrelateOperation {
   queryExecutor(builder) {
@@ -10,7 +11,10 @@ class ManyToManyUnrelateOperationBase extends UnrelateOperation {
       .childQueryOf(builder)
       .delete();
 
-    return this.applyModifyFilterForJoinTable(unrelateQuery).modify(this.relation.joinTableModify);
+    addWhereGroup(unrelateQuery, () => this.applyModifyFilterForJoinTable(unrelateQuery));
+    addWhereGroup(unrelateQuery, () => unrelateQuery.modify(this.relation.joinTableModify));
+
+    return unrelateQuery;
   }
 
   /* istanbul ignore next */

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelatePostgresOperation.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { ManyToManyUnrelateOperationBase } = require('./ManyToManyUnrelateOperationBase');
+const { ManyToManyPostgresModifyMixin } = require('../ManyToManyPostgresModifyMixin');
+
+class ManyToManyUnrelatePostgresOperation extends ManyToManyPostgresModifyMixin(
+  ManyToManyUnrelateOperationBase,
+) {
+  get modifyMainQuery() {
+    return false;
+  }
+}
+
+module.exports = {
+  ManyToManyUnrelatePostgresOperation,
+};

package/lib/relations/manyToMany/update/ManyToManyUpdateMySqlOperation.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const { ManyToManyUpdateOperationBase } = require('./ManyToManyUpdateOperationBase');
+const { ManyToManyMySqlModifyMixin } = require('../ManyToManyMySqlModifyMixin');
+
+class ManyToManyUpdateMySqlOperation extends ManyToManyMySqlModifyMixin(
+  ManyToManyUpdateOperationBase,
+) {}
+
+module.exports = {
+  ManyToManyUpdateMySqlOperation,
+};

package/lib/relations/manyToMany/update/ManyToManyUpdateOperationBase.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { UpdateOperation } = require('../../../queryBuilder/operations/UpdateOperation');
+const { addWhereGroup } = require('../../../queryBuilder/whereGroups');
 
 class ManyToManyUpdateOperationBase extends UpdateOperation {
   constructor(name, opt) {
@@ -25,6 +26,10 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
       }
     }
 
+    if (this.hasExtraProps) {
+      this.relation.assertCanModifyJoinTable(builder, `${this.name} with extra properties`);
+    }
+
     const res = super.onAdd(builder, args);
 
     if (this.hasExtraProps) {
@@ -44,9 +49,14 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
         .childQueryOf(builder)
         .patch(this.joinTablePatch);
 
-      await this.applyModifyFilterForJoinTable(joinTableUpdateQuery).modify(
-        this.relation.joinTableModify,
+      addWhereGroup(joinTableUpdateQuery, () =>
+        this.applyModifyFilterForJoinTable(joinTableUpdateQuery),
       );
+      addWhereGroup(joinTableUpdateQuery, () =>
+        joinTableUpdateQuery.modify(this.relation.joinTableModify),
+      );
+
+      await joinTableUpdateQuery;
       return result;
     } else {
       return result;

package/lib/relations/manyToMany/update/ManyToManyUpdatePostgresOperation.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const { ManyToManyUpdateOperationBase } = require('./ManyToManyUpdateOperationBase');
+const { ManyToManyPostgresModifyMixin } = require('../ManyToManyPostgresModifyMixin');
+
+class ManyToManyUpdatePostgresOperation extends ManyToManyPostgresModifyMixin(
+  ManyToManyUpdateOperationBase,
+) {}
+
+module.exports = {
+  ManyToManyUpdatePostgresOperation,
+};

package/lib/utils/assert.js

@@ -1,6 +1,14 @@
 'use strict';
 
+function assertHasIdColumn(modelClass) {
+  if (modelClass.getIdColumnArray().length === 0) {
+    throw new Error(`model ${modelClass.name} has no idColumn`);
+  }
+}
+
 function assertHasId(model) {
+  assertHasIdColumn(model.constructor);
+
   if (!model.$hasId()) {
     const modelClass = model.constructor;
     const ids = modelClass.getIdColumnArray().join(', ');
@@ -21,5 +29,6 @@ function assertIdNotUndefined(id, message) {
 
 module.exports = {
   assertHasId,
+  assertHasIdColumn,
   assertIdNotUndefined,
 };

package/lib/utils/deprecate.js

@@ -10,6 +10,12 @@ function deprecate(message) {
   }
 }
 
+// Only meant for tests that need to see a deprecation message again.
+function resetDeprecations() {
+  LOGGED_DEPRECATIONS.clear();
+}
+
 module.exports = {
   deprecate,
+  resetDeprecations,
 };

package/lib/utils/identifierMapping.js

@@ -168,10 +168,24 @@ function keyMapper(mapper) {
   };
 }
 
+// Returns a function that only calls `mapper` for the part of the input string
+// before the first `separator`, and leaves the rest untouched. For field
+// expressions like `jsonColumn:some.jsonPath` this maps the column but keeps
+// the json path as is. Column names can't contain `:`, so the first one marks
+// the boundary.
+function mapFirstPart(mapper, separator) {
+  return (str) => {
+    const idx = str.indexOf(separator);
+    return idx === -1 ? mapper(str) : mapper(str.slice(0, idx)) + str.slice(idx);
+  };
+}
+
 function snakeCaseMappers(opt = {}) {
+  const format = (str) => snakeCase(str, opt);
+
   return {
     parse: keyMapper(memoize((str) => camelCase(str, opt))),
-    format: keyMapper(memoize((str) => snakeCase(str, opt))),
+    format: keyMapper(memoize(opt.preserveJsonKeys ? mapFirstPart(format, ':') : format)),
   };
 }
 

package/lib/utils/parseFieldExpression.js

@@ -46,6 +46,34 @@ function freezeParsedExpr(parsedExpr) {
   return parsedExpr;
 }
 
+// Formats the json path of a parsed field expression as a Postgres text array
+// literal, e.g. `{a,"",b}`. Keys that would otherwise be misread (empty keys,
+// keys with whitespace, delimiters, quotes or backslashes and `NULL`) are
+// double-quoted, with quotes and backslashes escaped.
+function toPostgresJsonPath(access) {
+  const keys = access.map(({ ref }) => {
+    const key = String(ref);
+    return key === '' || /[{}",\\\s]/.test(key) || key.toUpperCase() === 'NULL'
+      ? `"${key.replace(/["\\]/g, '\\$&')}"`
+      : key;
+  });
+  return `{${keys.join(',')}}`;
+}
+
+// Formats the json path of a parsed field expression as a quoted string literal
+// to be used in raw knex SQL, e.g. `'{a,b}'`. The path can't be passed as a
+// binding, as knex doesn't keep the order of bindings in raw columns (e.g. in
+// `whereIn(ref(...), values)`), so the keys need to be escaped instead: single
+// quotes are doubled, and `?` is escaped so that knex doesn't read it as a
+// binding placeholder. Backslashes are always doubled by `toPostgresJsonPath()`,
+// so they can't escape the closing quote either.
+function toPostgresJsonPathLiteral(access) {
+  const path = toPostgresJsonPath(access).replace(/'/g, "''").replace(/\?/g, '\\?');
+  return `'${path}'`;
+}
+
 module.exports = {
   parseFieldExpression,
+  toPostgresJsonPath,
+  toPostgresJsonPathLiteral,
 };