objection 3.2.0 → 3.3.0

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');
@@ -91,7 +98,7 @@ class ManyToManyRelation extends Relation {
       });
     });
 
-    owner.buildFindQuery(builder, this, joinTableOwnerRefs);
+    addWhereGroup(builder, () => owner.buildFindQuery(builder, this, joinTableOwnerRefs));
     return this.applyModify(builder);
   }
 
@@ -160,47 +167,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 +196,10 @@ 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,
-      });
-    }
+    return new (getUnrelateOperationClass(builder))('unrelate', {
+      relation: this,
+      owner,
+    });
   }
 
   createJoinModels(ownerId, related) {
@@ -498,6 +476,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/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) {
@@ -44,9 +45,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/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,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "objection",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "An SQL-friendly ORM for Node.js",
   "main": "lib/objection.js",
   "license": "MIT",
@@ -10,8 +10,9 @@
     "test:typings": "tsc && prettier --check \"typings/**/*.ts\" \"tests/ts/**/*.ts\"",
     "prettier": "prettier --write \"{examples,lib,tests,testUtils,typings,doc}/**/*.{js,ts}\"",
     "eslint": "eslint --format codeframe \"examples/**/*.js\" \"lib/**/*.js\" \"tests/**/*.js\"",
-    "docs:dev": "vuepress dev doc",
-    "docs:build": "vuepress build doc"
+    "docs:dev": "vitepress dev doc",
+    "docs:build": "vitepress build doc",
+    "docs:preview": "vitepress preview doc"
   },
   "publishConfig": {
     "tag": "latest"
@@ -35,7 +36,7 @@
   "bugs": {
     "url": "https://github.com/ditojs/objection/issues"
   },
-  "homepage": "https://github.com/ditojs/objection",
+  "homepage": "https://ditojs.github.io/objection/",
   "engines": {
     "node": ">=14.0.0"
   },
@@ -66,19 +67,22 @@
   },
   "devDependencies": {
     "@types/node": "^22.15.3",
+    "bluebird": "^3.7.2",
     "chai": "^4.3.10",
     "chai-subset": "^1.6.0",
     "eslint": "^8.54.0",
     "eslint-formatter-codeframe": "^7.32.1",
     "eslint-plugin-prettier": "^5.3.1",
     "expect.js": "^0.3.1",
-    "knex": "^3.1.0",
+    "knex": "^3.3.0",
+    "lodash": "^4.18.1",
     "mocha": "^11.2.2",
     "mysql": "^2.18.1",
     "pg": "^8.15.6",
     "prettier": "3.9.9",
     "sqlite3": "^5.1.7",
     "typescript": ">=5.8.3",
-    "vuepress": "1.9.10"
+    "uuid": "^9.0.1",
+    "vitepress": "1.6.4"
   }
 }