feat(link-modules,modules-sdk, utils, types, products) - Remote Link and Link modules (#4695)

What:
- Definition of all Modules links
- `link-modules` package to manage the creation of all pre-defined link or custom ones

```typescript
import { initialize as iniInventory } from "@medusajs/inventory";
import { initialize as iniProduct } from "@medusajs/product";

import {
  initialize as iniLinks,
  runMigrations as migrateLinks
} from "@medusajs/link-modules";

await Promise.all([iniInventory(), iniProduct()]);


await migrateLinks(); // create tables based on previous loaded modules

await iniLinks(); // load link based on previous loaded modules

await iniLinks(undefined, [
  {
    serviceName: "product_custom_translation_service_link",
    isLink: true,
    databaseConfig: {
      tableName: "product_transalations",
    },
    alias: [
      {
        name: "translations",
      },
    ],
    primaryKeys: ["id", "product_id", "translation_id"],
    relationships: [
      {
        serviceName: Modules.PRODUCT,
        primaryKey: "id",
        foreignKey: "product_id",
        alias: "product",
      },
      {
        serviceName: "custom_translation_service",
        primaryKey: "id",
        foreignKey: "translation_id",
        alias: "transalation",
        deleteCascade: true,
      },
    ],
    extends: [
      {
        serviceName: Modules.PRODUCT,
        relationship: {
          serviceName: "product_custom_translation_service_link",
          primaryKey: "product_id",
          foreignKey: "id",
          alias: "translations",
          isList: true,
        },
      },
      {
        serviceName: "custom_translation_service",
        relationship: {
          serviceName: "product_custom_translation_service_link",
          primaryKey: "product_id",
          foreignKey: "id",
          alias: "product_link",
        },
      },
    ],
  },
]); // custom links
```

Remote Link

```typescript
import { RemoteLink, Modules } from "@medusajs/modules-sdk";

// [...] initialize modules and links

const remoteLink = new RemoteLink();

// upsert the relationship
await remoteLink.create({ // one (object) or many (array)
  [Modules.PRODUCT]: {
    variant_id: "var_abc",
  },
  [Modules.INVENTORY]: {
    inventory_item_id: "iitem_abc",
  },
  data: { // optional additional fields
    required_quantity: 5
  }
});

// dismiss (doesn't cascade)
await remoteLink.dismiss({ // one (object) or many (array)
  [Modules.PRODUCT]: {
    variant_id: "var_abc",
  },
  [Modules.INVENTORY]: {
    inventory_item_id: "iitem_abc",
  },
});

// delete
await remoteLink.delete({
  // every key is a module
  [Modules.PRODUCT]: {
    // every key is a linkable field
    variant_id: "var_abc", // single or multiple values
  },
});

// restore
await remoteLink.restore({
  // every key is a module
  [Modules.PRODUCT]: {
    // every key is a linkable field
    variant_id: "var_abc", // single or multiple values
  },
});

```

Co-authored-by: Riqwan Thamir <5105988+riqwan@users.noreply.github.com>

packages/link-modules/src/loaders/connection.ts

@@ -0,0 +1,31 @@
+import {
+  InternalModuleDeclaration,
+  LoaderOptions,
+  ModuleServiceInitializeCustomDataLayerOptions,
+  ModuleServiceInitializeOptions,
+} from "@medusajs/modules-sdk"
+import { ModulesSdkUtils } from "@medusajs/utils"
+
+import { EntitySchema } from "@mikro-orm/core"
+
+export function connectionLoader(entity: EntitySchema) {
+  return async (
+    {
+      options,
+      container,
+      logger,
+    }: LoaderOptions<
+      | ModuleServiceInitializeOptions
+      | ModuleServiceInitializeCustomDataLayerOptions
+    >,
+    moduleDeclaration?: InternalModuleDeclaration
+  ): Promise<void> => {
+    await ModulesSdkUtils.mikroOrmConnectionLoader({
+      entities: [entity],
+      container,
+      options,
+      moduleDeclaration,
+      logger,
+    })
+  }
+}

packages/link-modules/src/loaders/container.ts

@@ -0,0 +1,40 @@
+import { BaseRepository, getLinkRepository } from "@repositories"
+import { LinkService, getModuleService } from "@services"
+
+import { LoaderOptions } from "@medusajs/modules-sdk"
+import {
+  InternalModuleDeclaration,
+  ModuleJoinerConfig,
+  ModulesSdkTypes,
+} from "@medusajs/types"
+import { asClass, asValue } from "awilix"
+
+export function containerLoader(entity, joinerConfig: ModuleJoinerConfig) {
+  return async (
+    {
+      options,
+      container,
+    }: LoaderOptions<
+      | ModulesSdkTypes.ModuleServiceInitializeOptions
+      | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
+    >,
+    moduleDeclaration?: InternalModuleDeclaration
+  ): Promise<void> => {
+    const [primary, foreign] = joinerConfig.relationships!
+
+    container.register({
+      joinerConfig: asValue(joinerConfig),
+      primaryKey: asValue(primary.foreignKey.split(",")),
+      foreignKey: asValue(foreign.foreignKey),
+      extraFields: asValue(
+        Object.keys(joinerConfig.databaseConfig?.extraFields || {})
+      ),
+
+      linkModuleService: asClass(getModuleService(joinerConfig)).singleton(),
+      linkService: asClass(LinkService).singleton(),
+
+      baseRepository: asClass(BaseRepository).singleton(),
+      linkRepository: asClass(getLinkRepository(entity)).singleton(),
+    })
+  }
+}

packages/link-modules/src/loaders/index.ts

@@ -0,0 +1,26 @@
+import {
+  JoinerRelationship,
+  ModuleJoinerConfig,
+  ModuleLoaderFunction,
+} from "@medusajs/types"
+
+import { generateEntity } from "../utils"
+import { connectionLoader } from "./connection"
+import { containerLoader } from "./container"
+
+export function getLoaders({
+  joinerConfig,
+  primary,
+  foreign,
+}: {
+  joinerConfig: ModuleJoinerConfig
+  primary: JoinerRelationship
+  foreign: JoinerRelationship
+}): ModuleLoaderFunction[] {
+  if (joinerConfig.isReadOnlyLink) {
+    return []
+  }
+
+  const entity = generateEntity(joinerConfig, primary, foreign)
+  return [connectionLoader(entity), containerLoader(entity, joinerConfig)]
+}