fix(dml): Throw when many to many are not configured properly (#9085)

**What**
When both sides of a many to many relationship do not define the mapped by option, it leads to misconfigured relations and a malformed SQL query. (ref. #9075)

- When both mapped by are not defined, infer look up to try to identify the missing configuration if any
- Disallow defining many to many only on one side

packages/core/types/src/dml/index.ts

@@ -90,7 +90,7 @@ export type PropertyType<T> = {
 export type RelationshipOptions = {
  /**
  * The name of the relationship as defined in the other
- * data model. This is only required by the `belongsTo`
+ * data model. This is only required by the `belongsTo` and `manyToMany`
  * relationship method.
  */
  mappedBy?: string

packages/core/utils/src/dml/__tests__/entity-builder.spec.ts

@@ -2971,6 +2971,7 @@ describe("Entity builder", () => {
  })
  .indexes([
  {
+ // @ts-expect-error
  on: ["email", "account", "doesnotexist", "anotherdoesnotexist"],
  },
  ])
@@ -4714,7 +4715,9 @@ describe("Entity builder", () => {
  const user = model.define("user", {
  id: model.number(),
  username: model.text(),
- teams: model.manyToMany(() => team),
+ teams: model.manyToMany(() => team, {
+ mappedBy: "users",
+ }),
  })
 
  const User = toMikroORMEntity(user)
@@ -4775,6 +4778,7 @@ describe("Entity builder", () => {
  name: "teams",
  entity: "Team",
  pivotTable: "team_users",
+ mappedBy: "users",
  },
  created_at: {
  reference: "scalar",
@@ -5686,7 +5690,9 @@ describe("Entity builder", () => {
  const user = model.define("platform.user", {
  id: model.number(),
  username: model.text(),
- teams: model.manyToMany(() => team),
+ teams: model.manyToMany(() => team, {
+ mappedBy: "users",
+ }),
  })
 
  const User = toMikroORMEntity(user)
@@ -5748,6 +5754,7 @@ describe("Entity builder", () => {
  name: "teams",
  entity: "Team",
  pivotTable: "platform.team_users",
+ mappedBy: "users",
  },
  created_at: {
  reference: "scalar",
@@ -5867,7 +5874,10 @@ describe("Entity builder", () => {
  const user = model.define("user", {
  id: model.number(),
  username: model.text(),
- teams: model.manyToMany(() => team, { pivotTable: "users_teams" }),
+ teams: model.manyToMany(() => team, {
+ pivotTable: "users_teams",
+ mappedBy: "users",
+ }),
  })
 
  const User = toMikroORMEntity(user)
@@ -5928,6 +5938,7 @@ describe("Entity builder", () => {
  name: "teams",
  entity: "Team",
  pivotTable: "users_teams",
+ mappedBy: "users",
  },
  created_at: {
  reference: "scalar",
@@ -6052,7 +6063,10 @@ describe("Entity builder", () => {
  const user = model.define("user", {
  id: model.number(),
  username: model.text(),
- teams: model.manyToMany(() => team, { pivotEntity: () => squad }),
+ teams: model.manyToMany(() => team, {
+ pivotEntity: () => squad,
+ mappedBy: "users",
+ }),
  })
 
  const [User, Team, Squad] = toMikroOrmEntities([user, team, squad])
@@ -6203,6 +6217,7 @@ describe("Entity builder", () => {
  name: "teams",
  entity: "Team",
  pivotEntity: "TeamUsers",
+ mappedBy: "users",
  },
  created_at: {
  reference: "scalar",

packages/core/utils/src/dml/helpers/entity-builder/define-relationship.ts

@@ -9,9 +9,9 @@ import {
  BeforeCreate,
  ManyToMany,
  ManyToOne,
- OnInit,
  OneToMany,
  OneToOne,
+ OnInit,
  Property,
  rel,
 } from "@mikro-orm/core"
@@ -27,6 +27,66 @@ type Context = {
  MANY_TO_MANY_TRACKED_RELATIONS: Record<string, boolean>
 }
 
+/**
+ * Validates a many to many relationship without mappedBy and checks if the other side of the relationship is defined and possesses mappedBy.
+ * @param MikroORMEntity
+ * @param relationship
+ * @param relatedEntity
+ * @param relatedModelName
+ */
+function validateManyToManyRelationshipWithoutMappedBy({
+ MikroORMEntity,
+ relationship,
+ relatedEntity,
+ relatedModelName,
+}: {
+ MikroORMEntity: EntityConstructor<any>
+ relationship: RelationshipMetadata
+ relatedEntity: DmlEntity<
+ Record<string, PropertyType<any> | RelationshipType<any>>,
+ any
+ >
+ relatedModelName: string
+}) {
+ /**
+ * Since we don't have the information about the other side of the
+ * relationship, we will try to find all the other side many to many that refers to the current entity.
+ * If there is any, we will try to find if at least one of them has a mappedBy.
+ */
+ const potentialOtherSides = Object.entries(relatedEntity.schema)
+ .filter(([, propConfig]) => DmlManyToMany.isManyToMany(propConfig))
+ .filter(([prop, propConfig]) => {
+ const parsedProp = propConfig.parse(prop) as RelationshipMetadata
+ const relatedEntity =
+ typeof parsedProp.entity === "function"
+ ? parsedProp.entity()
+ : undefined
+
+ if (!relatedEntity) {
+ throw new Error(
+ `Invalid relationship reference for "${relatedModelName}.${prop}". Make sure to define the relationship using a factory function`
+ )
+ }
+
+ return parseEntityName(relatedEntity).modelName === MikroORMEntity.name
+ }) as unknown as [string, RelationshipType<any>][]
+
+ if (potentialOtherSides.length) {
+ const hasMappedBy = potentialOtherSides.some(
+ ([, propConfig]) => !!propConfig.parse("").mappedBy
+ )
+ if (!hasMappedBy) {
+ throw new Error(
+ `Invalid relationship reference for "${MikroORMEntity.name}.${relationship.name}". "mappedBy" should be defined on one side or the other.`
+ )
+ }
+ } else {
+ throw new Error(
+ `Invalid relationship reference for "${MikroORMEntity.name}.${relationship.name}". The other side of the relationship is missing.`
+ )
+ }
+}
+
 /**
  * Defines has one relationship on the Mikro ORM entity.
  */
@@ -280,6 +340,13 @@ export function defineManyToManyRelationship(
  `${MikroORMEntity.name}.${relationship.name}`
  ] = true
  }
+ } else {
+ validateManyToManyRelationshipWithoutMappedBy({
+ MikroORMEntity,
+ relationship,
+ relatedEntity,
+ relatedModelName,
+ })
  }
 
  /**

packages/core/utils/src/dml/integration-tests/__tests__/many-to-many.spec.ts

@@ -186,4 +186,65 @@ describe("manyToMany - manyToMany", () => {
  ]),
  })
  })
+
+ it(`should fail to load the dml's if both side of the relation are missing the mappedBy options`, () => {
+ const team = model.define("team", {
+ id: model.id().primaryKey(),
+ name: model.text(),
+ users: model.manyToMany(() => user, {
+ pivotEntity: () => squad,
+ }),
+ })
+
+ const squad = model.define("teamUsers", {
+ id: model.id().primaryKey(),
+ user: model.belongsTo(() => user, { mappedBy: "squads" }),
+ squad: model.belongsTo(() => team, { mappedBy: "users" }),
+ })
+
+ const user = model.define("user", {
+ id: model.id().primaryKey(),
+ username: model.text(),
+ squads: model.manyToMany(() => team, {
+ pivotEntity: () => squad,
+ }),
+ })
+
+ let error!: Error
+ try {
+ ;[User, Squad, Team] = toMikroOrmEntities([user, squad, team])
+ } catch (e) {
+ error = e
+ }
+
+ expect(error).toBeTruthy()
+ expect(error.message).toEqual(
+ 'Invalid relationship reference for "User.squads". "mappedBy" should be defined on one side or the other.'
+ )
+ })
+
+ it(`should fail to load the dml's if the relation is defined only on one side`, () => {
+ const team = model.define("team", {
+ id: model.id().primaryKey(),
+ name: model.text(),
+ users: model.manyToMany(() => user),
+ })
+
+ const user = model.define("user", {
+ id: model.id().primaryKey(),
+ username: model.text(),
+ })
+
+ let error!: Error
+ try {
+ ;[User, Team] = toMikroOrmEntities([user, team])
+ } catch (e) {
+ error = e
+ }
+
+ expect(error).toBeTruthy()
+ expect(error.message).toEqual(
+ 'Invalid relationship reference for "Team.users". The other side of the relationship is missing.'
+ )
+ })
 })