objection 3.9.1 → 4.0.0-rc.1

package/lib/relations/belongsToMany/BelongsToManyRelation.js

@@ -0,0 +1,276 @@
+import { Relation } from '../Relation.js';
+import { BelongsToManyFindOperation } from './BelongsToManyFindOperation.js';
+import { BelongsToManyInsertOperation } from './BelongsToManyInsertOperation.js';
+import { BelongsToManyDeleteOperation } from './BelongsToManyDeleteOperation.js';
+import { BelongsToManyRelateOperation } from './BelongsToManyRelateOperation.js';
+import { BelongsToManyUnrelateOperation } from './BelongsToManyUnrelateOperation.js';
+
+import { raw } from '../../queryBuilder/RawBuilder.js';
+import { ref } from '../../queryBuilder/ReferenceBuilder.js';
+import { addWhereGroup } from '../../queryBuilder/whereGroups.js';
+import { isOwnerModelClassQuery } from '../RelationOwner.js';
+import { valuesKey } from '../../model/modelValues.js';
+import { isPostgres, isMySql, isSqlite, isMsSql, whereInKeys } from '../../utils/knexUtils.js';
+import { jsonEquals } from '../../utils/objectUtils.js';
+import * as promiseUtils from '../../utils/promiseUtils/index.js';
+
+// The alias of the owner rows in `findQuery()` when the owners are given as ids
+// or as a query:
+const ownersAlias = 'objectiontmpowners';
+
+export class BelongsToManyRelation extends Relation {
+  // The owner holds the keys, in an array.
+  get keySide() {
+    return 'owner';
+  }
+
+  setMapping(mapping) {
+    const retVal = super.setMapping(mapping);
+
+    if (this.ownerProp.size !== 1) {
+      throw this.createError('composite keys are not supported.');
+    }
+
+    return retVal;
+  }
+
+  // The keys of the related models that `owner` holds in its array:
+  getKeys(owner) {
+    const keys = this.ownerProp.getProp(owner, 0);
+
+    if (keys == null) {
+      return [];
+    } else if (Array.isArray(keys)) {
+      return keys.filter((key) => key != null);
+    } else {
+      throw this.createError(
+        `the join property "${this.ownerProp.propDescription(0)}" must hold an array of keys, ` +
+          `not ${JSON.stringify(keys)}. Add it to the jsonAttributes of ${this.ownerModelClass.name} ` +
+          'if it holds a JSON array.',
+      );
+    }
+  }
+
+  // Remove the duplicate keys, keeping the first of each:
+  normalizeKeys(keys) {
+    const seen = new Set();
+
+    return keys.filter((key) => {
+      const id = valuesKey([key]);
+      const isNew = !seen.has(id);
+      seen.add(id);
+      return isNew;
+    });
+  }
+
+  // Remove the keys in `remove` from `keys` and add the ones in `add`, leaving
+  // out empty keys. Keys that are already there keep their place and value:
+  changeKeys(keys, { add = [], remove = [] }) {
+    const removedKeys = new Set(remove.map((key) => valuesKey([key])));
+
+    return this.normalizeKeys([
+      ...keys.filter((key) => !removedKeys.has(valuesKey([key]))),
+      ...add.filter((key) => key != null),
+    ]);
+  }
+
+  // Create the patch that writes `keys` to the array of the `owner` row: only
+  // the array inside a JSON column, unless the column is empty.
+  createKeysPatch(owner, keys) {
+    const patch = {};
+
+    if (owner[this.ownerProp.props[0]] == null) {
+      this.ownerProp.setProp(patch, 0, keys);
+    } else {
+      this.ownerProp.patch(patch, 0, keys);
+    }
+
+    return patch;
+  }
+
+  findQuery(builder, owner) {
+    const relatedRef = this.relatedProp.ref(builder, 0);
+
+    addWhereGroup(builder, () => {
+      if (owner.isReference) {
+        builder.where(containsKey(builder, owner.reference[0], relatedRef));
+      } else if (owner.isModels) {
+        const keys = this.normalizeKeys(owner.modelArray.flatMap((model) => this.getKeys(model)));
+        // Empty arrays are normal here, so we don't resolve the query early,
+        // to keep the result of updates, deletes and aggregates.
+        if (keys.length) {
+          whereInKeys(builder, [relatedRef], keys);
+        } else {
+          builder.where(false);
+        }
+      } else if (owner.isIdentifiers || owner.isQueryBuilder) {
+        // Look for the related rows in the arrays of the owner rows. The owner
+        // query becomes a derived table, so that its `limit()` keeps applying
+        // to the owners. The arrays are selected under the name of the owner
+        // column, also for JSON field expressions.
+        const owners = owner.getProps(this);
+        const keysColumn = this.ownerProp.cols[0];
+
+        if (isOwnerModelClassQuery(owners, this)) {
+          owners.clearSelect().select(this.ownerProp.ref(owners, 0).as(keysColumn));
+        }
+
+        builder.whereExists(
+          this.ownerModelClass
+            .query()
+            .childQueryOf(builder)
+            .select(1)
+            .from(owners.as(ownersAlias))
+            .where(containsKey(builder, ref(`${ownersAlias}.${keysColumn}`), relatedRef)),
+        );
+      } else {
+        builder.where(false).resolve([]);
+      }
+    });
+
+    return this.applyModify(builder);
+  }
+
+  // @override
+  joinOn(builder, join, { relatedTableAlias, ownerTable }) {
+    const relatedRef = this.relatedProp.ref(builder, 0).table(relatedTableAlias);
+    const keysRef = this.ownerProp.ref(builder, 0).table(ownerTable);
+
+    join.on(containsKey(builder, keysRef, relatedRef));
+  }
+
+  find(_, owner) {
+    return new BelongsToManyFindOperation('find', {
+      relation: this,
+      owner,
+    });
+  }
+
+  insert(_, owner) {
+    return new BelongsToManyInsertOperation('insert', {
+      relation: this,
+      owner,
+    });
+  }
+
+  delete(_, owner) {
+    return new BelongsToManyDeleteOperation('delete', {
+      relation: this,
+      owner,
+    });
+  }
+
+  relate(_, owner) {
+    return new BelongsToManyRelateOperation('relate', {
+      relation: this,
+      owner,
+    });
+  }
+
+  unrelate(_, owner) {
+    return new BelongsToManyUnrelateOperation('unrelate', {
+      relation: this,
+      owner,
+    });
+  }
+
+  // Find the keys of the related rows that `builder` filters, for `unrelate()`
+  // and `delete()`. Like all internal reads of the relation, it calls no find
+  // hooks.
+  findKeys(builder, owner) {
+    const query = this.relatedModelClass
+      .query()
+      .childQueryOf(builder)
+      .findOptions({ dontCallFindHooks: true });
+
+    return query
+      .copyFrom(builder, builder.constructor.JoinSelector)
+      .copyFrom(builder, builder.constructor.WhereSelector)
+      .modify((query) => this.findQuery(query, owner))
+      .select(this.relatedProp.ref(query, 0))
+      .runAfter((related) => related.map((rel) => this.relatedProp.getProp(rel, 0)));
+  }
+
+  // Add and remove keys in the arrays of the owner rows, and in the owner
+  // models. Resolves to the number of owner rows that changed. The arrays are
+  // read without the find hooks and written back by separate queries.
+  updateKeys(builder, owner, { add = [], remove = [] }) {
+    const { ownerModelClass, ownerProp } = this;
+    const idProp = ownerModelClass.getIdRelationProperty();
+    const ownerIds = owner.getProps(this, idProp);
+    const query = ownerModelClass
+      .query()
+      .childQueryOf(builder)
+      .findOptions({ dontCallFindHooks: true });
+    const idRefs = idProp.refs(query);
+
+    const updateRow = async (row) => {
+      const keys = this.getKeys(row);
+      const newKeys = this.changeKeys(keys, { add, remove });
+      const isChanged = !jsonEquals(keys, newKeys);
+
+      if (isChanged) {
+        const patch = this.createKeysPatch(row, newKeys);
+
+        await ownerModelClass.query().childQueryOf(builder).patch(patch).findById(row.$id());
+      }
+
+      if (owner.isModels) {
+        const id = row.$idKey();
+
+        for (const model of owner.modelArray) {
+          if (model.$hasId() && model.$idKey() === id) {
+            ownerProp.setProp(model, 0, newKeys);
+          }
+        }
+      }
+
+      return isChanged;
+    };
+
+    // Select the whole column of the arrays, also for JSON field expressions:
+    return query
+      .select([...idRefs, `${query.tableRefFor(ownerModelClass)}.${ownerProp.cols[0]}`])
+      .modify((query) => {
+        if (ownerIds) {
+          query.whereInComposite(idRefs, ownerIds);
+        } else {
+          query.resolve([]);
+        }
+      })
+      .runAfter(async (rows) => {
+        const results = await promiseUtils.map(rows, updateRow, {
+          concurrency: ownerModelClass.getConcurrency(builder.unsafeKnex()),
+        });
+
+        return results.filter(Boolean).length;
+      });
+  }
+}
+
+Object.defineProperties(BelongsToManyRelation.prototype, {
+  isObjectionBelongsToManyRelation: {
+    enumerable: false,
+    writable: false,
+    value: true,
+  },
+});
+
+// The condition for the array of keys in `keysRef` to contain the key in
+// `keyRef`. Postgres converts both to jsonb, which supports json, jsonb and
+// native array columns alike.
+function containsKey(builder, keysRef, keyRef) {
+  const knex = builder.knex();
+
+  if (isPostgres(knex)) {
+    return raw('to_jsonb(?) @> to_jsonb(?)', [keysRef, keyRef]);
+  } else if (isMySql(knex)) {
+    return raw('? member of (?)', [keyRef, keysRef]);
+  } else if (isSqlite(knex)) {
+    return raw('exists (select 1 from json_each(?) where value = ?)', [keysRef, keyRef]);
+  } else if (isMsSql(knex)) {
+    return raw('exists (select 1 from openjson(?) where value = ?)', [keysRef, keyRef]);
+  } else {
+    throw new Error(`Unsupported database for BelongsToManyRelation: '${knex.client.dialect}'.`);
+  }
+}

package/lib/relations/belongsToMany/BelongsToManyUnrelateOperation.js

@@ -0,0 +1,11 @@
+import { UnrelateOperation } from '../../queryBuilder/operations/UnrelateOperation.js';
+
+export class BelongsToManyUnrelateOperation extends UnrelateOperation {
+  // Remove the keys of the related rows that the query finds, so that its
+  // `where` clauses and the relation's `modify` filter the related rows.
+  queryExecutor(builder) {
+    return this.relation
+      .findKeys(builder, this.owner)
+      .runAfter((keys) => this.relation.updateKeys(builder, this.owner, { remove: keys }));
+  }
+}

package/lib/relations/belongsToOne/BelongsToOneDeleteOperation.js

@@ -1,8 +1,6 @@
-'use strict';
+import { RelationDeleteOperation } from '../RelationDeleteOperation.js';
 
-const { RelationDeleteOperation } = require('../RelationDeleteOperation');
-
-class BelongsToOneDeleteOperation extends RelationDeleteOperation {
+export class BelongsToOneDeleteOperation extends RelationDeleteOperation {
   onAfter1(builder, result) {
     // A query resolved without executing it, e.g. with `none()`, deleted
     // nothing, so the owners are left untouched.
@@ -19,7 +17,3 @@ class BelongsToOneDeleteOperation extends RelationDeleteOperation {
     return result;
   }
 }
-
-module.exports = {
-  BelongsToOneDeleteOperation,
-};

package/lib/relations/belongsToOne/BelongsToOneInsertOperation.js

@@ -1,10 +1,9 @@
-'use strict';
+import { RelationInsertOperation } from '../RelationInsertOperation.js';
+import { BelongsToOneRelateOperation } from './BelongsToOneRelateOperation.js';
+import { InsertGraphOperation } from '../../queryBuilder/operations/InsertGraphOperation.js';
+import { assignRelated } from '../../model/modelSet.js';
 
-const { RelationInsertOperation } = require('../RelationInsertOperation');
-const { BelongsToOneRelateOperation } = require('./BelongsToOneRelateOperation');
-const { InsertGraphOperation } = require('../../queryBuilder/operations/InsertGraphOperation');
-
-class BelongsToOneInsertOperation extends RelationInsertOperation {
+export class BelongsToOneInsertOperation extends RelationInsertOperation {
   onAdd(builder, args) {
     const retVal = super.onAdd(builder, args);
 
@@ -33,7 +32,7 @@ class BelongsToOneInsertOperation extends RelationInsertOperation {
 
     if (this.assignResultToOwner && this.owner.isModels) {
       for (const owner of this.owner.modelArray) {
-        owner.$setRelated(this.relation, inserted);
+        assignRelated(owner, this.relation, inserted);
       }
     }
 
@@ -43,7 +42,3 @@ class BelongsToOneInsertOperation extends RelationInsertOperation {
     return inserted;
   }
 }
-
-module.exports = {
-  BelongsToOneInsertOperation,
-};

package/lib/relations/belongsToOne/BelongsToOneRelateOperation.js

@@ -1,9 +1,7 @@
-'use strict';
+import { normalizeIds } from '../../utils/normalizeIds.js';
+import { RelateOperation } from '../../queryBuilder/operations/RelateOperation.js';
 
-const { normalizeIds } = require('../../utils/normalizeIds');
-const { RelateOperation } = require('../../queryBuilder/operations/RelateOperation');
-
-class BelongsToOneRelateOperation extends RelateOperation {
+export class BelongsToOneRelateOperation extends RelateOperation {
   onAdd(_, args) {
     this.input = args[0];
     this.ids = normalizeIds(args[0], this.relation.relatedProp, { arrayOutput: true });
@@ -49,7 +47,3 @@ function assertOneId(ids) {
     throw new Error('can only relate one model to a BelongsToOneRelation');
   }
 }
-
-module.exports = {
-  BelongsToOneRelateOperation,
-};

package/lib/relations/belongsToOne/BelongsToOneRelation.js

@@ -1,23 +1,16 @@
-'use strict';
+import { Relation } from '../Relation.js';
+import { BelongsToOneInsertOperation } from './BelongsToOneInsertOperation.js';
+import { BelongsToOneDeleteOperation } from './BelongsToOneDeleteOperation.js';
+import { BelongsToOneRelateOperation } from './BelongsToOneRelateOperation.js';
+import { BelongsToOneUnrelateOperation } from './BelongsToOneUnrelateOperation.js';
 
-const { Relation } = require('../Relation');
-const { BelongsToOneInsertOperation } = require('./BelongsToOneInsertOperation');
-const { BelongsToOneDeleteOperation } = require('./BelongsToOneDeleteOperation');
-const { BelongsToOneRelateOperation } = require('./BelongsToOneRelateOperation');
-const { BelongsToOneUnrelateOperation } = require('./BelongsToOneUnrelateOperation');
-
-class BelongsToOneRelation extends Relation {
+export class BelongsToOneRelation extends Relation {
   isOneToOne() {
     return true;
   }
 
-  // The foreign key is unset when no related model was ever assigned, e.g. on
-  // models returned by `insert()` or created with `fromJson()`, where no
-  // related model is the right result. This can't be told apart from a
-  // foreign key left out of a partial `select()`. Foreign keys that are part
-  // of the id are always expected to be set (#132).
-  isOptionalOwnerProp(index) {
-    return !this.ownerModelClass.getIdPropertyArray().includes(this.ownerProp.props[index]);
+  get keySide() {
+    return 'owner';
   }
 
   insert(_, owner) {
@@ -56,7 +49,3 @@ Object.defineProperties(BelongsToOneRelation.prototype, {
     value: true,
   },
 });
-
-module.exports = {
-  BelongsToOneRelation,
-};

package/lib/relations/belongsToOne/BelongsToOneUnrelateOperation.js

@@ -1,8 +1,6 @@
-'use strict';
+import { UnrelateOperation } from '../../queryBuilder/operations/UnrelateOperation.js';
 
-const { UnrelateOperation } = require('../../queryBuilder/operations/UnrelateOperation');
-
-class BelongsToOneUnrelateOperation extends UnrelateOperation {
+export class BelongsToOneUnrelateOperation extends UnrelateOperation {
   onAdd() {
     const ids = new Array(this.relation.ownerProp.size);
 
@@ -15,47 +13,75 @@ class BelongsToOneUnrelateOperation extends UnrelateOperation {
   }
 
   queryExecutor(builder) {
+    const { relation, owner } = this;
+    const { ownerProp, ownerModelClass } = relation;
     const patch = {};
-    const ownerProp = this.relation.ownerProp;
 
     ownerProp.forEach((i) => {
-      const relatedValue = this.ids[0][i];
-
-      if (this.owner.isModels) {
-        for (const owner of this.owner.modelArray) {
-          ownerProp.setProp(owner, i, relatedValue);
-        }
-      }
-
-      ownerProp.patch(patch, i, relatedValue);
+      ownerProp.patch(patch, i, this.ids[0][i]);
     });
 
-    const ownerIdProp = this.relation.ownerModelClass.getIdRelationProperty();
+    const ownerIdProp = ownerModelClass.getIdRelationProperty();
     const ownerRefs = ownerIdProp.refs(builder);
-    const ownerIds = this.owner.getProps(this.relation, ownerIdProp);
+    const ownerIds = owner.getProps(relation, ownerIdProp);
+    const isFiltered = !!relation.modify || builder.has(builder.constructor.WhereSelector);
+
+    const clearOwnerKeys = (owners) => {
+      for (const owner of owners) {
+        ownerProp.forEach((i) => ownerProp.setProp(owner, i, null));
+      }
+    };
 
-    const query = this.relation.ownerModelClass
+    const query = ownerModelClass
       .query()
       .childQueryOf(builder)
       .patch(patch)
       .whereInComposite(ownerRefs, ownerIds);
 
-    // We are creating a query to the related items. So any `where` statements
-    // must filter the *related* items, not the root query above, which is actually
-    // for the owners.
-    if (builder.has(builder.constructor.WhereSelector)) {
+    if (!isFiltered) {
+      if (owner.isModels) {
+        clearOwnerKeys(owner.modelArray);
+      }
+    } else {
+      // We are creating a query to the related items. So any `where` statements
+      // and the relation's `modify` must filter the *related* items, not the
+      // root query above, which is actually for the owners.
       query.whereExists(
-        this.relation.ownerModelClass
-          .relatedQuery(this.relation.name)
+        ownerModelClass
+          .relatedQuery(relation.name)
+          .childQueryOf(builder)
           .copyFrom(builder, builder.constructor.JoinSelector)
           .copyFrom(builder, builder.constructor.WhereSelector),
       );
+
+      if (owner.isModels) {
+        // Only clear the keys of the owner models whose related row matched.
+        // Unless all or none did, read back which ones the query unrelated:
+        query.runAfter(async (numUnrelated) => {
+          if (numUnrelated === ownerIds.length) {
+            clearOwnerKeys(owner.modelArray);
+          } else if (numUnrelated > 0) {
+            const keysQuery = ownerModelClass
+              .query()
+              .childQueryOf(builder)
+              .findOptions({ dontCallFindHooks: true });
+            const table = keysQuery.tableRefFor(ownerModelClass);
+            // Select the whole columns, also for JSON field expressions:
+            const rows = await keysQuery
+              .select([...ownerRefs, ...ownerProp.cols.map((col) => `${table}.${col}`)])
+              .whereInComposite(ownerRefs, ownerIds);
+            const unrelatedIds = new Set(
+              rows.filter((row) => !ownerProp.hasProps(row)).map((row) => row.$idKey()),
+            );
+
+            clearOwnerKeys(owner.modelArray.filter((owner) => unrelatedIds.has(owner.$idKey())));
+          }
+
+          return numUnrelated;
+        });
+      }
     }
 
     return query;
   }
 }
-
-module.exports = {
-  BelongsToOneUnrelateOperation,
-};

package/lib/relations/hasMany/HasManyInsertOperation.js

@@ -1,9 +1,8 @@
-'use strict';
+import { RelationInsertOperation } from '../RelationInsertOperation.js';
+import { removeOverriddenQueryProps } from '../../model/modelQueryProps.js';
+import { assignRelated } from '../../model/modelSet.js';
 
-const { RelationInsertOperation } = require('../RelationInsertOperation');
-const { removeOverriddenQueryProps } = require('../../model/modelQueryProps');
-
-class HasManyInsertOperation extends RelationInsertOperation {
+export class HasManyInsertOperation extends RelationInsertOperation {
   onAdd(builder, args) {
     const retVal = super.onAdd(builder, args);
     assertOwnerIsSingleItem(this.owner, this.relation);
@@ -32,7 +31,7 @@ class HasManyInsertOperation extends RelationInsertOperation {
 
     if (this.owner.isModels) {
       for (const owner of this.owner.modelArray) {
-        owner.$appendRelated(this.relation, inserted);
+        assignRelated(owner, this.relation, inserted, { append: true });
       }
     }
 
@@ -59,7 +58,3 @@ function assertOwnerIsSingleItem(owner, relation) {
     );
   }
 }
-
-module.exports = {
-  HasManyInsertOperation,
-};

package/lib/relations/hasMany/HasManyRelateOperation.js

@@ -1,10 +1,8 @@
-'use strict';
+import { normalizeIds } from '../../utils/normalizeIds.js';
+import { RelateOperation } from '../../queryBuilder/operations/RelateOperation.js';
+import { addWhereGroup } from '../../queryBuilder/whereGroups.js';
 
-const { normalizeIds } = require('../../utils/normalizeIds');
-const { RelateOperation } = require('../../queryBuilder/operations/RelateOperation');
-const { addWhereGroup } = require('../../queryBuilder/whereGroups');
-
-class HasManyRelateOperation extends RelateOperation {
+export class HasManyRelateOperation extends RelateOperation {
   onAdd(_, args) {
     this.input = args[0];
 
@@ -33,7 +31,7 @@ class HasManyRelateOperation extends RelateOperation {
       .copyFrom(builder, builder.constructor.JoinSelector)
       .copyFrom(builder, builder.constructor.WhereSelector)
       .modify((query) => {
-        addWhereGroup(query, () => query.findByIds(this.ids));
+        query.findByIds(this.ids);
         addWhereGroup(query, () => query.modify(this.relation.modify));
       });
   }
@@ -58,7 +56,3 @@ function assertOwnerIsSingleItem(owner, relation) {
     );
   }
 }
-
-module.exports = {
-  HasManyRelateOperation,
-};

package/lib/relations/hasMany/HasManyRelation.js

@@ -1,11 +1,13 @@
-'use strict';
-
-const { Relation } = require('../Relation');
-const { HasManyInsertOperation } = require('./HasManyInsertOperation');
-const { HasManyRelateOperation } = require('./HasManyRelateOperation');
-const { HasManyUnrelateOperation } = require('./HasManyUnrelateOperation');
+import { Relation } from '../Relation.js';
+import { HasManyInsertOperation } from './HasManyInsertOperation.js';
+import { HasManyRelateOperation } from './HasManyRelateOperation.js';
+import { HasManyUnrelateOperation } from './HasManyUnrelateOperation.js';
+
+export class HasManyRelation extends Relation {
+  get keySide() {
+    return 'related';
+  }
 
-class HasManyRelation extends Relation {
   insert(_, owner) {
     return new HasManyInsertOperation('insert', {
       relation: this,
@@ -43,7 +45,3 @@ Object.defineProperties(HasManyRelation.prototype, {
     value: true,
   },
 });
-
-module.exports = {
-  HasManyRelation,
-};

package/lib/relations/hasMany/HasManyUnrelateOperation.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 HasManyUnrelateOperation extends UnrelateOperation {
+export class HasManyUnrelateOperation extends UnrelateOperation {
   queryExecutor(builder) {
     const patch = {};
     const relatedProp = this.relation.relatedProp;
@@ -26,7 +24,3 @@ class HasManyUnrelateOperation extends UnrelateOperation {
       });
   }
 }
-
-module.exports = {
-  HasManyUnrelateOperation,
-};

package/lib/relations/hasOne/HasOneRelation.js

@@ -1,13 +1,7 @@
-'use strict';
+import { HasManyRelation } from '../hasMany/HasManyRelation.js';
 
-const { HasManyRelation } = require('../hasMany/HasManyRelation');
-
-class HasOneRelation extends HasManyRelation {
+export class HasOneRelation extends HasManyRelation {
   isOneToOne() {
     return true;
   }
 }
-
-module.exports = {
-  HasOneRelation,
-};

package/lib/relations/hasOneThrough/HasOneThroughRelation.js

@@ -1,13 +1,7 @@
-'use strict';
+import { ManyToManyRelation } from '../manyToMany/ManyToManyRelation.js';
 
-const { ManyToManyRelation } = require('../manyToMany/ManyToManyRelation');
-
-class HasOneThroughRelation extends ManyToManyRelation {
+export class HasOneThroughRelation extends ManyToManyRelation {
   isOneToOne() {
     return true;
   }
 }
-
-module.exports = {
-  HasOneThroughRelation,
-};