Feat(medusa,modules-sdk): Modules SDK package (#3294)

packages/modules-sdk/src/definitions.ts

@@ -0,0 +1,30 @@
+import { ModuleDefinition, MODULE_RESOURCE_TYPE, MODULE_SCOPE } from "./types"
+
+export const MODULE_DEFINITIONS: ModuleDefinition[] = [
+  {
+    key: "stockLocationService",
+    registrationName: "stockLocationService",
+    defaultPackage: false,
+    label: "StockLocationService",
+    isRequired: false,
+    canOverride: true,
+    defaultModuleDeclaration: {
+      scope: MODULE_SCOPE.INTERNAL,
+      resources: MODULE_RESOURCE_TYPE.SHARED,
+    },
+  },
+  {
+    key: "inventoryService",
+    registrationName: "inventoryService",
+    defaultPackage: false,
+    label: "InventoryService",
+    isRequired: false,
+    canOverride: true,
+    defaultModuleDeclaration: {
+      scope: MODULE_SCOPE.INTERNAL,
+      resources: MODULE_RESOURCE_TYPE.SHARED,
+    },
+  },
+]
+
+export default MODULE_DEFINITIONS

packages/modules-sdk/src/index.ts

@@ -0,0 +1,6 @@
+export * from "./types"
+export * from "./loaders"
+
+export * from "./module-helper"
+
+export * from "./definitions"

packages/modules-sdk/src/loaders/__mocks__/@modules/brokenloader.ts

@@ -0,0 +1,13 @@
+const loader = ({}) => {
+  throw new Error("loader")
+}
+
+const service = class TestService {}
+const migrations = []
+const loaders = [loader]
+
+export default {
+  service,
+  migrations,
+  loaders,
+}

packages/modules-sdk/src/loaders/__mocks__/@modules/default.ts

@@ -0,0 +1,11 @@
+const service = class TestService {}
+const migrations = []
+const loaders = []
+const models = []
+
+export default {
+  service,
+  migrations,
+  loaders,
+  models,
+}

packages/modules-sdk/src/loaders/__mocks__/@modules/no-service.ts

@@ -0,0 +1,7 @@
+const migrations = []
+const loaders = []
+
+export default {
+  migrations,
+  loaders,
+}

packages/modules-sdk/src/loaders/__mocks__/medusa-telemetry.ts

@@ -0,0 +1,2 @@
+export const trackInstallation = jest.fn()
+export const trackFeatureFlag = jest.fn()

packages/modules-sdk/src/loaders/__tests__/module-definitions.ts

@@ -0,0 +1,202 @@
+import {
+  ConfigModule,
+  ModuleDefinition,
+  MODULE_RESOURCE_TYPE,
+  MODULE_SCOPE,
+} from "../../types"
+import { registerModules } from "../module-definition"
+import MODULE_DEFINITIONS from "../../definitions"
+
+const RESOLVED_PACKAGE = "@medusajs/test-service-resolved"
+jest.mock("resolve-cwd", () => jest.fn(() => RESOLVED_PACKAGE))
+
+describe("module definitions loader", () => {
+  const defaultDefinition: ModuleDefinition = {
+    key: "testService",
+    registrationName: "testService",
+    defaultPackage: "@medusajs/test-service",
+    label: "TestService",
+    isRequired: false,
+    canOverride: true,
+    defaultModuleDeclaration: {
+      scope: MODULE_SCOPE.INTERNAL,
+      resources: MODULE_RESOURCE_TYPE.SHARED,
+    },
+  }
+
+  beforeEach(() => {
+    jest.resetModules()
+    jest.clearAllMocks()
+
+    // Clear module definitions
+    MODULE_DEFINITIONS.splice(0, MODULE_DEFINITIONS.length)
+  })
+
+  it("Resolves module with default definition given empty config", () => {
+    MODULE_DEFINITIONS.push({ ...defaultDefinition })
+
+    const res = registerModules({ modules: {} } as ConfigModule)
+
+    expect(res[defaultDefinition.key]).toEqual({
+      resolutionPath: defaultDefinition.defaultPackage,
+      definition: defaultDefinition,
+      options: {},
+      moduleDeclaration: {
+        scope: "internal",
+        resources: "shared",
+      },
+    })
+  })
+
+  describe("boolean config", () => {
+    it("Resolves module with no resolution path when given false", () => {
+      MODULE_DEFINITIONS.push({ ...defaultDefinition })
+
+      const res = registerModules({
+        modules: { [defaultDefinition.key]: false },
+      } as ConfigModule)
+
+      expect(res[defaultDefinition.key]).toEqual({
+        resolutionPath: false,
+        definition: defaultDefinition,
+        options: {},
+      })
+    })
+
+    it("Fails to resolve module with no resolution path when given false for a required module", () => {
+      expect.assertions(1)
+      MODULE_DEFINITIONS.push({ ...defaultDefinition, isRequired: true })
+
+      try {
+        registerModules({
+          modules: { [defaultDefinition.key]: false },
+        } as ConfigModule)
+      } catch (err) {
+        expect(err.message).toEqual(
+          `Module: ${defaultDefinition.label} is required`
+        )
+      }
+    })
+
+    it("Resolves module with no resolution path when not given custom resolution path as false as default package", () => {
+      const definition = {
+        ...defaultDefinition,
+        defaultPackage: false as false,
+      }
+
+      MODULE_DEFINITIONS.push(definition)
+
+      const res = registerModules({
+        modules: {},
+      } as ConfigModule)
+
+      expect(res[defaultDefinition.key]).toEqual({
+        resolutionPath: false,
+        definition: definition,
+        options: {},
+        moduleDeclaration: {
+          scope: "internal",
+          resources: "shared",
+        },
+      })
+    })
+  })
+
+  describe("string config", () => {
+    it("Resolves module with default definition given empty config", () => {
+      MODULE_DEFINITIONS.push({ ...defaultDefinition })
+
+      const res = registerModules({
+        modules: {
+          [defaultDefinition.key]: defaultDefinition.defaultPackage,
+        },
+      } as ConfigModule)
+
+      expect(res[defaultDefinition.key]).toEqual({
+        resolutionPath: RESOLVED_PACKAGE,
+        definition: defaultDefinition,
+        options: {},
+        moduleDeclaration: {
+          scope: "internal",
+          resources: "shared",
+        },
+      })
+    })
+  })
+
+  describe("object config", () => {
+    it("Resolves resolution path and provides empty options when none are provided", () => {
+      MODULE_DEFINITIONS.push({ ...defaultDefinition })
+
+      const res = registerModules({
+        modules: {
+          [defaultDefinition.key]: {
+            resolve: defaultDefinition.defaultPackage,
+            resources: MODULE_RESOURCE_TYPE.ISOLATED,
+          },
+        },
+      } as ConfigModule)
+
+      expect(res[defaultDefinition.key]).toEqual({
+        resolutionPath: RESOLVED_PACKAGE,
+        definition: defaultDefinition,
+        options: {},
+        moduleDeclaration: {
+          scope: "internal",
+          resources: "isolated",
+          resolve: defaultDefinition.defaultPackage,
+        },
+      })
+    })
+
+    it("Resolves default resolution path and provides options when only options are provided", () => {
+      MODULE_DEFINITIONS.push({ ...defaultDefinition })
+
+      const res = registerModules({
+        modules: {
+          [defaultDefinition.key]: {
+            options: { test: 123 },
+          },
+        },
+      } as unknown as ConfigModule)
+
+      expect(res[defaultDefinition.key]).toEqual({
+        resolutionPath: defaultDefinition.defaultPackage,
+        definition: defaultDefinition,
+        options: { test: 123 },
+        moduleDeclaration: {
+          scope: "internal",
+          resources: "shared",
+          options: { test: 123 },
+        },
+      })
+    })
+
+    it("Resolves resolution path and provides options when only options are provided", () => {
+      MODULE_DEFINITIONS.push({ ...defaultDefinition })
+
+      const res = registerModules({
+        modules: {
+          [defaultDefinition.key]: {
+            resolve: defaultDefinition.defaultPackage,
+            options: { test: 123 },
+            scope: "internal",
+            resources: "isolated",
+          },
+        },
+      } as unknown as ConfigModule)
+
+      expect(res[defaultDefinition.key]).toEqual({
+        resolutionPath: RESOLVED_PACKAGE,
+        definition: defaultDefinition,
+        options: { test: 123 },
+        moduleDeclaration: {
+          scope: "internal",
+          resources: "isolated",
+          resolve: defaultDefinition.defaultPackage,
+          options: { test: 123 },
+        },
+      })
+    })
+  })
+})

packages/modules-sdk/src/loaders/__tests__/module-loader.ts

@@ -0,0 +1,325 @@
+import {
+  asFunction,
+  asValue,
+  AwilixContainer,
+  ClassOrFunctionReturning,
+  createContainer,
+  Resolver,
+} from "awilix"
+import {
+  ConfigModule,
+  MedusaContainer,
+  ModuleResolution,
+  MODULE_RESOURCE_TYPE,
+  MODULE_SCOPE,
+} from "../../types"
+
+import { moduleLoader } from "../module-loader"
+import { trackInstallation } from "../__mocks__/medusa-telemetry"
+
+function asArray(
+  resolvers: (ClassOrFunctionReturning<unknown> | Resolver<unknown>)[]
+): { resolve: (container: AwilixContainer) => unknown[] } {
+  return {
+    resolve: (container: AwilixContainer): unknown[] =>
+      resolvers.map((resolver) => container.build(resolver)),
+  }
+}
+
+const logger = {
+  warn: jest.fn(),
+} as any
+
+const buildConfigModule = (
+  configParts: Partial<ConfigModule>
+): ConfigModule => {
+  return {
+    modules: {},
+    moduleResolutions: {},
+    ...configParts,
+  }
+}
+
+const buildContainer = () => {
+  const container = createContainer() as MedusaContainer
+
+  container.registerAdd = function (
+    this: MedusaContainer,
+    name: string,
+    registration: typeof asFunction | typeof asValue
+  ): MedusaContainer {
+    const storeKey = name + "_STORE"
+
+    if (this.registrations[storeKey] === undefined) {
+      this.register(storeKey, asValue([] as Resolver<unknown>[]))
+    }
+    const store = this.resolve(storeKey) as (
+      | ClassOrFunctionReturning<unknown>
+      | Resolver<unknown>
+    )[]
+
+    if (this.registrations[name] === undefined) {
+      this.register(name, asArray(store))
+    }
+    store.unshift(registration)
+
+    return this
+  }.bind(container)
+
+  return container
+}
+describe("modules loader", () => {
+  let container
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  beforeEach(() => {
+    container = buildContainer()
+  })
+
+  it("registers service as undefined in container when no resolution path is given", async () => {
+    const moduleResolutions: Record<string, ModuleResolution> = {
+      testService: {
+        resolutionPath: false,
+        definition: {
+          registrationName: "testService",
+          key: "testService",
+          defaultPackage: "testService",
+          label: "TestService",
+          defaultModuleDeclaration: {
+            scope: MODULE_SCOPE.INTERNAL,
+            resources: MODULE_RESOURCE_TYPE.SHARED,
+          },
+        },
+        moduleDeclaration: {
+          scope: MODULE_SCOPE.INTERNAL,
+          resources: MODULE_RESOURCE_TYPE.SHARED,
+        },
+      },
+    }
+
+    const configModule = buildConfigModule({
+      moduleResolutions,
+    })
+    await moduleLoader({ container, configModule, logger })
+
+    const testService = container.resolve(
+      moduleResolutions.testService.definition.key
+    )
+    expect(testService).toBe(undefined)
+  })
+
+  it("registers service ", async () => {
+    const moduleResolutions: Record<string, ModuleResolution> = {
+      testService: {
+        resolutionPath: "@modules/default",
+        definition: {
+          registrationName: "testService",
+          key: "testService",
+          defaultPackage: "testService",
+          label: "TestService",
+          defaultModuleDeclaration: {
+            scope: MODULE_SCOPE.INTERNAL,
+            resources: MODULE_RESOURCE_TYPE.SHARED,
+          },
+        },
+        moduleDeclaration: {
+          scope: MODULE_SCOPE.INTERNAL,
+          resources: MODULE_RESOURCE_TYPE.SHARED,
+        },
+      },
+    }
+
+    const configModule = buildConfigModule({
+      moduleResolutions,
+    })
+
+    await moduleLoader({ container, configModule, logger })
+
+    const testService = container.resolve(
+      moduleResolutions.testService.definition.key,
+      {}
+    )
+
+    expect(trackInstallation).toHaveBeenCalledWith(
+      {
+        module: moduleResolutions.testService.definition.key,
+        resolution: moduleResolutions.testService.resolutionPath,
+      },
+      "module"
+    )
+    expect(testService).toBeTruthy()
+    expect(typeof testService).toEqual("object")
+  })
+
+  it("runs defined loaders and logs error", async () => {
+    const moduleResolutions: Record<string, ModuleResolution> = {
+      testService: {
+        resolutionPath: "@modules/brokenloader",
+        definition: {
+          registrationName: "testService",
+          key: "testService",
+          defaultPackage: "testService",
+          label: "TestService",
+          defaultModuleDeclaration: {
+            scope: MODULE_SCOPE.INTERNAL,
+            resources: MODULE_RESOURCE_TYPE.SHARED,
+          },
+        },
+        moduleDeclaration: {
+          scope: MODULE_SCOPE.INTERNAL,
+          resources: MODULE_RESOURCE_TYPE.SHARED,
+        },
+      },
+    }
+
+    const configModule = buildConfigModule({
+      moduleResolutions,
+    })
+
+    await moduleLoader({ container, configModule, logger })
+
+    expect(logger.warn).toHaveBeenCalledWith(
+      "Could not resolve module: TestService. Error: Loaders for module TestService failed: loader"
+    )
+  })
+
+  it("logs error if no service is defined", async () => {
+    const moduleResolutions: Record<string, ModuleResolution> = {
+      testService: {
+        resolutionPath: "@modules/no-service",
+        definition: {
+          registrationName: "testService",
+          key: "testService",
+          defaultPackage: "testService",
+          label: "TestService",
+          defaultModuleDeclaration: {
+            scope: MODULE_SCOPE.INTERNAL,
+            resources: MODULE_RESOURCE_TYPE.SHARED,
+          },
+        },
+        moduleDeclaration: {
+          scope: MODULE_SCOPE.INTERNAL,
+          resources: MODULE_RESOURCE_TYPE.SHARED,
+        },
+      },
+    }
+
+    const configModule = buildConfigModule({
+      moduleResolutions,
+    })
+
+    await moduleLoader({ container, configModule, logger })
+
+    expect(logger.warn).toHaveBeenCalledWith(
+      "Could not resolve module: TestService. Error: No service found in module. Make sure that your module exports a service."
+    )
+  })
+
+  it("throws error if no service is defined and module is required", async () => {
+    expect.assertions(1)
+    const moduleResolutions: Record<string, ModuleResolution> = {
+      testService: {
+        resolutionPath: "@modules/no-service",
+        definition: {
+          registrationName: "testService",
+          key: "testService",
+          defaultPackage: "testService",
+          label: "TestService",
+          isRequired: true,
+          defaultModuleDeclaration: {
+            scope: MODULE_SCOPE.INTERNAL,
+            resources: MODULE_RESOURCE_TYPE.SHARED,
+          },
+        },
+        moduleDeclaration: {
+          scope: MODULE_SCOPE.INTERNAL,
+          resources: MODULE_RESOURCE_TYPE.SHARED,
+        },
+      },
+    }
+
+    const configModule = buildConfigModule({
+      moduleResolutions,
+    })
+    try {
+      await moduleLoader({ container, configModule, logger })
+    } catch (err) {
+      expect(err.message).toEqual(
+        "No service found in module. Make sure that your module exports a service."
+      )
+    }
+  })
+
+  it("throws error if no scope is defined to the module", async () => {
+    expect.assertions(1)
+    const moduleResolutions: Record<string, ModuleResolution> = {
+      testService: {
+        resolutionPath: "@modules/no-service",
+        definition: {
+          registrationName: "testService",
+          key: "testService",
+          defaultPackage: "testService",
+          label: "TestService",
+          isRequired: true,
+          defaultModuleDeclaration: {
+            scope: MODULE_SCOPE.INTERNAL,
+            resources: MODULE_RESOURCE_TYPE.SHARED,
+          },
+        },
+        // @ts-ignore
+        moduleDeclaration: {
+          resources: MODULE_RESOURCE_TYPE.SHARED,
+        },
+      },
+    }
+
+    const configModule = buildConfigModule({
+      moduleResolutions,
+    })
+    try {
+      await moduleLoader({ container, configModule, logger })
+    } catch (err) {
+      expect(err.message).toEqual(
+        "The module TestService has to define its scope (internal | external)"
+      )
+    }
+  })
+
+  it("throws error if resources is not set when scope is defined as internal", async () => {
+    expect.assertions(1)
+    const moduleResolutions: Record<string, ModuleResolution> = {
+      testService: {
+        resolutionPath: "@modules/no-service",
+        definition: {
+          registrationName: "testService",
+          key: "testService",
+          defaultPackage: "testService",
+          label: "TestService",
+          isRequired: true,
+          defaultModuleDeclaration: {
+            scope: MODULE_SCOPE.INTERNAL,
+            resources: MODULE_RESOURCE_TYPE.SHARED,
+          },
+        },
+        // @ts-ignore
+        moduleDeclaration: {
+          scope: MODULE_SCOPE.INTERNAL,
+        },
+      },
+    }
+
+    const configModule = buildConfigModule({
+      moduleResolutions,
+    })
+    try {
+      await moduleLoader({ container, configModule, logger })
+    } catch (err) {
+      expect(err.message).toEqual(
+        "The module TestService is missing its resources config"
+      )
+    }
+  })
+})

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

@@ -0,0 +1,3 @@
+export * from "./module-loader"
+
+export * from "./module-definition"

packages/modules-sdk/src/loaders/module-definition.ts

@@ -0,0 +1,61 @@
+import resolveCwd from "resolve-cwd"
+
+import { ConfigModule, ModuleResolution } from "../types"
+import MODULE_DEFINITIONS from "../definitions"
+
+export const registerModules = ({ modules }: ConfigModule) => {
+  const moduleResolutions = {} as Record<string, ModuleResolution>
+  const projectModules = modules ?? {}
+
+  for (const definition of MODULE_DEFINITIONS) {
+    let resolutionPath = definition.defaultPackage
+
+    const moduleConfiguration = projectModules[definition.key]
+
+    if (typeof moduleConfiguration === "boolean") {
+      if (!moduleConfiguration && definition.isRequired) {
+        throw new Error(`Module: ${definition.label} is required`)
+      }
+      if (!moduleConfiguration) {
+        moduleResolutions[definition.key] = {
+          resolutionPath: false,
+          definition,
+          options: {},
+        }
+        continue
+      }
+    }
+
+    // If user added a module and it's overridable, we resolve that instead
+    if (
+      definition.canOverride &&
+      (typeof moduleConfiguration === "string" ||
+        (typeof moduleConfiguration === "object" &&
+          moduleConfiguration.resolve))
+    ) {
+      resolutionPath = resolveCwd(
+        typeof moduleConfiguration === "string"
+          ? moduleConfiguration
+          : (moduleConfiguration.resolve as string)
+      )
+    }
+
+    const moduleDeclaration =
+      typeof moduleConfiguration === "object" ? moduleConfiguration : {}
+
+    moduleResolutions[definition.key] = {
+      resolutionPath,
+      definition,
+      moduleDeclaration: {
+        ...definition.defaultModuleDeclaration,
+        ...moduleDeclaration,
+      },
+      options:
+        typeof moduleConfiguration === "object"
+          ? moduleConfiguration.options ?? {}
+          : {},
+    }
+  }
+
+  return moduleResolutions
+}

packages/modules-sdk/src/loaders/module-loader.ts

@@ -0,0 +1,162 @@
+import { asFunction, asValue } from "awilix"
+import { trackInstallation } from "medusa-telemetry"
+import {
+  ClassConstructor,
+  ConfigModule,
+  LoaderOptions,
+  Logger,
+  MedusaContainer,
+  ModuleExports,
+  ModuleResolution,
+  MODULE_RESOURCE_TYPE,
+  MODULE_SCOPE,
+} from "../types/module"
+
+import { ModulesHelper } from "../module-helper"
+
+export const moduleHelper = new ModulesHelper()
+
+const registerModule = async (
+  container: MedusaContainer,
+  resolution: ModuleResolution,
+  configModule: ConfigModule,
+  logger: Logger
+): Promise<{ error?: Error } | void> => {
+  const constainerName = resolution.definition.registrationName
+
+  const { scope, resources } = resolution.moduleDeclaration ?? {}
+  if (!scope || (scope === MODULE_SCOPE.INTERNAL && !resources)) {
+    let message = `The module ${resolution.definition.label} has to define its scope (internal | external)`
+    if (scope && !resources) {
+      message = `The module ${resolution.definition.label} is missing its resources config`
+    }
+
+    container.register({
+      [constainerName]: asValue(undefined),
+    })
+
+    return {
+      error: new Error(message),
+    }
+  }
+
+  if (!resolution.resolutionPath) {
+    container.register({
+      [constainerName]: asValue(undefined),
+    })
+
+    return
+  }
+
+  let loadedModule: ModuleExports
+  try {
+    loadedModule = (await import(resolution.resolutionPath!)).default
+  } catch (error) {
+    return { error }
+  }
+
+  const moduleService = loadedModule?.service || null
+
+  if (!moduleService) {
+    return {
+      error: new Error(
+        "No service found in module. Make sure that your module exports a service."
+      ),
+    }
+  }
+
+  if (
+    scope === MODULE_SCOPE.INTERNAL &&
+    resources === MODULE_RESOURCE_TYPE.SHARED
+  ) {
+    const moduleModels = loadedModule?.models || null
+    if (moduleModels) {
+      moduleModels.map((val: ClassConstructor<unknown>) => {
+        container.registerAdd("db_entities", asValue(val))
+      })
+    }
+  }
+
+  // TODO: "cradle" should only contain dependent Modules and the EntityManager if module scope is shared
+  container.register({
+    [constainerName]: asFunction((cradle) => {
+      return new moduleService(
+        cradle,
+        resolution.options,
+        resolution.moduleDeclaration
+      )
+    }).singleton(),
+  })
+
+  const moduleLoaders = loadedModule?.loaders || []
+  try {
+    for (const loader of moduleLoaders) {
+      await loader(
+        {
+          container,
+          configModule,
+          logger,
+          options: resolution.options,
+        },
+        resolution.moduleDeclaration
+      )
+    }
+  } catch (err) {
+    return {
+      error: new Error(
+        `Loaders for module ${resolution.definition.label} failed: ${err.message}`
+      ),
+    }
+  }
+
+  trackInstallation(
+    {
+      module: resolution.definition.key,
+      resolution: resolution.resolutionPath,
+    },
+    "module"
+  )
+}
+
+export const moduleLoader = async ({
+  container,
+  configModule,
+  logger,
+}: LoaderOptions): Promise<void> => {
+  const moduleResolutions = configModule?.moduleResolutions ?? {}
+
+  for (const resolution of Object.values(moduleResolutions)) {
+    const registrationResult = await registerModule(
+      container,
+      resolution,
+      configModule,
+      logger!
+    )
+    if (registrationResult?.error) {
+      const { error } = registrationResult
+      if (resolution.definition.isRequired) {
+        logger?.warn(
+          `Could not resolve required module: ${resolution.definition.label}. Error: ${error.message}`
+        )
+        throw error
+      }
+
+      logger?.warn(
+        `Could not resolve module: ${resolution.definition.label}. Error: ${error.message}`
+      )
+    }
+  }
+
+  moduleHelper.setModules(
+    Object.entries(moduleResolutions).reduce((acc, [k, v]) => {
+      if (v.resolutionPath) {
+        acc[k] = v
+      }
+      return acc
+    }, {})
+  )
+
+  container.register({
+    modulesHelper: asValue(moduleHelper),
+  })
+}

packages/modules-sdk/src/module-helper.ts

@@ -0,0 +1,16 @@
+import { ModuleResolution, ModulesResponse } from "./types/module"
+
+export class ModulesHelper {
+  private modules_: Record<string, ModuleResolution> = {}
+
+  setModules(modules: Record<string, ModuleResolution>) {
+    this.modules_ = modules
+  }
+
+  get modules(): ModulesResponse {
+    return Object.values(this.modules_ || {}).map((value) => ({
+      module: value.definition.key,
+      resolution: value.resolutionPath,
+    }))
+  }
+}

packages/modules-sdk/src/types/index.ts

@@ -0,0 +1 @@
+export * from "./module"

packages/modules-sdk/src/types/module.ts

@@ -0,0 +1,103 @@
+import { AwilixContainer } from "awilix"
+import { Logger as _Logger } from "winston"
+
+export type LogLevel =
+  | "query"
+  | "schema"
+  | "error"
+  | "warn"
+  | "info"
+  | "log"
+  | "migration"
+export type LoggerOptions = boolean | "all" | LogLevel[]
+
+export type ClassConstructor<T> = {
+  new (...args: unknown[]): T
+}
+
+export type MedusaContainer = AwilixContainer & {
+  registerAdd: <T>(name: string, registration: T) => MedusaContainer
+}
+
+export type Logger = _Logger & {
+  progress: (activityId: string, msg: string) => void
+  info: (msg: string) => void
+  warn: (msg: string) => void
+}
+
+export enum MODULE_SCOPE {
+  INTERNAL = "internal",
+  EXTERNAL = "external",
+}
+
+export enum MODULE_RESOURCE_TYPE {
+  SHARED = "shared",
+  ISOLATED = "isolated",
+}
+
+export type ConfigurableModuleDeclaration = {
+  scope: MODULE_SCOPE.INTERNAL
+  resources: MODULE_RESOURCE_TYPE
+  resolve?: string
+  options?: Record<string, unknown>
+}
+/*
+| {
+    scope: MODULE_SCOPE.external
+    server: {
+      type: "built-in" | "rest" | "tsrpc" | "grpc" | "gql"
+      url: string
+      options?: Record<string, unknown>
+    }
+  }
+*/
+
+export type ModuleResolution = {
+  resolutionPath: string | false
+  definition: ModuleDefinition
+  options?: Record<string, unknown>
+  moduleDeclaration?: ConfigurableModuleDeclaration
+}
+
+export type ModuleDefinition = {
+  key: string
+  registrationName: string
+  defaultPackage: string | false
+  label: string
+  canOverride?: boolean
+  isRequired?: boolean
+  defaultModuleDeclaration: ConfigurableModuleDeclaration
+}
+
+export type LoaderOptions = {
+  container: MedusaContainer
+  configModule: ConfigModule
+  options?: Record<string, unknown>
+  logger?: Logger
+}
+
+export type Constructor<T> = new (...args: any[]) => T
+
+export type ModuleExports = {
+  loaders: ((
+    options: LoaderOptions,
+    moduleDeclaration?: ConfigurableModuleDeclaration
+  ) => Promise<void>)[]
+  service: Constructor<any>
+  migrations?: any[]
+  models?: Constructor<any>[]
+}
+
+export type ConfigModule = {
+  options?: Record<string, any>
+  modules?: Record<
+    string,
+    false | string | Partial<ConfigurableModuleDeclaration>
+  >
+  moduleResolutions?: Record<string, ModuleResolution>
+}
+
+export type ModulesResponse = {
+  module: string
+  resolution: string | false
+}[]