fix(utils): Cascade soft deletion management

packages/core/utils/src/dal/mikro-orm/utils.ts

@@ -1,6 +1,7 @@
 import { Collection, EntityMetadata, FindOptions, wrap } from "@mikro-orm/core"
 import { SqlEntityManager } from "@mikro-orm/postgresql"
 import { buildQuery } from "../../modules-sdk/build-query"
+import { isString } from "../../common/is-string"
 
 function detectCircularDependency(
  manager: SqlEntityManager,
@@ -23,7 +24,13 @@ function detectCircularDependency(
  for (const relation of relationsToCascade) {
  const branchVisited = new Set(Array.from(visited))
 
- const isSelfCircularDependency = entityMetadata.class === relation.entity()
+ const relationEntity =
+ typeof relation.entity === "function"
+ ? relation.entity()
+ : relation.entity
+ const isSelfCircularDependency = isString(relationEntity)
+ ? entityMetadata.className === relationEntity
+ : entityMetadata.class === relationEntity
 
  if (!isSelfCircularDependency && branchVisited.has(relation.name)) {
  const dependencies = Array.from(visited)

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

@@ -2,11 +2,17 @@ import { MetadataStorage, MikroORM } from "@mikro-orm/core"
 import { model } from "../../entity-builder"
 import { toMikroOrmEntities } from "../../helpers/create-mikro-orm-entity"
 import { createDatabase, dropDatabase } from "pg-god"
-import { CustomTsMigrationGenerator, mikroOrmSerializer } from "../../../dal"
+import {
+ CustomTsMigrationGenerator,
+ mikroOrmSerializer,
+ mikroOrmUpdateDeletedAtRecursively,
+ SoftDeletableFilterKey,
+} from "../../../dal"
 import { EntityConstructor } from "@medusajs/types"
 import { pgGodCredentials } from "../utils"
 import { FileSystem } from "../../../common"
 import { join } from "path"
+import { SqlEntityManager } from "@mikro-orm/postgresql"
 
 export const fileSystem = new FileSystem(
  join(__dirname, "../../integration-tests-migrations-many-to-one")
@@ -31,11 +37,15 @@ describe("manyToOne - belongTo", () => {
  user: model.belongsTo(() => user, { mappedBy: "teams" }),
  })
 
- const user = model.define("user", {
- id: model.id().primaryKey(),
- username: model.text(),
- teams: model.hasMany(() => team, { mappedBy: "user" }),
- })
+ const user = model
+ .define("user", {
+ id: model.id().primaryKey(),
+ username: model.text(),
+ teams: model.hasMany(() => team, { mappedBy: "user" }),
+ })
+ .cascades({
+ delete: ["teams"],
+ })
 
  ;[User, Team] = toMikroOrmEntities([user, team])
 
@@ -148,4 +158,115 @@ describe("manyToOne - belongTo", () => {
  ],
  })
  })
+
+ it(`should handle soft delete cascade`, async () => {
+ let manager = orm.em.fork()
+
+ const user1 = manager.create(User, {
+ username: "User 1",
+ })
+
+ await manager.persistAndFlush([user1])
+ manager = orm.em.fork()
+
+ const team1 = manager.create(Team, {
+ name: "Team 1",
+ user_id: user1.id,
+ })
+ const team2 = manager.create(Team, {
+ name: "Team 2",
+ user_id: user1.id,
+ })
+
+ await manager.persistAndFlush([team1, team2])
+ manager = orm.em.fork()
+
+ let teams = await manager.find(
+ Team,
+ {},
+ {
+ populate: ["user"],
+ }
+ )
+
+ const serializedTeams = await mikroOrmSerializer<InstanceType<typeof Team>>(
+ teams
+ )
+ expect(serializedTeams).toHaveLength(2)
+ expect(serializedTeams).toEqual(
+ expect.arrayContaining([
+ {
+ id: team1.id,
+ name: "Team 1",
+ created_at: expect.any(Date),
+ updated_at: expect.any(Date),
+ deleted_at: null,
+ user_id: user1.id,
+ user: {
+ id: user1.id,
+ username: "User 1",
+ created_at: expect.any(Date),
+ updated_at: expect.any(Date),
+ deleted_at: null,
+ },
+ },
+ {
+ id: team2.id,
+ name: "Team 2",
+ created_at: expect.any(Date),
+ updated_at: expect.any(Date),
+ deleted_at: null,
+ user_id: user1.id,
+ user: {
+ id: user1.id,
+ username: "User 1",
+ created_at: expect.any(Date),
+ updated_at: expect.any(Date),
+ deleted_at: null,
+ },
+ },
+ ])
+ )
+
+ manager = orm.em.fork()
+ const userToDelete = await manager.findOne(User, {
+ id: user1.id,
+ })
+ await mikroOrmUpdateDeletedAtRecursively(
+ manager as SqlEntityManager,
+ [userToDelete],
+ new Date()
+ )
+
+ teams = await manager.find(
+ Team,
+ {},
+ {
+ populate: ["user"],
+ filters: {
+ [SoftDeletableFilterKey]: {
+ withDeleted: true,
+ },
+ },
+ }
+ )
+
+ expect(teams).toHaveLength(2)
+ expect(teams).toEqual(
+ expect.arrayContaining([
+ expect.objectContaining({
+ deleted_at: expect.any(Date),
+ user: expect.objectContaining({
+ deleted_at: expect.any(Date),
+ }),
+ }),
+ expect.objectContaining({
+ deleted_at: expect.any(Date),
+ user: expect.objectContaining({
+ deleted_at: expect.any(Date),
+ }),
+ }),
+ ])
+ )
+ })
 })