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/modules-sdk/src/remote-query.ts

@@ -2,28 +2,23 @@ import {
   JoinerRelationship,
   JoinerServiceConfig,
   LoadedModule,
+  ModuleJoinerConfig,
   RemoteExpandProperty,
+  RemoteJoinerQuery,
 } from "@medusajs/types"
 
+import { RemoteFetchDataCallback, RemoteJoiner } from "@medusajs/orchestration"
+import { isString, toPascalCase } from "@medusajs/utils"
 import { MedusaModule } from "./medusa-module"
-import { RemoteJoiner } from "@medusajs/orchestration"
-import { toPascalCase } from "@medusajs/utils"
 
 export class RemoteQuery {
   private remoteJoiner: RemoteJoiner
   private modulesMap: Map<string, LoadedModule> = new Map()
+  private customRemoteFetchData?: RemoteFetchDataCallback
 
   constructor(
     modulesLoaded?: LoadedModule[],
-    remoteFetchData?: (
-      expand: RemoteExpandProperty,
-      keyField: string,
-      ids?: (unknown | unknown[])[],
-      relationship?: JoinerRelationship
-    ) => Promise<{
-      data: unknown[] | { [path: string]: unknown[] }
-      path?: string
-    }>
+    customRemoteFetchData?: RemoteFetchDataCallback
   ) {
     if (!modulesLoaded?.length) {
       modulesLoaded = MedusaModule.getLoadedModules().map(
@@ -31,25 +26,28 @@ export class RemoteQuery {
       )
     }
 
-    const servicesConfig: JoinerServiceConfig[] = []
+    const servicesConfig: ModuleJoinerConfig[] = []
     for (const mod of modulesLoaded) {
       if (!mod.__definition.isQueryable) {
         continue
       }
 
-      if (this.modulesMap.has(mod.__definition.key)) {
+      const serviceName = mod.__definition.key
+
+      if (this.modulesMap.has(serviceName)) {
         throw new Error(
-          `Duplicated instance of module ${mod.__definition.key} is not allowed.`
+          `Duplicated instance of module ${serviceName} is not allowed.`
         )
       }
 
-      this.modulesMap.set(mod.__definition.key, mod)
+      this.modulesMap.set(serviceName, mod)
       servicesConfig.push(mod.__joinerConfig)
     }
 
+    this.customRemoteFetchData = customRemoteFetchData
     this.remoteJoiner = new RemoteJoiner(
-      servicesConfig,
-      remoteFetchData ?? this.remoteFetchData.bind(this)
+      servicesConfig as JoinerServiceConfig[],
+      this.remoteFetchData.bind(this)
     )
   }
 
@@ -69,14 +67,20 @@ export class RemoteQuery {
 
   private static getAllFieldsAndRelations(
     data: any,
-    prefix = ""
-  ): { select: string[]; relations: string[] } {
+    prefix = "",
+    args: Record<string, unknown[]> = {}
+  ): {
+    select: string[]
+    relations: string[]
+    args: Record<string, unknown[]>
+  } {
     let fields: Set<string> = new Set()
     let relations: string[] = []
 
     data.fields?.forEach((field: string) => {
       fields.add(prefix ? `${prefix}.${field}` : field)
     })
+    args[prefix] = data.args
 
     if (data.expands) {
       for (const property in data.expands) {
@@ -87,7 +91,8 @@ export class RemoteQuery {
 
         const result = RemoteQuery.getAllFieldsAndRelations(
           data.expands[property],
-          newPrefix
+          newPrefix,
+          args
         )
 
         result.select.forEach(fields.add, fields)
@@ -95,7 +100,7 @@ export class RemoteQuery {
       }
     }
 
-    return { select: [...fields], relations }
+    return { select: [...fields], relations, args }
   }
 
   private hasPagination(options: { [attr: string]: unknown }): boolean {
@@ -126,6 +131,13 @@ export class RemoteQuery {
     data: unknown[] | { [path: string]: unknown }
     path?: string
   }> {
+    if (this.customRemoteFetchData) {
+      const resp = await this.customRemoteFetchData(expand, keyField, ids)
+      if (resp !== undefined) {
+        return resp
+      }
+    }
+
     const serviceConfig = expand.serviceConfig
     const service = this.modulesMap.get(serviceConfig.serviceName)!
 
@@ -196,9 +208,14 @@ export class RemoteQuery {
     }
   }
 
-  public async query(query: string, variables: any = {}): Promise<any> {
-    return await this.remoteJoiner.query(
-      RemoteJoiner.parseQuery(query, variables)
-    )
+  public async query(
+    query: string | RemoteJoinerQuery,
+    variables?: Record<string, unknown>
+  ): Promise<any> {
+    const finalQuery = isString(query)
+      ? RemoteJoiner.parseQuery(query, variables)
+      : query
+
+    return await this.remoteJoiner.query(finalQuery)
   }
 }