chore(medusa,orchestration,link-modules,modules-sdk): internal services as modules (#4925)

packages/medusa/src/joiner-config.ts

@@ -0,0 +1,77 @@
+import { Modules } from "@medusajs/modules-sdk"
+import { ModuleJoinerConfig } from "@medusajs/types"
+
+export const joinerConfig: ModuleJoinerConfig[] = [
+  {
+    serviceName: "cartService",
+    primaryKeys: ["id"],
+    linkableKeys: ["cart_id"],
+    alias: [
+      {
+        name: "cart",
+      },
+    ],
+    relationships: [
+      {
+        serviceName: Modules.PRODUCT,
+        primaryKey: "id",
+        foreignKey: "variant_id",
+        alias: "variant",
+        args: {
+          methodSuffix: "Variants",
+        },
+      },
+      {
+        serviceName: "regionService",
+        primaryKey: "id",
+        foreignKey: "region_id",
+        alias: "region",
+      },
+      {
+        serviceName: "customerService",
+        primaryKey: "id",
+        foreignKey: "customer_id",
+        alias: "customer",
+      },
+    ],
+  },
+  {
+    serviceName: "shippingProfileService",
+    primaryKeys: ["id"],
+    linkableKeys: ["profile_id"],
+    alias: [
+      {
+        name: "shipping_profile",
+      },
+      {
+        name: "shipping_profiles",
+      },
+    ],
+  },
+  {
+    serviceName: "regionService",
+    primaryKeys: ["id"],
+    linkableKeys: ["region_id"],
+    alias: [
+      {
+        name: "region",
+      },
+      {
+        name: "regions",
+      },
+    ],
+  },
+  {
+    serviceName: "customerService",
+    primaryKeys: ["id"],
+    linkableKeys: ["customer_id"],
+    alias: [
+      {
+        name: "customer",
+      },
+      {
+        name: "customers",
+      },
+    ],
+  },
+]

packages/medusa/src/loaders/feature-flags/isolate-product-domain.ts

@@ -0,0 +1,10 @@
+import { FlagSettings } from "../../types/feature-flags"
+
+const IsolateProductDomainFeatureFlag: FlagSettings = {
+  key: "isolate_product_domain",
+  default_val: false,
+  env_key: "MEDUSA_FF_ISOLATE_PRODUCT_DOMAIN",
+  description: "[WIP] Isolate product domain dependencies from the core",
+}
+
+export default IsolateProductDomainFeatureFlag

packages/medusa/src/loaders/index.ts

@@ -1,20 +1,28 @@
+import { MedusaApp, moduleLoader, registerModules } from "@medusajs/modules-sdk"
+import { ContainerRegistrationKeys } from "@medusajs/utils"
 import { asValue } from "awilix"
 import { Express, NextFunction, Request, Response } from "express"
+import { createMedusaContainer } from "medusa-core-utils"
 import { track } from "medusa-telemetry"
 import { EOL } from "os"
 import "reflect-metadata"
 import requestIp from "request-ip"
 import { Connection } from "typeorm"
+import { joinerConfig } from "../joiner-config"
+import modulesConfig from "../modules-config"
 import { MedusaContainer } from "../types/global"
+import { remoteQueryFetchData } from "../utils"
 import apiLoader from "./api"
 import loadConfig from "./config"
 import databaseLoader, { dataSource } from "./database"
 import defaultsLoader from "./defaults"
 import expressLoader from "./express"
 import featureFlagsLoader from "./feature-flags"
+import IsolateProductDomainFeatureFlag from "./feature-flags/isolate-product-domain"
 import Logger from "./logger"
 import modelsLoader from "./models"
 import passportLoader from "./passport"
+import pgConnectionLoader from "./pg-connection"
 import pluginsLoader, { registerPluginModels } from "./plugins"
 import redisLoader from "./redis"
 import repositoriesLoader from "./repositories"
@@ -23,11 +31,6 @@ import servicesLoader from "./services"
 import strategiesLoader from "./strategies"
 import subscribersLoader from "./subscribers"
 
-import { moduleLoader, registerModules } from "@medusajs/modules-sdk"
-import { createMedusaContainer } from "medusa-core-utils"
-import pgConnectionLoader from "./pg-connection"
-import { ContainerRegistrationKeys } from "@medusajs/utils"
-
 type Options = {
   directory: string
   expressApp: Express
@@ -182,5 +185,20 @@ export default async ({
     Logger.success(searchActivity, "Indexing event emitted") || {}
   track("SEARCH_ENGINE_INDEXING_COMPLETED", { duration: searchAct.duration })
 
+  if (featureFlagRouter.isFeatureEnabled(IsolateProductDomainFeatureFlag.key)) {
+    const { query } = await MedusaApp({
+      modulesConfig,
+      servicesConfig: joinerConfig,
+      remoteFetchData: remoteQueryFetchData(container),
+      injectedDependencies: {
+        [ContainerRegistrationKeys.PG_CONNECTION]: container.resolve(
+          ContainerRegistrationKeys.PG_CONNECTION
+        ),
+      },
+    })
+
+    container.register("remoteQuery", asValue(query))
+  }
+
   return { container, dbConnection, app: expressApp }
 }

packages/medusa/src/modules-config.ts

@@ -0,0 +1,9 @@
+import { MedusaModuleConfig, Modules } from "@medusajs/modules-sdk"
+
+const modules: MedusaModuleConfig = [
+  {
+    module: Modules.PRODUCT,
+  },
+]
+
+export default modules

packages/medusa/src/utils/index.ts

@@ -11,8 +11,9 @@ export * from "./is-object"
 export * from "./is-string"
 export * from "./omit-deep"
 export * from "./product-category"
+export * from "./remote-query-fetch-data"
 export * from "./remove-undefined-properties"
 export * from "./set-metadata"
 export * from "./validate-id"
-export * from "./validators/is-type"
 export { registerOverriddenValidators, validator } from "./validator"
+export * from "./validators/is-type"

packages/medusa/src/utils/remote-query-fetch-data.ts

@@ -0,0 +1,53 @@
+import { MedusaModule, RemoteQuery } from "@medusajs/modules-sdk"
+import { MedusaContainer } from "@medusajs/types"
+
+export function remoteQueryFetchData(container: MedusaContainer) {
+  return async (expand, keyField, ids, relationship) => {
+    const serviceConfig = expand.serviceConfig
+    const service = container.resolve(serviceConfig.serviceName, {
+      allowUnregistered: true,
+    })
+
+    if (MedusaModule.isInstalled(serviceConfig.serviceName)) {
+      return
+    }
+
+    const filters = {}
+    const options = {
+      ...RemoteQuery.getAllFieldsAndRelations(expand),
+    }
+
+    if (ids) {
+      filters[keyField] = ids
+    }
+
+    const hasPagination = Object.keys(options).some((key) =>
+      ["skip"].includes(key)
+    )
+
+    let methodName = hasPagination ? "listAndCount" : "list"
+
+    if (relationship?.args?.methodSuffix) {
+      methodName += relationship.args.methodSuffix
+    } else if (serviceConfig?.args?.methodSuffix) {
+      methodName += serviceConfig.args.methodSuffix
+    }
+
+    const result = await service[methodName](filters, options)
+
+    if (hasPagination) {
+      const [data, count] = result
+      return {
+        data: {
+          rows: data,
+          metadata: {},
+        },
+        path: "rows",
+      }
+    }
+
+    return {
+      data: result,
+    } as any
+  }
+}