objection 3.9.0 → 4.0.0-rc.1

package/lib/relations/manyToMany/ManyToManyModifyMixin.js

@@ -1,8 +1,7 @@
-'use strict';
-
-const { ManyToManyFindOperation } = require('./find/ManyToManyFindOperation');
-const { addWhereGroup } = require('../../queryBuilder/whereGroups');
-const { withoutOrder } = require('../../queryBuilder/withoutOrder');
+import { ManyToManyFindOperation } from './find/ManyToManyFindOperation.js';
+import { addWhereGroup } from '../../queryBuilder/whereGroups.js';
+import { withoutOrder } from '../../queryBuilder/withoutOrder.js';
+import { whereInKeys } from '../../utils/knexUtils.js';
 
 // This mixin contains the shared code for all modify operations (update, delete, relate, unrelate)
 // for ManyToManyRelation operations.
@@ -12,7 +11,7 @@ const { withoutOrder } = require('../../queryBuilder/withoutOrder');
 // that we are able to `innerJoin` the join table to the query. Most SQL engines don't allow
 // joins in updates or deletes. Join table is joined so that queries can reference the join
 // table columns.
-const ManyToManyModifyMixin = (Operation) => {
+export const ManyToManyModifyMixin = (Operation) => {
   return class extends Operation {
     constructor(...args) {
       super(...args);
@@ -42,13 +41,13 @@ const ManyToManyModifyMixin = (Operation) => {
         this.removeFiltersFromMainQuery(builder);
 
         // Add a single where clause that uses the created subquery. Updates
-        // that modify the join rows too are executed in batches of the ids
-        // that `onAfterBuild` fetches, see `queryBatches()` (#161).
+        // that modify the join rows too filter by the ids that `onAfterBuild`
+        // fetches (#161).
         addWhereGroup(builder, () =>
           this.modifiesJoinTable
             ? builder.where((whereBuilder) =>
-                builder._queryBatch
-                  ? this.applyIdFilterForRelatedTable(whereBuilder, builder._queryBatch)
+                this.relatedIds
+                  ? this.applyIdFilterForRelatedTable(whereBuilder, this.relatedIds)
                   : this.applyModifyFilterForRelatedTable(whereBuilder),
               )
             : this.applyModifyFilterForRelatedTable(builder),
@@ -93,7 +92,7 @@ const ManyToManyModifyMixin = (Operation) => {
 
     applyIdFilterForRelatedTable(builder, ids) {
       const idRefs = this.relation.relatedModelClass.getIdRelationProperty().refs(builder);
-      return builder.whereInComposite(idRefs, ids);
+      return whereInKeys(builder, idRefs, ids);
     }
 
     // Only modifies the join rows that match the filters (#1853).
@@ -171,7 +170,3 @@ class ManyToManyModifyFindOperation extends ManyToManyFindOperation {
     );
   }
 }
-
-module.exports = {
-  ManyToManyModifyMixin,
-};

package/lib/relations/manyToMany/ManyToManyMySqlModifyMixin.js

@@ -1,6 +1,4 @@
-'use strict';
-
-const { ManyToManyModifyMixin } = require('./ManyToManyModifyMixin');
+import { ManyToManyModifyMixin } from './ManyToManyModifyMixin.js';
 
 // We need to override this mixin for mysql because mysql doesn't allow a
 // statement that modifies the join table to read the join table in a
@@ -14,7 +12,7 @@ const { ManyToManyModifyMixin } = require('./ManyToManyModifyMixin');
 // join rows that only differ in their other columns (#1853).
 //
 // https://stackoverflow.com/a/2314264/3729316
-const ManyToManyMySqlModifyMixin = (Operation) => {
+export const ManyToManyMySqlModifyMixin = (Operation) => {
   return class extends ManyToManyModifyMixin(Operation) {
     applyModifyFilterForJoinTable(builder) {
       const { joinTableOwnerProp, joinTableRelatedProp } = this.relation;
@@ -49,7 +47,3 @@ const ManyToManyMySqlModifyMixin = (Operation) => {
     }
   };
 };
-
-module.exports = {
-  ManyToManyMySqlModifyMixin,
-};

package/lib/relations/manyToMany/ManyToManyRelation.js

@@ -1,36 +1,43 @@
-'use strict';
-
-const { getModel } = require('../../model/getModel');
-const { Relation } = require('../Relation');
-const { RelationProperty } = require('../RelationProperty');
-
-const { isSqlite, isMySql } = 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 { withoutOrder } = require('../../queryBuilder/withoutOrder');
-
-const { ManyToManyFindOperation } = require('./find/ManyToManyFindOperation');
-const { ManyToManyInsertOperation } = require('./insert/ManyToManyInsertOperation');
-const { ManyToManyRelateOperation } = require('./relate/ManyToManyRelateOperation');
-
-const { ManyToManyUnrelateOperation } = require('./unrelate/ManyToManyUnrelateOperation');
-const {
-  ManyToManyUnrelateSqliteOperation,
-} = require('./unrelate/ManyToManyUnrelateSqliteOperation');
-const { ManyToManyUnrelateMySqlOperation } = require('./unrelate/ManyToManyUnrelateMySqlOperation');
-
-const { ManyToManyUpdateOperation } = require('./update/ManyToManyUpdateOperation');
-const { ManyToManyUpdateSqliteOperation } = require('./update/ManyToManyUpdateSqliteOperation');
-const { ManyToManyUpdateMySqlOperation } = require('./update/ManyToManyUpdateMySqlOperation');
-
-const { ManyToManyDeleteOperation } = require('./delete/ManyToManyDeleteOperation');
-const { ManyToManyDeleteSqliteOperation } = require('./delete/ManyToManyDeleteSqliteOperation');
-
-class ManyToManyRelation extends Relation {
+import { getModel } from '../../model/getModel.js';
+import { Relation } from '../Relation.js';
+import { RelationProperty } from '../RelationProperty.js';
+
+import { isSqlite, isMySql } from '../../utils/knexUtils.js';
+import { inheritModel } from '../../model/inheritModel.js';
+import { resolveModel } from '../../utils/resolveModel.js';
+import { mapAfterAllReturn } from '../../utils/promiseUtils/index.js';
+import { isFunction, isObject, isString } from '../../utils/objectUtils.js';
+import { createModifier } from '../../utils/createModifier.js';
+import { addWhereGroup } from '../../queryBuilder/whereGroups.js';
+import { withoutOrder } from '../../queryBuilder/withoutOrder.js';
+import { raw } from '../../queryBuilder/RawBuilder.js';
+
+import { ManyToManyFindOperation } from './find/ManyToManyFindOperation.js';
+import { ManyToManyInsertOperation } from './insert/ManyToManyInsertOperation.js';
+import { ManyToManyRelateOperation } from './relate/ManyToManyRelateOperation.js';
+
+import { ManyToManyUnrelateOperation } from './unrelate/ManyToManyUnrelateOperation.js';
+import { ManyToManyUnrelateSqliteOperation } from './unrelate/ManyToManyUnrelateSqliteOperation.js';
+import { ManyToManyUnrelateMySqlOperation } from './unrelate/ManyToManyUnrelateMySqlOperation.js';
+
+import { ManyToManyUpdateOperation } from './update/ManyToManyUpdateOperation.js';
+import { ManyToManyUpdateSqliteOperation } from './update/ManyToManyUpdateSqliteOperation.js';
+import { ManyToManyUpdateMySqlOperation } from './update/ManyToManyUpdateMySqlOperation.js';
+
+import { ManyToManyDeleteOperation } from './delete/ManyToManyDeleteOperation.js';
+import { ManyToManyDeleteSqliteOperation } from './delete/ManyToManyDeleteSqliteOperation.js';
+
+const nestedJoinTypes = {
+  rightJoin: 'right join',
+  rightOuterJoin: 'right outer join',
+  fullOuterJoin: 'full outer join',
+};
+
+export class ManyToManyRelation extends Relation {
+  get keySide() {
+    return 'join';
+  }
+
   setMapping(mapping) {
     const retVal = super.setMapping(mapping);
 
@@ -140,6 +147,7 @@ class ManyToManyRelation extends Relation {
       relatedTable = defaultRelatedTable(this, builder),
       ownerTable = defaultOwnerTable(this, builder),
       joinTableAlias = defaultJoinTableAlias(this, relatedTableAlias, builder),
+      modifyJoin,
     } = {},
   ) {
     let relatedJoinSelect = this.applyModify(relatedJoinSelectQuery).as(relatedTableAlias);
@@ -162,27 +170,50 @@ class ManyToManyRelation extends Relation {
       withoutOrder(joinTableSelect);
     }
 
-    return builder[joinOperation](joinTableSelect, (join) => {
-      const ownerProp = this.ownerProp;
-      const joinTableOwnerProp = this.joinTableOwnerProp;
-
+    const { ownerProp, relatedProp, joinTableOwnerProp, joinTableRelatedProp } = this;
+    const addOwnerConditions = (join) => {
       ownerProp.forEach((i) => {
         const joinTableOwnerRef = joinTableOwnerProp.ref(builder, i).table(joinTableAlias);
         const ownerRef = ownerProp.ref(builder, i).table(ownerTable);
 
         join.on(joinTableOwnerRef, ownerRef);
       });
-    })[joinOperation](relatedJoinSelect, (join) => {
-      const relatedProp = this.relatedProp;
-      const joinTableRelatedProp = this.joinTableRelatedProp;
-
-      relatedProp.forEach((i) => {
-        const joinTableRelatedRef = joinTableRelatedProp.ref(builder, i).table(joinTableAlias);
-        const relatedRef = relatedProp.ref(builder, i).table(relatedTableAlias);
+    };
+    const getRelatedRefs = (i) => [
+      joinTableRelatedProp.ref(builder, i).table(joinTableAlias),
+      relatedProp.ref(builder, i).table(relatedTableAlias),
+    ];
+
+    if (modifyJoin) {
+      // Nest the join of the related table in the join of the join table, so
+      // that the conditions of `modifyJoin()` cover both tables in one ON
+      // clause, and outer joins don't keep the join table rows they exclude.
+      // The nested join keeps the related rows that a right or full join keeps:
+      const nestedJoinType = nestedJoinTypes[joinOperation] || 'inner join';
+      const on = relatedProp.cols.map(() => '? = ?').join(' and ');
+      const nestedJoin = raw(
+        `(${getBinding(joinTableSelect)} ${nestedJoinType} ${getBinding(relatedJoinSelect)} on ${on})`,
+        [
+          joinTableSelect,
+          relatedJoinSelect,
+          ...relatedProp.cols.flatMap((_, i) => getRelatedRefs(i)),
+        ],
+      );
 
-        join.on(joinTableRelatedRef, relatedRef);
+      return builder[joinOperation](nestedJoin, (join) => {
+        addOwnerConditions(join);
+        this._applyModifyJoin(join, modifyJoin, {
+          owner: ownerTable,
+          related: relatedTableAlias,
+          joinTable: joinTableAlias,
+        });
       });
-    });
+    } else {
+      builder[joinOperation](joinTableSelect, addOwnerConditions);
+      return builder[joinOperation](relatedJoinSelect, (join) => {
+        relatedProp.forEach((i) => join.on(...getRelatedRefs(i)));
+      });
+    }
   }
 
   find(_, owner) {
@@ -334,6 +365,11 @@ function defaultJoinTableAlias(relation, relatedTableAlias, builder) {
   }
 }
 
+// Table names go in as identifiers, subqueries as values.
+function getBinding(select) {
+  return isString(select) ? '??' : '?';
+}
+
 function aliasedTableName(tableName, alias) {
   if (tableName === alias) {
     return tableName;
@@ -554,7 +590,3 @@ function getDeleteOperationClass(builder) {
     other: ManyToManyDeleteOperation,
   });
 }
-
-module.exports = {
-  ManyToManyRelation,
-};

package/lib/relations/manyToMany/ManyToManySqliteModifyMixin.js

@@ -1,12 +1,10 @@
-'use strict';
-
-const { ManyToManyModifyMixin } = require('./ManyToManyModifyMixin');
+import { ManyToManyModifyMixin } from './ManyToManyModifyMixin.js';
 const SQLITE_BUILTIN_ROW_ID = '_rowid_';
 
 // We need to override this mixin for sqlite because sqlite doesn't support
 // multi-column where in statements with subqueries. We need to use the
 // internal _rowid_ column instead.
-const ManyToManySqliteModifyMixin = (Operation) => {
+export const ManyToManySqliteModifyMixin = (Operation) => {
   return class extends ManyToManyModifyMixin(Operation) {
     applyModifyFilterForRelatedTable(builder) {
       const tableRef = builder.tableRefFor(this.relation.relatedModelClass);
@@ -17,7 +15,3 @@ const ManyToManySqliteModifyMixin = (Operation) => {
     }
   };
 };
-
-module.exports = {
-  ManyToManySqliteModifyMixin,
-};

package/lib/relations/manyToMany/delete/ManyToManyDeleteOperation.js

@@ -1,10 +1,6 @@
-'use strict';
+import { ManyToManyDeleteOperationBase } from './ManyToManyDeleteOperationBase.js';
+import { ManyToManyModifyMixin } from '../ManyToManyModifyMixin.js';
 
-const { ManyToManyDeleteOperationBase } = require('./ManyToManyDeleteOperationBase');
-const { ManyToManyModifyMixin } = require('../ManyToManyModifyMixin');
-
-class ManyToManyDeleteOperation extends ManyToManyModifyMixin(ManyToManyDeleteOperationBase) {}
-
-module.exports = {
-  ManyToManyDeleteOperation,
-};
+export class ManyToManyDeleteOperation extends ManyToManyModifyMixin(
+  ManyToManyDeleteOperationBase,
+) {}

package/lib/relations/manyToMany/delete/ManyToManyDeleteOperationBase.js

@@ -1,8 +1,6 @@
-'use strict';
+import { DeleteOperation } from '../../../queryBuilder/operations/DeleteOperation.js';
 
-const { DeleteOperation } = require('../../../queryBuilder/operations/DeleteOperation');
-
-class ManyToManyDeleteOperationBase extends DeleteOperation {
+export class ManyToManyDeleteOperationBase extends DeleteOperation {
   constructor(name, opt) {
     super(name, opt);
 
@@ -20,7 +18,3 @@ class ManyToManyDeleteOperationBase extends DeleteOperation {
     throw new Error('not implemented');
   }
 }
-
-module.exports = {
-  ManyToManyDeleteOperationBase,
-};

package/lib/relations/manyToMany/delete/ManyToManyDeleteSqliteOperation.js

@@ -1,12 +1,6 @@
-'use strict';
+import { ManyToManyDeleteOperationBase } from './ManyToManyDeleteOperationBase.js';
+import { ManyToManySqliteModifyMixin } from '../ManyToManySqliteModifyMixin.js';
 
-const { ManyToManyDeleteOperationBase } = require('./ManyToManyDeleteOperationBase');
-const { ManyToManySqliteModifyMixin } = require('../ManyToManySqliteModifyMixin');
-
-class ManyToManyDeleteSqliteOperation extends ManyToManySqliteModifyMixin(
+export class ManyToManyDeleteSqliteOperation extends ManyToManySqliteModifyMixin(
   ManyToManyDeleteOperationBase,
 ) {}
-
-module.exports = {
-  ManyToManyDeleteSqliteOperation,
-};

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

@@ -1,10 +1,7 @@
-'use strict';
+import { RelationFindOperation } from '../../RelationFindOperation.js';
+import { getTempColumn } from '../../../utils/tmpColumnUtils.js';
 
-const { RelationFindOperation } = require('../../RelationFindOperation');
-const { getTempColumn } = require('../../../utils/tmpColumnUtils');
-const { warnOnce } = require('../../../utils/warnings');
-
-class ManyToManyFindOperation extends RelationFindOperation {
+export class ManyToManyFindOperation extends RelationFindOperation {
   constructor(name, opt) {
     super(name, opt);
 
@@ -36,7 +33,7 @@ class ManyToManyFindOperation extends RelationFindOperation {
     }
 
     if (this.owner.isModels) {
-      this.warnOnInvalidOwnerProps();
+      this.checkOwnerProps();
 
       if (this.assignResultToOwner) {
         this.selectMissingJoinColumns(builder);
@@ -44,43 +41,9 @@ class ManyToManyFindOperation extends RelationFindOperation {
     }
   }
 
-  onAfter2(_, related) {
-    const isOneToOne = this.relation.isOneToOne();
-
-    if (this.assignResultToOwner && this.owner.isModels) {
-      const owners = this.owner.modelArray;
-      const ownerProp = this.relation.ownerProp;
-      const relatedByOwnerId = new Map();
-
-      for (let i = 0, l = related.length; i < l; ++i) {
-        const rel = related[i];
-        const key = rel.$propKey(this.ownerJoinColumnAlias);
-        let arr = relatedByOwnerId.get(key);
-
-        if (!arr) {
-          arr = [];
-          relatedByOwnerId.set(key, arr);
-        }
-
-        arr.push(rel);
-      }
-
-      this.warnOnMissingRelatedProps(related);
-
-      for (let i = 0, l = owners.length; i < l; ++i) {
-        const own = owners[i];
-        const key = ownerProp.propKey(own);
-        const related = relatedByOwnerId.get(key);
-
-        if (isOneToOne) {
-          own[this.relationProperty] = (related && related[0]) || null;
-        } else {
-          own[this.relationProperty] = related || [];
-        }
-      }
-    }
-
-    return related;
+  // @override
+  getOwnerKey(related) {
+    return related.$propKey(this.ownerJoinColumnAlias);
   }
 
   // @override
@@ -89,21 +52,21 @@ class ManyToManyFindOperation extends RelationFindOperation {
   }
 
   // The related models are assigned to their owners by the owner join columns
-  // selected from the join table. If they get lost, e.g. in a custom
-  // `$parseDatabaseJson()`, the related models are silently dropped (#2258).
-  warnOnMissingRelatedProps(related) {
-    const { joinTableOwnerProp } = this.relation;
+  // selected from the join table. They can get lost, e.g. in a custom
+  // `$parseDatabaseJson()` (#2258).
+  // @override
+  checkRelatedProps(related) {
+    const { name, ownerModelClass, joinTableOwnerProp } = this.relation;
 
     for (let c = 0, lc = this.ownerJoinColumnAlias.length; c < lc; ++c) {
       const alias = this.ownerJoinColumnAlias[c];
 
       if (related.some((rel) => rel[alias] === undefined)) {
-        warnOnce(
-          `Fetching relation "${this.relation.name}" of ${this.relation.ownerModelClass.name}: ` +
-            `some related models are missing the join table column ` +
-            `"${joinTableOwnerProp.propDescription(c)}" selected as "${alias}", so they are not ` +
-            'assigned to any owner. Check that $parseDatabaseJson() and the column name mappers ' +
-            'of the related model keep it.',
+        throw new Error(
+          `Unable to fetch relation "${name}" of ${ownerModelClass.name}: some related models ` +
+            `are missing the join table column "${joinTableOwnerProp.propDescription(c)}" ` +
+            `selected as "${alias}". Check that $parseDatabaseJson() and the column name ` +
+            'mappers of the related model keep it.',
         );
       }
     }
@@ -127,13 +90,11 @@ class ManyToManyFindOperation extends RelationFindOperation {
       const propName = relatedModelClass.columnNameToPropertyName(this.ownerJoinColumnAlias[i]);
 
       builder.select(joinTableOwnerRef.as(this.ownerJoinColumnAlias[i]));
-      this.omitFromResult(builder, propName);
+      // Unlike the join props, these aliases are never kept, as they aren't
+      // props of the related model.
+      builder.addInternalSelection(propName);
     });
 
     super.selectMissingJoinColumns(builder);
   }
 }
-
-module.exports = {
-  ManyToManyFindOperation,
-};

package/lib/relations/manyToMany/insert/ManyToManyInsertOperation.js

@@ -1,10 +1,9 @@
-'use strict';
+import { hasBatchInsert } from '../../../utils/knexUtils.js';
+import { RelationInsertOperation } from '../../RelationInsertOperation.js';
+import { ManyToManyRelateOperation } from '../relate/ManyToManyRelateOperation.js';
+import { assignRelated } from '../../../model/modelSet.js';
 
-const { hasBatchInsert } = require('../../../utils/knexUtils');
-const { RelationInsertOperation } = require('../../RelationInsertOperation');
-const { ManyToManyRelateOperation } = require('../relate/ManyToManyRelateOperation');
-
-class ManyToManyInsertOperation extends RelationInsertOperation {
+export class ManyToManyInsertOperation extends RelationInsertOperation {
   onAdd(builder, args) {
     const retVal = super.onAdd(builder, args);
 
@@ -26,7 +25,7 @@ class ManyToManyInsertOperation extends RelationInsertOperation {
 
     if (this.assignResultToOwner && this.owner.isModels) {
       for (const owner of this.owner.modelArray) {
-        owner.$appendRelated(this.relation, inserted);
+        assignRelated(owner, this.relation, inserted, { append: true });
       }
     }
 
@@ -53,7 +52,3 @@ class ManyToManyInsertOperation extends RelationInsertOperation {
     return inserted;
   }
 }
-
-module.exports = {
-  ManyToManyInsertOperation,
-};

package/lib/relations/manyToMany/relate/ManyToManyRelateOperation.js

@@ -1,10 +1,8 @@
-'use strict';
+import { isPostgres } from '../../../utils/knexUtils.js';
+import { normalizeIds } from '../../../utils/normalizeIds.js';
+import { RelateOperation } from '../../../queryBuilder/operations/RelateOperation.js';
 
-const { isPostgres } = require('../../../utils/knexUtils');
-const { normalizeIds } = require('../../../utils/normalizeIds');
-const { RelateOperation } = require('../../../queryBuilder/operations/RelateOperation');
-
-class ManyToManyRelateOperation extends RelateOperation {
+export class ManyToManyRelateOperation extends RelateOperation {
   onAdd(builder, args) {
     this.input = args[0];
     this.ids = normalizeIds(args[0], this.relation.relatedProp);
@@ -81,7 +79,3 @@ function assertOwnerIsSingleItem(builder, owner, relation) {
     }
   }
 }
-
-module.exports = {
-  ManyToManyRelateOperation,
-};

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

@@ -1,12 +1,6 @@
-'use strict';
+import { ManyToManyUnrelateOperationBase } from './ManyToManyUnrelateOperationBase.js';
+import { ManyToManyMySqlModifyMixin } from '../ManyToManyMySqlModifyMixin.js';
 
-const { ManyToManyUnrelateOperationBase } = require('./ManyToManyUnrelateOperationBase');
-const { ManyToManyMySqlModifyMixin } = require('../ManyToManyMySqlModifyMixin');
-
-class ManyToManyUnrelateMySqlOperation extends ManyToManyMySqlModifyMixin(
+export class ManyToManyUnrelateMySqlOperation extends ManyToManyMySqlModifyMixin(
   ManyToManyUnrelateOperationBase,
 ) {}
-
-module.exports = {
-  ManyToManyUnrelateMySqlOperation,
-};

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

@@ -1,10 +1,6 @@
-'use strict';
+import { ManyToManyUnrelateOperationBase } from './ManyToManyUnrelateOperationBase.js';
+import { ManyToManyModifyMixin } from '../ManyToManyModifyMixin.js';
 
-const { ManyToManyUnrelateOperationBase } = require('./ManyToManyUnrelateOperationBase');
-const { ManyToManyModifyMixin } = require('../ManyToManyModifyMixin');
-
-class ManyToManyUnrelateOperation extends ManyToManyModifyMixin(ManyToManyUnrelateOperationBase) {}
-
-module.exports = {
-  ManyToManyUnrelateOperation,
-};
+export class ManyToManyUnrelateOperation extends ManyToManyModifyMixin(
+  ManyToManyUnrelateOperationBase,
+) {}

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

@@ -1,9 +1,7 @@
-'use strict';
+import { UnrelateOperation } from '../../../queryBuilder/operations/UnrelateOperation.js';
+import { addWhereGroup } from '../../../queryBuilder/whereGroups.js';
 
-const { UnrelateOperation } = require('../../../queryBuilder/operations/UnrelateOperation');
-const { addWhereGroup } = require('../../../queryBuilder/whereGroups');
-
-class ManyToManyUnrelateOperationBase extends UnrelateOperation {
+export class ManyToManyUnrelateOperationBase extends UnrelateOperation {
   get modifiesJoinTable() {
     return true;
   }
@@ -36,7 +34,3 @@ class ManyToManyUnrelateOperationBase extends UnrelateOperation {
     throw new Error('not implemented');
   }
 }
-
-module.exports = {
-  ManyToManyUnrelateOperationBase,
-};

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

@@ -1,12 +1,6 @@
-'use strict';
+import { ManyToManyUnrelateOperationBase } from './ManyToManyUnrelateOperationBase.js';
+import { ManyToManySqliteModifyMixin } from '../ManyToManySqliteModifyMixin.js';
 
-const { ManyToManyUnrelateOperationBase } = require('./ManyToManyUnrelateOperationBase');
-const { ManyToManySqliteModifyMixin } = require('../ManyToManySqliteModifyMixin');
-
-class ManyToManyUnrelateSqliteOperation extends ManyToManySqliteModifyMixin(
+export class ManyToManyUnrelateSqliteOperation extends ManyToManySqliteModifyMixin(
   ManyToManyUnrelateOperationBase,
 ) {}
-
-module.exports = {
-  ManyToManyUnrelateSqliteOperation,
-};

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

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

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

@@ -1,10 +1,6 @@
-'use strict';
+import { ManyToManyUpdateOperationBase } from './ManyToManyUpdateOperationBase.js';
+import { ManyToManyModifyMixin } from '../ManyToManyModifyMixin.js';
 
-const { ManyToManyUpdateOperationBase } = require('./ManyToManyUpdateOperationBase');
-const { ManyToManyModifyMixin } = require('../ManyToManyModifyMixin');
-
-class ManyToManyUpdateOperation extends ManyToManyModifyMixin(ManyToManyUpdateOperationBase) {}
-
-module.exports = {
-  ManyToManyUpdateOperation,
-};
+export class ManyToManyUpdateOperation extends ManyToManyModifyMixin(
+  ManyToManyUpdateOperationBase,
+) {}