feat(prduct, utils, types): Create soft delete pattern for link module (#4649)

* feat(prouct, utils, types): Create soft delete pattern for link module

* add comment

* add comment

* finalise

* remove linkable keys

* cleanup and tests

* cleanup

* add some comments and renaming

* re work

* fix tests

---------

Co-authored-by: Riqwan Thamir <rmthamir@gmail.com>

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

@@ -2,10 +2,10 @@ import { Context, DAL, RepositoryTransformOptions } from "@medusajs/types"
 import { MedusaContext } from "../../decorators"
 import { buildQuery, InjectTransactionManager } from "../../modules-sdk"
 import {
-  mikroOrmSerializer,
-  mikroOrmUpdateDeletedAtRecursively,
+  getSoftDeletedCascadedEntitiesIdsMappedBy,
   transactionWrapper,
 } from "../utils"
+import { mikroOrmSerializer, mikroOrmUpdateDeletedAtRecursively } from "./utils"
 
 class MikroOrmBase<T = any> {
   protected readonly manager_: any
@@ -71,13 +71,17 @@ export abstract class MikroOrmAbstractBaseRepository<T = any>
     ids: string[],
     @MedusaContext()
     { transactionManager: manager }: Context = {}
-  ): Promise<T[]> {
+  ): Promise<[T[], Record<string, unknown[]>]> {
     const entities = await this.find({ where: { id: { $in: ids } } as any })
     const date = new Date()
 
     await mikroOrmUpdateDeletedAtRecursively(manager, entities, date)
 
-    return entities
+    const softDeletedEntitiesMap = getSoftDeletedCascadedEntitiesIdsMappedBy({
+      entities,
+    })
+
+    return [entities, softDeletedEntitiesMap]
   }
 
   @InjectTransactionManager()

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

@@ -0,0 +1,54 @@
+import { SoftDeletableFilterKey } from "./mikro-orm-soft-deletable-filter"
+
+export const mikroOrmUpdateDeletedAtRecursively = async <
+  T extends object = any
+>(
+  manager: any,
+  entities: (T & { id: string; deleted_at?: string | Date | null })[],
+  value: Date | null
+) => {
+  for (const entity of entities) {
+    if (!("deleted_at" in entity)) continue
+
+    entity.deleted_at = value
+
+    const relations = manager
+      .getDriver()
+      .getMetadata()
+      .get(entity.constructor.name).relations
+
+    const relationsToCascade = relations.filter((relation) =>
+      relation.cascade.includes("soft-remove" as any)
+    )
+
+    for (const relation of relationsToCascade) {
+      let collectionRelation = entity[relation.name]
+
+      if (!collectionRelation.isInitialized()) {
+        await collectionRelation.init()
+      }
+
+      const relationEntities = await collectionRelation.getItems({
+        filters: {
+          [SoftDeletableFilterKey]: {
+            withDeleted: true,
+          },
+        },
+      })
+
+      await mikroOrmUpdateDeletedAtRecursively(manager, relationEntities, value)
+    }
+
+    await manager.persist(entity)
+  }
+}
+
+export const mikroOrmSerializer = async <TOutput extends object>(
+  data: any,
+  options?: any
+): Promise<TOutput> => {
+  options ??= {}
+  const { serialize } = await import("@mikro-orm/core")
+  const result = serialize(data, options)
+  return result as unknown as Promise<TOutput>
+}