chore(): Autoload module resources (#7291)

**What**
- automatically build and consume connection and container loader if not exported by the module
- therefore load the services and repositories automatically, including baseRepository
- automatically build run and revert migrations if not provided
- cleaup modules to remove extra unnecessary bits and pieces
- remove the `initializeFactory` in favor of using `medusaApp`

Should drastically improve the module building DX by removing a lot of boilerplate to handle by the user, that plus the base entity should simplify quite a lot the flow cc @shahednasser 

**Note**
I had to choose a way to identify connection and container loader from the exported loader from the module. I decided to go with named function `connectionLoader` and `containerLoader`, also, now the factories will return named function so if the user use the factories we are providing to build those loaders, the function will also be named and identified

integration-tests/modules/__tests__/modules/load-standalone.ts

@@ -1,4 +1,6 @@
 import { medusaIntegrationTestRunner } from "medusa-test-utils"
+import { MedusaApp, Modules } from "@medusajs/modules-sdk"
+import { IProductModuleService } from "@medusajs/types"
 
 jest.setTimeout(30000)
 
@@ -15,10 +17,18 @@ medusaIntegrationTestRunner({
       })
 
       it("Should migrate database and initialize Product module using connection string from environment variable ", async function () {
-        const { initialize, runMigrations } = require("@medusajs/product")
+        const { modules, runMigrations } = await MedusaApp({
+          modulesConfig: {
+            [Modules.PRODUCT]: true,
+          },
+        })
+
         await runMigrations()
 
-        const product = await initialize()
+        const product = modules[
+          Modules.PRODUCT
+        ] as unknown as IProductModuleService
+
         const productList = await product.list()
 
         expect(productList).toEqual(expect.arrayContaining([]))

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

@@ -5,4 +5,3 @@ export * from "./medusa-app"
 export * from "./medusa-module"
 export * from "./remote-link"
 export * from "./remote-query"
-export * from "./utils/initialize-factory"

packages/core/modules-sdk/src/loaders/register-modules.ts

@@ -137,11 +137,9 @@ function getInternalModuleResolution(
   // If user added a module and it's overridable, we resolve that instead
   const isStr = isString(moduleConfig)
   if (isStr || (isObj && moduleConfig.resolve)) {
-    resolutionPath = !moduleExports
-      ? resolveCwd(isStr ? moduleConfig : (moduleConfig.resolve as string))
-      : // Explicitly assign an empty string, later, we will check if the value is exactly false.
-        // This allows to continue the module loading while using the module exports instead of re importing the module itself during the process.
-        ""
+    resolutionPath = resolveCwd(
+      isStr ? moduleConfig : (moduleConfig.resolve as string)
+    )
   }
 
   const moduleDeclaration = isObj ? moduleConfig : {}

packages/core/modules-sdk/src/loaders/utils/load-internal.ts

@@ -1,17 +1,32 @@
 import {
+  Constructor,
   InternalModuleDeclaration,
   Logger,
   MedusaContainer,
   MODULE_RESOURCE_TYPE,
   ModuleExports,
+  ModuleLoaderFunction,
   ModuleResolution,
 } from "@medusajs/types"
 import {
   ContainerRegistrationKeys,
   createMedusaContainer,
   MedusaModuleType,
+  ModulesSdkUtils,
 } from "@medusajs/utils"
 import { asFunction, asValue } from "awilix"
+import { join, resolve } from "path"
+import { statSync } from "fs"
+import { readdir } from "fs/promises"
+
+type ModuleResource = {
+  services: Function[]
+  models: Function[]
+  repositories: Function[]
+  loaders: ModuleLoaderFunction[]
+  moduleService: Constructor<any>
+  normalizedPath: string
+}
 
 export async function loadInternalModule(
   container: MedusaContainer,
@@ -36,6 +51,8 @@ export async function loadInternalModule(
     const modulePath = resolution.resolutionPath as string
 
     if (resolution.moduleExports) {
+      // TODO:
+      // If we want to benefit from the auto load mechanism, even if the module exports is provided, we need to ask for the module path
       loadedModule = resolution.moduleExports
     } else {
       loadedModule = await import(modulePath)
@@ -56,7 +73,17 @@ export async function loadInternalModule(
     return { error }
   }
 
-  if (!loadedModule?.service) {
+  let moduleResources = {} as ModuleResource
+
+  if (resolution.resolutionPath) {
+    moduleResources = await loadResources(
+      loadedModule?.loaders ?? [],
+      resolution,
+      logger
+    )
+  }
+
+  if (!loadedModule?.service && !moduleResources.moduleService) {
     container.register({
       [registrationName]: asValue(undefined),
     })
@@ -69,9 +96,11 @@ export async function loadInternalModule(
   }
 
   if (migrationOnly) {
+    const moduleService_ = moduleResources.moduleService ?? loadedModule.service
+
     // Partially loaded module, only register the service __joinerConfig function to be able to resolve it later
     const moduleService = {
-      __joinerConfig: loadedModule.service.prototype.__joinerConfig,
+      __joinerConfig: moduleService_.prototype.__joinerConfig,
     }
     container.register({
       [registrationName]: asValue(moduleService),
@@ -100,32 +129,21 @@ export async function loadInternalModule(
     )
   }
 
-  const moduleLoaders = loadedModule?.loaders ?? []
-  try {
-    for (const loader of moduleLoaders) {
-      await loader(
-        {
-          container: localContainer,
-          logger,
-          options: resolution.options,
-          dataLoaderOnly: loaderOnly,
-        },
-        resolution.moduleDeclaration as InternalModuleDeclaration
-      )
-    }
-  } catch (err) {
-    container.register({
-      [registrationName]: asValue(undefined),
-    })
+  const loaders = moduleResources.loaders ?? loadedModule?.loaders ?? []
+  const error = await runLoaders(loaders, {
+    container,
+    localContainer,
+    logger,
+    resolution,
+    loaderOnly,
+    registrationName,
+  })
 
-    return {
-      error: new Error(
-        `Loaders for module ${resolution.definition.label} failed: ${err.message}`
-      ),
-    }
+  if (error) {
+    return error
   }
 
-  const moduleService = loadedModule.service
+  const moduleService = moduleResources.moduleService ?? loadedModule.service
 
   container.register({
     [registrationName]: asFunction((cradle) => {
@@ -155,8 +173,229 @@ export async function loadModuleMigrations(
     loadedModule =
       moduleExports ?? (await import(resolution.resolutionPath as string))
 
-    return [loadedModule.runMigrations, loadedModule.revertMigration]
+    let runMigrations = loadedModule.runMigrations
+    let revertMigration = loadedModule.revertMigration
+
+    // Generate migration scripts if they are not present
+    if (!runMigrations || !revertMigration) {
+      const moduleResources = await loadResources(
+        loadedModule?.loaders ?? [],
+        resolution,
+        console as unknown as Logger
+      )
+
+      const migrationScriptOptions = {
+        moduleName: resolution.definition.key,
+        models: moduleResources.models,
+        pathToMigrations: moduleResources.normalizedPath + "/dist/migrations",
+      }
+
+      runMigrations ??= ModulesSdkUtils.buildMigrationScript(
+        migrationScriptOptions
+      )
+
+      revertMigration ??= ModulesSdkUtils.buildRevertMigrationScript(
+        migrationScriptOptions
+      )
+    }
+
+    return [runMigrations, revertMigration]
   } catch {
     return [undefined, undefined]
   }
 }
+
+async function importAllFromDir(path: string) {
+  let filesToLoad: string[] = []
+
+  await readdir(path).then((files) => {
+    files.forEach((file) => {
+      if (file !== "index.js" && file.endsWith(".js")) {
+        const filePath = join(path, file)
+        const stats = statSync(filePath)
+
+        if (stats.isDirectory()) {
+          // TODO: should we handle that? dont think so but I put that here for discussion
+        } else if (stats.isFile()) {
+          filesToLoad.push(filePath)
+        }
+      }
+    })
+
+    return filesToLoad
+  })
+
+  return (
+    await Promise.all(filesToLoad.map((filePath) => import(filePath)))
+  ).flatMap((value) => {
+    return Object.values(value)
+  })
+}
+
+async function loadResources(
+  loadedModuleLoaders: ModuleLoaderFunction[],
+  moduleResolution: ModuleResolution,
+  logger: Logger
+): Promise<ModuleResource> {
+  const modulePath = moduleResolution.resolutionPath as string
+  let normalizedPath = modulePath.replace("dist/", "").replace("index.js", "")
+  normalizedPath = resolve(normalizedPath)
+
+  try {
+    const defaultOnFail = () => {
+      return []
+    }
+
+    const [moduleService, services, models, repositories] = await Promise.all([
+      import(modulePath).then((moduleExports) => moduleExports.default.service),
+      importAllFromDir(resolve(normalizedPath, "dist", "services")).catch(
+        defaultOnFail
+      ),
+      importAllFromDir(resolve(normalizedPath, "dist", "models")).catch(
+        defaultOnFail
+      ),
+      importAllFromDir(resolve(normalizedPath, "dist", "repositories")).catch(
+        defaultOnFail
+      ),
+    ])
+
+    const cleanupResources = (resources) => {
+      return Object.values(resources).filter(
+        (resource): resource is Function => {
+          return typeof resource === "function"
+        }
+      )
+    }
+
+    const potentialServices = [...new Set(cleanupResources(services))]
+    const potentialModels = [...new Set(cleanupResources(models))]
+    const potentialRepositories = [...new Set(cleanupResources(repositories))]
+
+    const finalLoaders = prepareLoaders({
+      loadedModuleLoaders,
+      models: potentialModels,
+      repositories: potentialRepositories,
+      services: potentialServices,
+      moduleResolution,
+      migrationPath: normalizedPath + "/dist/migrations",
+    })
+
+    return {
+      services: potentialServices,
+      models: potentialModels,
+      repositories: potentialRepositories,
+      loaders: finalLoaders,
+      moduleService,
+      normalizedPath
+    }
+  } catch (e) {
+    logger.warn(
+      `Unable to load resources for module ${modulePath} automagically. ${e.message}`
+    )
+
+    return {} as ModuleResource
+  }
+}
+
+async function runLoaders(
+  loaders: Function[] = [],
+  {
+    localContainer,
+    container,
+    logger,
+    resolution,
+    loaderOnly,
+    registrationName,
+  }
+): Promise<void | { error: Error }> {
+  try {
+    for (const loader of loaders) {
+      await loader(
+        {
+          container: localContainer,
+          logger,
+          options: resolution.options,
+          dataLoaderOnly: loaderOnly,
+        },
+        resolution.moduleDeclaration as InternalModuleDeclaration
+      )
+    }
+  } catch (err) {
+    container.register({
+      [registrationName]: asValue(undefined),
+    })
+
+    return {
+      error: new Error(
+        `Loaders for module ${resolution.definition.label} failed: ${err.message}`
+      ),
+    }
+  }
+}
+
+function prepareLoaders({
+  loadedModuleLoaders,
+  models,
+  repositories,
+  services,
+  moduleResolution,
+  migrationPath,
+}) {
+  const finalLoaders: ModuleLoaderFunction[] = []
+
+  const toObjectReducer = (acc, curr) => {
+    acc[curr.name] = curr
+    return acc
+  }
+
+  /*
+   * If no connectionLoader function is provided, create a default connection loader.
+   * TODO: Validate naming convention
+   */
+  const connectionLoaderName = "connectionLoader"
+  const containerLoader = "containerLoader"
+
+  const hasConnectionLoader = loadedModuleLoaders.some(
+    (l) => l.name === connectionLoaderName
+  )
+
+  if (!hasConnectionLoader && models.length > 0) {
+    const connectionLoader = ModulesSdkUtils.mikroOrmConnectionLoaderFactory({
+      moduleName: moduleResolution.definition.key,
+      moduleModels: models,
+      migrationsPath: migrationPath, //normalizedPath + "/dist/migrations",
+    })
+    finalLoaders.push(connectionLoader)
+  }
+
+  const hasContainerLoader = loadedModuleLoaders.some(
+    (l) => l.name === containerLoader
+  )
+
+  if (!hasContainerLoader) {
+    const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
+      moduleModels: models.reduce(toObjectReducer, {}),
+      moduleRepositories: repositories.reduce(toObjectReducer, {}),
+      moduleServices: services.reduce(toObjectReducer, {}),
+    })
+    finalLoaders.push(containerLoader)
+  }
+
+  finalLoaders.push(
+    ...loadedModuleLoaders.filter((loader) => {
+      if (
+        loader.name !== connectionLoaderName &&
+        loader.name !== containerLoader
+      ) {
+        return true
+      }
+
+      return (
+        (loader.name === containerLoader && hasContainerLoader) ||
+        (loader.name === connectionLoaderName && hasConnectionLoader)
+      )
+    })
+  )
+
+  return finalLoaders
+}

packages/core/modules-sdk/src/utils/index.ts

@@ -1,3 +1,2 @@
 export * from "./clean-graphql-schema"
 export * from "./graphql-schema-to-fields"
-export * from "./initialize-factory"

packages/core/modules-sdk/src/utils/initialize-factory.ts

@@ -1,44 +0,0 @@
-import {
-  ExternalModuleDeclaration,
-  InternalModuleDeclaration,
-  ModuleExports,
-  ModuleServiceInitializeCustomDataLayerOptions,
-  ModuleServiceInitializeOptions,
-} from "@medusajs/types"
-import { MODULE_PACKAGE_NAMES } from "../definitions"
-import { MedusaModule } from "../medusa-module"
-
-/**
- * Generate a initialize module factory that is exported by the module to be initialized manually
- *
- * @param moduleName
- * @param moduleDefinition
- */
-export function initializeFactory<T>({
-  moduleName,
-  moduleDefinition,
-}: {
-  moduleName: string
-  moduleDefinition: ModuleExports
-}) {
-  return async (
-    options?:
-      | ModuleServiceInitializeOptions
-      | ModuleServiceInitializeCustomDataLayerOptions
-      | ExternalModuleDeclaration
-      | InternalModuleDeclaration,
-    injectedDependencies?: any
-  ) => {
-    const loaded = await MedusaModule.bootstrap<T>({
-      moduleKey: moduleName,
-      defaultPath: MODULE_PACKAGE_NAMES[moduleName],
-      declaration: options as
-        | InternalModuleDeclaration
-        | ExternalModuleDeclaration,
-      injectedDependencies,
-      moduleExports: moduleDefinition,
-    })
-
-    return loaded[moduleName] as T
-  }
-}

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

@@ -122,7 +122,7 @@ export type LoaderOptions<TOptions = Record<string, unknown>> = {
 }
 
 export type ModuleLoaderFunction = (
-  options: LoaderOptions,
+  options: LoaderOptions<any>,
   moduleDeclaration?: InternalModuleDeclaration
 ) => Promise<void>
 
@@ -226,14 +226,6 @@ export declare type ModuleJoinerRelationship = JoinerRelationship & {
 export type ModuleExports = {
   service: Constructor<any>
   loaders?: ModuleLoaderFunction[]
-  /**
-   * @deprecated property will be removed in future versions
-   */
-  migrations?: any[]
-  /**
-   * @deprecated property will be removed in future versions
-   */
-  models?: Constructor<any>[]
   runMigrations?(
     options: LoaderOptions<any>,
     moduleDeclaration?: InternalModuleDeclaration

packages/core/utils/src/dal/mikro-orm/mikro-orm-create-connection.ts

@@ -99,7 +99,7 @@ export async function mikroOrmCreateConnection(
 
   const { MikroORM } = await import("@mikro-orm/postgresql")
   return await MikroORM.init({
-    discovery: { disableDynamicFileAccess: true },
+    discovery: { disableDynamicFileAccess: true, warnWhenNoEntities: false,  },
     entities,
     debug: database.debug ?? process.env.NODE_ENV?.startsWith("dev") ?? false,
     baseDir: process.cwd(),

packages/core/utils/src/modules-sdk/loaders/container-loader-factory.ts

@@ -10,7 +10,10 @@ import {
 import { asClass } from "awilix"
 import { internalModuleServiceFactory } from "../internal-module-service-factory"
 import { lowerCaseFirst } from "../../common"
-import { mikroOrmBaseRepositoryFactory } from "../../dal"
+import {
+  MikroOrmBaseRepository,
+  mikroOrmBaseRepositoryFactory,
+} from "../../dal"
 
 type RepositoryLoaderOptions = {
   moduleModels: Record<string, any>
@@ -44,13 +47,13 @@ export function moduleContainerLoaderFactory({
   moduleRepositories?: Record<string, any>
   customRepositoryLoader?: (options: RepositoryLoaderOptions) => void
 }): ({ container, options }: LoaderOptions) => Promise<void> {
-  return async ({
+  return async function containerLoader({
     container,
     options,
   }: LoaderOptions<
     | ModuleServiceInitializeOptions
     | ModuleServiceInitializeCustomDataLayerOptions
-  >) => {
+  >) {
     const customRepositories = (
       options as ModuleServiceInitializeCustomDataLayerOptions
     )?.repositories
@@ -85,9 +88,9 @@ export function loadModuleServices({
   container,
 }: ServiceLoaderOptions) {
   const moduleServicesMap = new Map(
-    Object.entries(moduleServices).map(([key, repository]) => [
+    Object.entries(moduleServices).map(([key, service]) => [
       lowerCaseFirst(key),
-      repository,
+      service,
     ])
   )
 
@@ -158,6 +161,10 @@ export function loadModuleRepositories({
 
   const allRepositories = [...customRepositoriesMap, ...moduleRepositoriesMap]
 
+  container.register({
+    ["baseRepository"]: asClass(MikroOrmBaseRepository).singleton(),
+  })
+
   allRepositories.forEach(([key, repository]) => {
     let finalRepository = customRepositoriesMap.get(key)
 

packages/core/utils/src/modules-sdk/loaders/mikro-orm-connection-loader-factory.ts

@@ -17,10 +17,10 @@ export function mikroOrmConnectionLoaderFactory({
   moduleModels: any[]
   migrationsPath?: string
 }): any {
-  return async (
+  return async function connectionLoader(
     { options, container, logger }: LoaderOptions,
     moduleDeclaration?: InternalModuleDeclaration
-  ): Promise<void> => {
+  ): Promise<void> {
     await mikroOrmConnectionLoader({
       moduleName,
       entities: moduleModels,

packages/modules/api-key/src/index.ts

@@ -1,14 +1,7 @@
 import { moduleDefinition } from "./module-definition"
-import { initializeFactory, Modules } from "@medusajs/modules-sdk"
 
 export * from "./types"
 export * from "./models"
 export * from "./services"
 
-export const initialize = initializeFactory({
-  moduleName: Modules.API_KEY,
-  moduleDefinition,
-})
-export const runMigrations = moduleDefinition.runMigrations
-export const revertMigration = moduleDefinition.revertMigration
 export default moduleDefinition

packages/modules/api-key/src/module-definition.ts

@@ -1,44 +1,8 @@
 import { ModuleExports } from "@medusajs/types"
-import * as ModuleServices from "@services"
 import { ApiKeyModuleService } from "@services"
-import { Modules } from "@medusajs/modules-sdk"
-import * as Models from "@models"
-import * as ModuleModels from "@models"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as ModuleRepositories from "@repositories"
-
-const migrationScriptOptions = {
-  moduleName: Modules.API_KEY,
-  models: Models,
-  pathToMigrations: __dirname + "/migrations",
-}
-
-const runMigrations = ModulesSdkUtils.buildMigrationScript(
-  migrationScriptOptions
-)
-
-const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
-  migrationScriptOptions
-)
-
-const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
-  moduleModels: ModuleModels,
-  moduleRepositories: ModuleRepositories,
-  moduleServices: ModuleServices,
-})
-
-const connectionLoader = ModulesSdkUtils.mikroOrmConnectionLoaderFactory({
-  moduleName: Modules.API_KEY,
-  moduleModels: Object.values(Models),
-  migrationsPath: __dirname + "/migrations",
-})
 
 const service = ApiKeyModuleService
-const loaders = [containerLoader, connectionLoader] as any
 
 export const moduleDefinition: ModuleExports = {
   service,
-  loaders,
-  revertMigration,
-  runMigrations,
 }

packages/modules/auth/src/index.ts

@@ -1,11 +1,5 @@
-import {
-  moduleDefinition,
-  revertMigration,
-  runMigrations,
-} from "./module-definition"
+import { moduleDefinition } from "./module-definition"
 
 export default moduleDefinition
-export { revertMigration, runMigrations }
 
-export * from "./initialize"
 export * from "./loaders"

packages/modules/auth/src/initialize/index.ts

@@ -1,31 +0,0 @@
-import {
-  ExternalModuleDeclaration,
-  InternalModuleDeclaration,
-  MedusaModule,
-  MODULE_PACKAGE_NAMES,
-  Modules,
-} from "@medusajs/modules-sdk"
-import { IAuthModuleService, ModulesSdkTypes } from "@medusajs/types"
-
-import { InitializeModuleInjectableDependencies } from "@types"
-import { moduleDefinition } from "../module-definition"
-
-export const initialize = async (
-  options?:
-    | ModulesSdkTypes.ModuleBootstrapDeclaration
-    | ModulesSdkTypes.ModuleServiceInitializeOptions
-    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions,
-  injectedDependencies?: InitializeModuleInjectableDependencies
-): Promise<IAuthModuleService> => {
-  const loaded = await MedusaModule.bootstrap<IAuthModuleService>({
-    moduleKey: Modules.AUTH,
-    defaultPath: MODULE_PACKAGE_NAMES[Modules.AUTH],
-    declaration: options as
-      | InternalModuleDeclaration
-      | ExternalModuleDeclaration, // TODO: Add provider configuration
-    injectedDependencies,
-    moduleExports: moduleDefinition,
-  })
-
-  return loaded[Modules.AUTH]
-}

packages/modules/auth/src/loaders/connection.ts

@@ -1,38 +0,0 @@
-import * as AuthModels from "../models"
-
-import {
-  InternalModuleDeclaration,
-  LoaderOptions,
-  Modules,
-} from "@medusajs/modules-sdk"
-
-import { EntitySchema } from "@mikro-orm/core"
-import { ModulesSdkTypes } from "@medusajs/types"
-import { ModulesSdkUtils } from "@medusajs/utils"
-
-export default async (
-  {
-    options,
-    container,
-    logger,
-  }: LoaderOptions<
-    | ModulesSdkTypes.ModuleServiceInitializeOptions
-    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
-  >,
-  moduleDeclaration?: InternalModuleDeclaration
-): Promise<void> => {
-  const entities = Object.values(
-    AuthModels
-  ) as unknown as EntitySchema[]
-  const pathToMigrations = __dirname + "/../migrations"
-
-  await ModulesSdkUtils.mikroOrmConnectionLoader({
-    moduleName: Modules.AUTH,
-    entities,
-    container,
-    options,
-    moduleDeclaration,
-    logger,
-    pathToMigrations,
-  })
-}

packages/modules/auth/src/loaders/container.ts

@@ -1,10 +0,0 @@
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as ModuleModels from "@models"
-import * as ModuleRepositories from "@repositories"
-import * as ModuleServices from "@services"
-
-export default ModulesSdkUtils.moduleContainerLoaderFactory({
-  moduleModels: ModuleModels,
-  moduleRepositories: ModuleRepositories,
-  moduleServices: ModuleServices,
-})

packages/modules/auth/src/loaders/index.ts

@@ -1,3 +1 @@
-export * from "./connection"
-export * from "./container"
 export * from "./providers"

packages/modules/auth/src/module-definition.ts

@@ -1,32 +1,11 @@
-import * as Models from "@models"
-
 import { AuthModuleService } from "@services"
 import { ModuleExports } from "@medusajs/types"
-import { Modules } from "@medusajs/modules-sdk"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import loadConnection from "./loaders/connection"
-import loadContainer from "./loaders/container"
 import loadProviders from "./loaders/providers"
 
-const migrationScriptOptions = {
-  moduleName: Modules.AUTH,
-  models: Models,
-  pathToMigrations: __dirname + "/migrations",
-}
-
-export const runMigrations = ModulesSdkUtils.buildMigrationScript(
-  migrationScriptOptions
-)
-export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
-  migrationScriptOptions
-)
-
 const service = AuthModuleService
-const loaders = [loadContainer, loadConnection, loadProviders] as any
+const loaders = [loadProviders] as any
 
 export const moduleDefinition: ModuleExports = {
   service,
   loaders,
-  runMigrations,
-  revertMigration,
 }

packages/modules/cart/src/index.ts

@@ -1,10 +1,3 @@
-import {
-  moduleDefinition,
-  revertMigration,
-  runMigrations,
-} from "./module-definition"
+import { moduleDefinition } from "./module-definition"
 
 export default moduleDefinition
-export { revertMigration, runMigrations }
-
-export * from "./initialize"

packages/modules/cart/src/initialize/index.ts

@@ -1,31 +0,0 @@
-import {
-  ExternalModuleDeclaration,
-  InternalModuleDeclaration,
-  MedusaModule,
-  MODULE_PACKAGE_NAMES,
-  Modules,
-} from "@medusajs/modules-sdk"
-import { ICartModuleService, ModulesSdkTypes } from "@medusajs/types"
-import { moduleDefinition } from "../module-definition"
-import { InitializeModuleInjectableDependencies } from "@types"
-
-export const initialize = async (
-  options?:
-    | ModulesSdkTypes.ModuleServiceInitializeOptions
-    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
-    | ExternalModuleDeclaration
-    | InternalModuleDeclaration,
-  injectedDependencies?: InitializeModuleInjectableDependencies
-): Promise<ICartModuleService> => {
-  const loaded = await MedusaModule.bootstrap<ICartModuleService>({
-    moduleKey: Modules.CART,
-    defaultPath: MODULE_PACKAGE_NAMES[Modules.CART],
-    declaration: options as
-      | InternalModuleDeclaration
-      | ExternalModuleDeclaration,
-    injectedDependencies,
-    moduleExports: moduleDefinition,
-  })
-
-  return loaded[Modules.CART]
-}

packages/modules/cart/src/loaders/connection.ts

@@ -1,36 +0,0 @@
-import {
-  InternalModuleDeclaration,
-  LoaderOptions,
-  Modules,
-} from "@medusajs/modules-sdk"
-import { ModulesSdkTypes } from "@medusajs/types"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import { EntitySchema } from "@mikro-orm/core"
-import * as CartModels from "../models"
-
-export default async (
-  {
-    options,
-    container,
-    logger,
-  }: LoaderOptions<
-    | ModulesSdkTypes.ModuleServiceInitializeOptions
-    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
-  >,
-  moduleDeclaration?: InternalModuleDeclaration
-): Promise<void> => {
-  const entities = Object.values(
-    CartModels
-  ) as unknown as EntitySchema[]
-  const pathToMigrations = __dirname + "/../migrations"
-
-  await ModulesSdkUtils.mikroOrmConnectionLoader({
-    moduleName: Modules.CART,
-    entities,
-    container,
-    options,
-    moduleDeclaration,
-    logger,
-    pathToMigrations,
-  })
-}

packages/modules/cart/src/loaders/container.ts

@@ -1,10 +0,0 @@
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as ModuleModels from "@models"
-import * as ModuleRepositories from "@repositories"
-import * as ModuleServices from "@services"
-
-export default ModulesSdkUtils.moduleContainerLoaderFactory({
-  moduleModels: ModuleModels,
-  moduleRepositories: ModuleRepositories,
-  moduleServices: ModuleServices,
-})

packages/modules/cart/src/loaders/index.ts

@@ -1,2 +0,0 @@
-export * from "./connection"
-export * from "./container"

packages/modules/cart/src/module-definition.ts

@@ -1,30 +1,8 @@
-import { Modules } from "@medusajs/modules-sdk"
 import { ModuleExports } from "@medusajs/types"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as Models from "@models"
-import loadConnection from "./loaders/connection"
-import loadContainer from "./loaders/container"
 import { CartModuleService } from "./services"
 
-const migrationScriptOptions = {
-  moduleName: Modules.CART,
-  models: Models,
-  pathToMigrations: __dirname + "/migrations",
-}
-
-export const runMigrations = ModulesSdkUtils.buildMigrationScript(
-  migrationScriptOptions
-)
-export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
-  migrationScriptOptions
-)
-
 const service = CartModuleService
-const loaders = [loadContainer, loadConnection] as any
 
 export const moduleDefinition: ModuleExports = {
   service,
-  loaders,
-  runMigrations,
-  revertMigration,
 }

packages/modules/currency/src/index.ts

@@ -1,14 +1,7 @@
 import { moduleDefinition } from "./module-definition"
-import { initializeFactory, Modules } from "@medusajs/modules-sdk"
 
 export * from "./types"
 export * from "./models"
 export * from "./services"
 
-export const initialize = initializeFactory({
-  moduleName: Modules.CURRENCY,
-  moduleDefinition,
-})
-export const runMigrations = moduleDefinition.runMigrations
-export const revertMigration = moduleDefinition.revertMigration
 export default moduleDefinition

packages/modules/currency/src/module-definition.ts

@@ -1,45 +1,11 @@
 import { ModuleExports } from "@medusajs/types"
-import * as ModuleServices from "@services"
 import { CurrencyModuleService } from "@services"
-import { Modules } from "@medusajs/modules-sdk"
-import * as Models from "@models"
-import * as ModuleModels from "@models"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as ModuleRepositories from "@repositories"
 import initialDataLoader from "./loaders/initial-data"
 
-const migrationScriptOptions = {
-  moduleName: Modules.CURRENCY,
-  models: Models,
-  pathToMigrations: __dirname + "/migrations",
-}
-
-const runMigrations = ModulesSdkUtils.buildMigrationScript(
-  migrationScriptOptions
-)
-
-const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
-  migrationScriptOptions
-)
-
-const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
-  moduleModels: ModuleModels,
-  moduleRepositories: ModuleRepositories,
-  moduleServices: ModuleServices,
-})
-
-const connectionLoader = ModulesSdkUtils.mikroOrmConnectionLoaderFactory({
-  moduleName: Modules.CURRENCY,
-  moduleModels: Object.values(Models),
-  migrationsPath: __dirname + "/migrations",
-})
-
 const service = CurrencyModuleService
-const loaders = [containerLoader, connectionLoader, initialDataLoader] as any
+const loaders = [initialDataLoader]
 
 export const moduleDefinition: ModuleExports = {
   service,
   loaders,
-  revertMigration,
-  runMigrations,
 }

packages/modules/customer/src/index.ts

@@ -1,10 +1,3 @@
-import {
-  moduleDefinition,
-  revertMigration,
-  runMigrations,
-} from "./module-definition"
+import { moduleDefinition } from "./module-definition"
 
 export default moduleDefinition
-export { revertMigration, runMigrations }
-
-export * from "./initialize"

packages/modules/customer/src/initialize/index.ts

@@ -1,31 +0,0 @@
-import {
-  ExternalModuleDeclaration,
-  InternalModuleDeclaration,
-  MedusaModule,
-  MODULE_PACKAGE_NAMES,
-  Modules,
-} from "@medusajs/modules-sdk"
-import { ICustomerModuleService, ModulesSdkTypes } from "@medusajs/types"
-import { moduleDefinition } from "../module-definition"
-import { InitializeModuleInjectableDependencies } from "@types"
-
-export const initialize = async (
-  options?:
-    | ModulesSdkTypes.ModuleServiceInitializeOptions
-    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
-    | ExternalModuleDeclaration
-    | InternalModuleDeclaration,
-  injectedDependencies?: InitializeModuleInjectableDependencies
-): Promise<ICustomerModuleService> => {
-  const loaded = await MedusaModule.bootstrap<ICustomerModuleService>({
-    moduleKey: Modules.CUSTOMER,
-    defaultPath: MODULE_PACKAGE_NAMES[Modules.CUSTOMER],
-    declaration: options as
-      | InternalModuleDeclaration
-      | ExternalModuleDeclaration,
-    injectedDependencies,
-    moduleExports: moduleDefinition,
-  })
-
-  return loaded[Modules.CUSTOMER]
-}

packages/modules/customer/src/loaders/connection.ts

@@ -1,34 +0,0 @@
-import {
-  InternalModuleDeclaration,
-  LoaderOptions,
-  Modules,
-} from "@medusajs/modules-sdk"
-import { ModulesSdkTypes } from "@medusajs/types"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import { EntitySchema } from "@mikro-orm/core"
-import * as CustomerModels from "../models"
-
-export default async (
-  {
-    options,
-    container,
-    logger,
-  }: LoaderOptions<
-    | ModulesSdkTypes.ModuleServiceInitializeOptions
-    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
-  >,
-  moduleDeclaration?: InternalModuleDeclaration
-): Promise<void> => {
-  const entities = Object.values(CustomerModels) as unknown as EntitySchema[]
-  const pathToMigrations = __dirname + "/../migrations"
-
-  await ModulesSdkUtils.mikroOrmConnectionLoader({
-    moduleName: Modules.CUSTOMER,
-    entities,
-    container,
-    options,
-    moduleDeclaration,
-    logger,
-    pathToMigrations,
-  })
-}

packages/modules/customer/src/loaders/container.ts

@@ -1,11 +0,0 @@
-import * as ModuleModels from "@models"
-import * as CustomerRepositories from "@repositories"
-import * as ModuleServices from "@services"
-
-import { ModulesSdkUtils } from "@medusajs/utils"
-
-export default ModulesSdkUtils.moduleContainerLoaderFactory({
-  moduleModels: ModuleModels,
-  moduleServices: ModuleServices,
-  moduleRepositories: CustomerRepositories,
-})

packages/modules/customer/src/loaders/index.ts

@@ -1,2 +0,0 @@
-export * from "./connection"
-export * from "./container"

packages/modules/customer/src/module-definition.ts

@@ -1,31 +1,8 @@
-import { Modules } from "@medusajs/modules-sdk"
 import { ModuleExports } from "@medusajs/types"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as Models from "@models"
 import { CustomerModuleService } from "@services"
-import loadConnection from "./loaders/connection"
-import loadContainer from "./loaders/container"
-
-const migrationScriptOptions = {
-  moduleName: Modules.CUSTOMER,
-  models: Models,
-  pathToMigrations: __dirname + "/migrations",
-}
-
-export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
-  migrationScriptOptions
-)
-
-export const runMigrations = ModulesSdkUtils.buildMigrationScript(
-  migrationScriptOptions
-)
 
 const service = CustomerModuleService
-const loaders = [loadContainer, loadConnection] as any
 
 export const moduleDefinition: ModuleExports = {
   service,
-  loaders,
-  runMigrations,
-  revertMigration,
 }

packages/modules/file/src/index.ts

@@ -1,13 +1,5 @@
 import { moduleDefinition } from "./module-definition"
-import { initializeFactory, Modules } from "@medusajs/modules-sdk"
 export * from "./types"
 export * from "./services"
 
-export const initialize = initializeFactory({
-  moduleName: Modules.FILE,
-  moduleDefinition,
-})
-
-export const runMigrations = moduleDefinition.runMigrations
-export const revertMigration = moduleDefinition.revertMigration
 export default moduleDefinition

packages/modules/file/src/module-definition.ts

@@ -1,28 +1,11 @@
 import { ModuleExports } from "@medusajs/types"
 import { FileModuleService } from "@services"
 import loadProviders from "./loaders/providers"
-import * as ModuleServices from "@services"
-import { ModulesSdkUtils } from "@medusajs/utils"
 
-export const runMigrations = () => {
-  return Promise.resolve()
-}
-export const revertMigration = () => {
-  return Promise.resolve()
-}
-
-const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
-  moduleModels: {},
-  moduleRepositories: {},
-  moduleServices: ModuleServices,
-})
-
-const loaders = [containerLoader, loadProviders] as any
+const loaders = [loadProviders] as any
 
 const service = FileModuleService
 export const moduleDefinition: ModuleExports = {
   service,
   loaders,
-  runMigrations,
-  revertMigration,
 }

packages/modules/fulfillment/src/index.ts

@@ -1,14 +1,7 @@
 import { moduleDefinition } from "./module-definition"
-import { initializeFactory, Modules } from "@medusajs/modules-sdk"
 
 export * from "./types"
 export * from "./models"
 export * from "./services"
 
-export const initialize = initializeFactory({
-  moduleName: Modules.FULFILLMENT,
-  moduleDefinition,
-})
-export const runMigrations = moduleDefinition.runMigrations
-export const revertMigration = moduleDefinition.revertMigration
 export default moduleDefinition

packages/modules/fulfillment/src/module-definition.ts

@@ -1,44 +1,11 @@
 import { ModuleExports } from "@medusajs/types"
-import * as ModuleServices from "@services"
 import { FulfillmentModuleService } from "@services"
-import { Modules } from "@medusajs/modules-sdk"
-import * as ModuleModels from "@models"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as ModuleRepositories from "@repositories"
 import loadProviders from "./loaders/providers"
 
-const migrationScriptOptions = {
-  moduleName: Modules.FULFILLMENT,
-  models: ModuleModels,
-  pathToMigrations: __dirname + "/migrations",
-}
-
-const runMigrations = ModulesSdkUtils.buildMigrationScript(
-  migrationScriptOptions
-)
-
-const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
-  migrationScriptOptions
-)
-
-const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
-  moduleModels: ModuleModels,
-  moduleRepositories: ModuleRepositories,
-  moduleServices: ModuleServices,
-})
-
-const connectionLoader = ModulesSdkUtils.mikroOrmConnectionLoaderFactory({
-  moduleName: Modules.FULFILLMENT,
-  moduleModels: Object.values(ModuleModels),
-  migrationsPath: __dirname + "/migrations",
-})
-
 const service = FulfillmentModuleService
-const loaders = [containerLoader, connectionLoader, loadProviders]
+const loaders = [loadProviders]
 
 export const moduleDefinition: ModuleExports = {
   service,
   loaders,
-  revertMigration,
-  runMigrations,
 }

packages/modules/inventory-next/src/index.ts

@@ -1,14 +1,6 @@
-import { Modules, initializeFactory } from "@medusajs/modules-sdk"
-
 import { moduleDefinition } from "./module-definition"
 
 export * from "./models"
 export * from "./services"
 
-export const initialize = initializeFactory({
-  moduleName: Modules.INVENTORY,
-  moduleDefinition,
-})
-export const runMigrations = moduleDefinition.runMigrations
-export const revertMigration = moduleDefinition.revertMigration
 export default moduleDefinition

packages/modules/inventory-next/src/module-definition.ts

@@ -1,44 +1,8 @@
-import * as InventoryModels from "@models"
-import * as InventoryRepositories from "@repositories"
-import * as InventoryServices from "@services"
-
 import InventoryService from "./services/inventory"
 import { ModuleExports } from "@medusajs/types"
-import { Modules } from "@medusajs/modules-sdk"
-import { ModulesSdkUtils } from "@medusajs/utils"
-
-const migrationScriptOptions = {
-  moduleName: Modules.INVENTORY,
-  models: InventoryModels,
-  pathToMigrations: __dirname + "/migrations",
-}
-
-const runMigrations = ModulesSdkUtils.buildMigrationScript(
-  migrationScriptOptions
-)
-
-const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
-  migrationScriptOptions
-)
-
-const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
-  moduleModels: InventoryModels,
-  moduleRepositories: InventoryRepositories,
-  moduleServices: InventoryServices,
-})
-
-const connectionLoader = ModulesSdkUtils.mikroOrmConnectionLoaderFactory({
-  moduleName: Modules.INVENTORY,
-  moduleModels: Object.values(InventoryModels),
-  migrationsPath: __dirname + "/migrations",
-})
 
 const service = InventoryService
-const loaders = [containerLoader, connectionLoader]
 
 export const moduleDefinition: ModuleExports = {
   service,
-  loaders,
-  revertMigration,
-  runMigrations,
 }

packages/modules/notification/src/index.ts

@@ -1,14 +1,7 @@
 import { moduleDefinition } from "./module-definition"
-import { initializeFactory, Modules } from "@medusajs/modules-sdk"
 
 export * from "./types"
 export * from "./models"
 export * from "./services"
 
-export const initialize = initializeFactory({
-  moduleName: Modules.NOTIFICATION,
-  moduleDefinition,
-})
-export const runMigrations = moduleDefinition.runMigrations
-export const revertMigration = moduleDefinition.revertMigration
 export default moduleDefinition

packages/modules/notification/src/module-definition.ts

@@ -1,44 +1,11 @@
 import { ModuleExports } from "@medusajs/types"
-import * as ModuleServices from "@services"
 import { NotificationModuleService } from "@services"
-import { Modules } from "@medusajs/modules-sdk"
-import * as ModuleModels from "@models"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as ModuleRepositories from "@repositories"
 import loadProviders from "./loaders/providers"
 
-const migrationScriptOptions = {
-  moduleName: Modules.NOTIFICATION,
-  models: ModuleModels,
-  pathToMigrations: __dirname + "/migrations",
-}
-
-const runMigrations = ModulesSdkUtils.buildMigrationScript(
-  migrationScriptOptions
-)
-
-const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
-  migrationScriptOptions
-)
-
-const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
-  moduleModels: ModuleModels,
-  moduleRepositories: ModuleRepositories,
-  moduleServices: ModuleServices,
-})
-
-const connectionLoader = ModulesSdkUtils.mikroOrmConnectionLoaderFactory({
-  moduleName: Modules.NOTIFICATION,
-  moduleModels: Object.values(ModuleModels),
-  migrationsPath: __dirname + "/migrations",
-})
-
 const service = NotificationModuleService
-const loaders = [containerLoader, connectionLoader, loadProviders]
+const loaders = [loadProviders]
 
 export const moduleDefinition: ModuleExports = {
   service,
   loaders,
-  revertMigration,
-  runMigrations,
 }

packages/modules/notification/src/repositories/index.ts

@@ -1 +0,0 @@
-export { MikroOrmBaseRepository as BaseRepository } from "@medusajs/utils"

packages/modules/order/src/index.ts

@@ -1,14 +1,7 @@
-import { initializeFactory, Modules } from "@medusajs/modules-sdk"
 import { moduleDefinition } from "./module-definition"
 
 export * from "./models"
 export * from "./services"
 export * from "./types"
 
-export const initialize = initializeFactory({
-  moduleName: Modules.ORDER,
-  moduleDefinition,
-})
-export const runMigrations = moduleDefinition.runMigrations
-export const revertMigration = moduleDefinition.revertMigration
 export default moduleDefinition

packages/modules/order/src/module-definition.ts

@@ -1,44 +1,8 @@
-import { Modules } from "@medusajs/modules-sdk"
 import { ModuleExports } from "@medusajs/types"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as Models from "@models"
-import * as ModuleModels from "@models"
-import * as ModuleRepositories from "@repositories"
-import * as ModuleServices from "@services"
 import { OrderModuleService } from "@services"
 
-const migrationScriptOptions = {
-  moduleName: Modules.ORDER,
-  models: Models,
-  pathToMigrations: __dirname + "/migrations",
-}
-
-const runMigrations = ModulesSdkUtils.buildMigrationScript(
-  migrationScriptOptions
-)
-
-const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
-  migrationScriptOptions
-)
-
-const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
-  moduleModels: ModuleModels,
-  moduleRepositories: ModuleRepositories,
-  moduleServices: ModuleServices,
-})
-
-const connectionLoader = ModulesSdkUtils.mikroOrmConnectionLoaderFactory({
-  moduleName: Modules.ORDER,
-  moduleModels: Object.values(Models),
-  migrationsPath: __dirname + "/migrations",
-})
-
 const service = OrderModuleService
-const loaders = [containerLoader, connectionLoader] as any
 
 export const moduleDefinition: ModuleExports = {
   service,
-  loaders,
-  revertMigration,
-  runMigrations,
 }

packages/modules/payment/src/index.ts

@@ -1,11 +1,5 @@
-import {
-  moduleDefinition,
-  revertMigration,
-  runMigrations,
-} from "./module-definition"
+import { moduleDefinition } from "./module-definition"
 
 export default moduleDefinition
-export { revertMigration, runMigrations }
 
-export * from "./initialize"
 export * from "./types"

packages/modules/payment/src/initialize/index.ts

@@ -1,38 +0,0 @@
-import {
-  ExternalModuleDeclaration,
-  InternalModuleDeclaration,
-  MedusaModule,
-  MODULE_PACKAGE_NAMES,
-  Modules,
-} from "@medusajs/modules-sdk"
-import {
-  IPaymentModuleService,
-  ModuleProvider,
-  ModulesSdkTypes,
-} from "@medusajs/types"
-
-import { moduleDefinition } from "../module-definition"
-import { InitializeModuleInjectableDependencies } from "../types"
-
-export const initialize = async (
-  options?:
-    | (
-        | ModulesSdkTypes.ModuleServiceInitializeOptions
-        | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
-        | ExternalModuleDeclaration
-        | InternalModuleDeclaration
-      ) & { providers: ModuleProvider[] },
-  injectedDependencies?: InitializeModuleInjectableDependencies
-): Promise<IPaymentModuleService> => {
-  const loaded = await MedusaModule.bootstrap<IPaymentModuleService>({
-    moduleKey: Modules.PAYMENT,
-    defaultPath: MODULE_PACKAGE_NAMES[Modules.PAYMENT],
-    declaration: options as
-      | InternalModuleDeclaration
-      | ExternalModuleDeclaration,
-    injectedDependencies,
-    moduleExports: moduleDefinition,
-  })
-
-  return loaded[Modules.PAYMENT]
-}

packages/modules/payment/src/loaders/connection.ts

@@ -1,34 +0,0 @@
-import {
-  InternalModuleDeclaration,
-  LoaderOptions,
-  Modules,
-} from "@medusajs/modules-sdk"
-import { ModulesSdkTypes } from "@medusajs/types"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import { EntitySchema } from "@mikro-orm/core"
-import * as PaymentModels from "../models"
-
-export default async (
-  {
-    options,
-    container,
-    logger,
-  }: LoaderOptions<
-    | ModulesSdkTypes.ModuleServiceInitializeOptions
-    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
-  >,
-  moduleDeclaration?: InternalModuleDeclaration
-): Promise<void> => {
-  const entities = Object.values(PaymentModels) as unknown as EntitySchema[]
-  const pathToMigrations = __dirname + "/../migrations"
-
-  await ModulesSdkUtils.mikroOrmConnectionLoader({
-    moduleName: Modules.PAYMENT,
-    entities,
-    container,
-    options,
-    moduleDeclaration,
-    logger,
-    pathToMigrations,
-  })
-}

packages/modules/payment/src/loaders/container.ts

@@ -1,10 +0,0 @@
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as ModuleModels from "@models"
-import * as ModuleRepositories from "@repositories"
-import * as ModuleServices from "@services"
-
-export default ModulesSdkUtils.moduleContainerLoaderFactory({
-  moduleModels: ModuleModels,
-  moduleRepositories: ModuleRepositories,
-  moduleServices: ModuleServices,
-})

packages/modules/payment/src/loaders/index.ts

@@ -1,4 +1,2 @@
-export * from "./connection"
-export * from "./container"
 export * from "./providers"
 export * from "./defaults"

packages/modules/payment/src/module-definition.ts

@@ -1,41 +1,13 @@
 import { ModuleExports } from "@medusajs/types"
 
 import { PaymentModuleService } from "@services"
-
-import loadConnection from "./loaders/connection"
-import loadContainer from "./loaders/container"
 import loadProviders from "./loaders/providers"
 import loadDefaults from "./loaders/defaults"
 
-import { Modules } from "@medusajs/modules-sdk"
-import { ModulesSdkUtils } from "@medusajs/utils"
-
-import * as PaymentModels from "@models"
-
-const migrationScriptOptions = {
-  moduleName: Modules.PAYMENT,
-  models: PaymentModels,
-  pathToMigrations: __dirname + "/migrations",
-}
-
-export const runMigrations = ModulesSdkUtils.buildMigrationScript(
-  migrationScriptOptions
-)
-export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
-  migrationScriptOptions
-)
-
 const service = PaymentModuleService
-const loaders = [
-  loadContainer,
-  loadConnection,
-  loadProviders,
-  loadDefaults,
-] as any
+const loaders = [loadProviders, loadDefaults] as any
 
 export const moduleDefinition: ModuleExports = {
   service,
   loaders,
-  runMigrations,
-  revertMigration,
 }

packages/modules/pricing/src/index.ts

@@ -1,14 +1,7 @@
-import {
-  moduleDefinition,
-  revertMigration,
-  runMigrations,
-} from "./module-definition"
+import { moduleDefinition } from "./module-definition"
 
 export default moduleDefinition
-export { revertMigration, runMigrations }
 
-export * from "./initialize"
-// TODO: remove export from models and services
 export * from "./models"
 export * from "./services"
 export * from "./types"

packages/modules/pricing/src/initialize/index.ts

@@ -1,34 +0,0 @@
-import {
-  ExternalModuleDeclaration,
-  InternalModuleDeclaration,
-  MODULE_PACKAGE_NAMES,
-  MedusaModule,
-  Modules,
-} from "@medusajs/modules-sdk"
-import { IPricingModuleService, ModulesSdkTypes } from "@medusajs/types"
-
-import { InitializeModuleInjectableDependencies } from "@types"
-import { moduleDefinition } from "../module-definition"
-
-export const initialize = async (
-  options?:
-    | ModulesSdkTypes.ModuleServiceInitializeOptions
-    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
-    | ExternalModuleDeclaration
-    | InternalModuleDeclaration,
-  injectedDependencies?: InitializeModuleInjectableDependencies
-): Promise<IPricingModuleService> => {
-  const serviceKey = Modules.PRICING
-
-  const loaded = await MedusaModule.bootstrap<IPricingModuleService>({
-    moduleKey: serviceKey,
-    defaultPath: MODULE_PACKAGE_NAMES[Modules.PRICING],
-    declaration: options as
-      | InternalModuleDeclaration
-      | ExternalModuleDeclaration,
-    injectedDependencies,
-    moduleExports: moduleDefinition,
-  })
-
-  return loaded[serviceKey]
-}

packages/modules/pricing/src/loaders/connection.ts

@@ -1,30 +0,0 @@
-import { InternalModuleDeclaration, LoaderOptions } from "@medusajs/modules-sdk"
-import { ModulesSdkTypes } from "@medusajs/types"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import { EntitySchema } from "@mikro-orm/core"
-import * as PricingModels from "../models"
-
-export default async (
-  {
-    options,
-    container,
-    logger,
-  }: LoaderOptions<
-    | ModulesSdkTypes.ModuleServiceInitializeOptions
-    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
-  >,
-  moduleDeclaration?: InternalModuleDeclaration
-): Promise<void> => {
-  const entities = Object.values(PricingModels) as unknown as EntitySchema[]
-  const pathToMigrations = __dirname + "/../migrations"
-
-  await ModulesSdkUtils.mikroOrmConnectionLoader({
-    moduleName: "pricing",
-    entities,
-    container,
-    options,
-    moduleDeclaration,
-    logger,
-    pathToMigrations,
-  })
-}

packages/modules/pricing/src/loaders/container.ts

@@ -1,10 +0,0 @@
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as ModuleModels from "@models"
-import * as ModuleRepositories from "@repositories"
-import * as ModuleServices from "@services"
-
-export default ModulesSdkUtils.moduleContainerLoaderFactory({
-  moduleModels: ModuleModels,
-  moduleRepositories: ModuleRepositories,
-  moduleServices: ModuleServices,
-})

packages/modules/pricing/src/loaders/index.ts

@@ -1,2 +0,0 @@
-export * from "./connection"
-export * from "./container"

packages/modules/pricing/src/module-definition.ts

@@ -1,30 +1,8 @@
-import { Modules } from "@medusajs/modules-sdk"
 import { ModuleExports } from "@medusajs/types"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as Models from "@models"
 import { PricingModuleService } from "@services"
-import loadConnection from "./loaders/connection"
-import loadContainer from "./loaders/container"
-
-const migrationScriptOptions = {
-  moduleName: Modules.PRICING,
-  models: Models,
-  pathToMigrations: __dirname + "/migrations",
-}
-
-export const runMigrations = ModulesSdkUtils.buildMigrationScript(
-  migrationScriptOptions
-)
-export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
-  migrationScriptOptions
-)
 
 const service = PricingModuleService
-const loaders = [loadContainer, loadConnection] as any
 
 export const moduleDefinition: ModuleExports = {
   service,
-  loaders,
-  runMigrations,
-  revertMigration,
 }

packages/modules/product/src/index.ts

@@ -1,14 +1,7 @@
-import {
-  moduleDefinition,
-  revertMigration,
-  runMigrations,
-} from "./module-definition"
+import { moduleDefinition } from "./module-definition"
 
 export default moduleDefinition
-export { revertMigration, runMigrations }
 
-export * from "./initialize"
-// TODO: remove export from models and services
 export * from "./models"
 export * from "./services"
 export * from "./types"

packages/modules/product/src/initialize/index.ts

@@ -1,34 +0,0 @@
-import {
-  ExternalModuleDeclaration,
-  InternalModuleDeclaration,
-  MedusaModule,
-  MODULE_PACKAGE_NAMES,
-  Modules,
-} from "@medusajs/modules-sdk"
-import { IProductModuleService, ModulesSdkTypes } from "@medusajs/types"
-
-import { InitializeModuleInjectableDependencies } from "@types"
-import { moduleDefinition } from "../module-definition"
-
-export const initialize = async (
-  options?:
-    | ModulesSdkTypes.ModuleServiceInitializeOptions
-    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
-    | ExternalModuleDeclaration
-    | InternalModuleDeclaration,
-  injectedDependencies?: InitializeModuleInjectableDependencies
-): Promise<IProductModuleService> => {
-  const serviceKey = Modules.PRODUCT
-
-  const loaded = await MedusaModule.bootstrap<IProductModuleService>({
-    moduleKey: serviceKey,
-    defaultPath: MODULE_PACKAGE_NAMES[Modules.PRODUCT],
-    declaration: options as
-      | InternalModuleDeclaration
-      | ExternalModuleDeclaration,
-    injectedDependencies,
-    moduleExports: moduleDefinition,
-  })
-
-  return loaded[serviceKey]
-}

packages/modules/product/src/loaders/connection.ts

@@ -1,30 +0,0 @@
-import { InternalModuleDeclaration, LoaderOptions } from "@medusajs/modules-sdk"
-import { ModulesSdkTypes } from "@medusajs/types"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import { EntitySchema } from "@mikro-orm/core"
-import * as ProductModels from "../models"
-
-export default async (
-  {
-    options,
-    container,
-    logger,
-  }: LoaderOptions<
-    | ModulesSdkTypes.ModuleServiceInitializeOptions
-    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
-  >,
-  moduleDeclaration?: InternalModuleDeclaration
-): Promise<void> => {
-  const entities = Object.values(ProductModels) as unknown as EntitySchema[]
-  const pathToMigrations = __dirname + "/../migrations"
-
-  await ModulesSdkUtils.mikroOrmConnectionLoader({
-    moduleName: "product",
-    entities,
-    container,
-    options,
-    moduleDeclaration,
-    logger,
-    pathToMigrations,
-  })
-}

packages/modules/product/src/loaders/container.ts

@@ -1,10 +0,0 @@
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as ModuleModels from "@models"
-import * as ModuleRepositories from "@repositories"
-import * as ModuleServices from "@services"
-
-export default ModulesSdkUtils.moduleContainerLoaderFactory({
-  moduleModels: ModuleModels,
-  moduleRepositories: ModuleRepositories,
-  moduleServices: ModuleServices,
-})

packages/modules/product/src/loaders/index.ts

@@ -1,2 +0,0 @@
-export * from "./connection"
-export * from "./container"

packages/modules/product/src/module-definition.ts

@@ -1,31 +1,8 @@
 import { ModuleExports } from "@medusajs/types"
 import { ProductModuleService } from "@services"
-import loadConnection from "./loaders/connection"
-import loadContainer from "./loaders/container"
-
-import { Modules } from "@medusajs/modules-sdk"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as ProductModels from "@models"
-
-const migrationScriptOptions = {
-  moduleName: Modules.PRODUCT,
-  models: ProductModels,
-  pathToMigrations: __dirname + "/migrations",
-}
-
-export const runMigrations = ModulesSdkUtils.buildMigrationScript(
-  migrationScriptOptions
-)
-export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
-  migrationScriptOptions
-)
 
 const service = ProductModuleService
-const loaders = [loadContainer, loadConnection] as any
 
 export const moduleDefinition: ModuleExports = {
   service,
-  loaders,
-  runMigrations,
-  revertMigration,
 }

packages/modules/product/src/repositories/index.ts

@@ -1,3 +1,2 @@
-export { MikroOrmBaseRepository as BaseRepository } from "@medusajs/utils"
 export { ProductRepository } from "./product"
 export { ProductCategoryRepository } from "./product-category"

packages/modules/product/src/services/__fixtures__/product.ts

@@ -1,17 +0,0 @@
-import { asValue } from "awilix"
-
-export const nonExistingProductId = "non-existing-id"
-
-export const productRepositoryMock = {
-  productRepository: asValue({
-    find: jest.fn().mockImplementation(async ({ where: { id } }) => {
-      if (id === nonExistingProductId) {
-        return []
-      }
-
-      return [{}]
-    }),
-    findAndCount: jest.fn().mockResolvedValue([[], 0]),
-    getFreshManager: jest.fn().mockResolvedValue({}),
-  }),
-}

packages/modules/product/src/services/__tests__/index.ts

@@ -0,0 +1 @@
+it("noop", () => {})

packages/modules/product/src/services/__tests__/product.spec.ts

@@ -1,227 +0,0 @@
-import {
-  nonExistingProductId,
-  productRepositoryMock,
-} from "../__fixtures__/product"
-import { createMedusaContainer } from "@medusajs/utils"
-import { asValue } from "awilix"
-import ContainerLoader from "../../loaders/container"
-
-describe("Product service", function () {
-  let container
-
-  beforeEach(async function () {
-    jest.clearAllMocks()
-
-    container = createMedusaContainer()
-    container.register("manager", asValue({}))
-
-    await ContainerLoader({ container })
-
-    container.register(productRepositoryMock)
-  })
-
-  it("should retrieve a product", async function () {
-    const productService = container.resolve("productService")
-    const productRepository = container.resolve("productRepository")
-    const productId = "existing-product"
-
-    await productService.retrieve(productId)
-
-    expect(productRepository.find).toHaveBeenCalledWith(
-      {
-        where: {
-          id: productId,
-        },
-        options: {
-          fields: undefined,
-          limit: undefined,
-          offset: 0,
-          populate: [],
-          withDeleted: undefined,
-        },
-      },
-      expect.any(Object)
-    )
-  })
-
-  it("should fail to retrieve a product", async function () {
-    const productService = container.resolve("productService")
-    const productRepository = container.resolve("productRepository")
-
-    const err = await productService
-      .retrieve(nonExistingProductId)
-      .catch((e) => e)
-
-    expect(productRepository.find).toHaveBeenCalledWith(
-      {
-        where: {
-          id: nonExistingProductId,
-        },
-        options: {
-          fields: undefined,
-          limit: undefined,
-          offset: 0,
-          populate: [],
-          withDeleted: undefined,
-        },
-      },
-      expect.any(Object)
-    )
-
-    expect(err.message).toBe(
-      `Product with id: ${nonExistingProductId} was not found`
-    )
-  })
-
-  it("should list products", async function () {
-    const productService = container.resolve("productService")
-    const productRepository = container.resolve("productRepository")
-
-    const filters = {}
-    const config = {
-      relations: [],
-    }
-
-    await productService.list(filters, config)
-
-    expect(productRepository.find).toHaveBeenCalledWith(
-      {
-        where: {},
-        options: {
-          fields: undefined,
-          limit: 15,
-          offset: 0,
-          orderBy: {
-            id: "ASC",
-          },
-          populate: [],
-          withDeleted: undefined,
-        },
-      },
-      expect.any(Object)
-    )
-  })
-
-  it("should list products with filters", async function () {
-    const productService = container.resolve("productService")
-    const productRepository = container.resolve("productRepository")
-
-    const filters = {
-      tags: {
-        value: {
-          $in: ["test"],
-        },
-      },
-    }
-    const config = {
-      relations: [],
-    }
-
-    await productService.list(filters, config)
-
-    expect(productRepository.find).toHaveBeenCalledWith(
-      {
-        where: {
-          tags: {
-            value: {
-              $in: ["test"],
-            },
-          },
-        },
-        options: {
-          fields: undefined,
-          limit: 15,
-          offset: 0,
-          orderBy: {
-            id: "ASC",
-          },
-          populate: [],
-          withDeleted: undefined,
-        },
-      },
-      expect.any(Object)
-    )
-  })
-
-  it("should list products with filters and relations", async function () {
-    const productService = container.resolve("productService")
-    const productRepository = container.resolve("productRepository")
-
-    const filters = {
-      tags: {
-        value: {
-          $in: ["test"],
-        },
-      },
-    }
-    const config = {
-      relations: ["tags"],
-    }
-
-    await productService.list(filters, config)
-
-    expect(productRepository.find).toHaveBeenCalledWith(
-      {
-        where: {
-          tags: {
-            value: {
-              $in: ["test"],
-            },
-          },
-        },
-        options: {
-          fields: undefined,
-          limit: 15,
-          offset: 0,
-          orderBy: {
-            id: "ASC",
-          },
-          withDeleted: undefined,
-          populate: ["tags"],
-        },
-      },
-      expect.any(Object)
-    )
-  })
-
-  it("should list and count the products with filters and relations", async function () {
-    const productService = container.resolve("productService")
-    const productRepository = container.resolve("productRepository")
-
-    const filters = {
-      tags: {
-        value: {
-          $in: ["test"],
-        },
-      },
-    }
-    const config = {
-      relations: ["tags"],
-    }
-
-    await productService.listAndCount(filters, config)
-
-    expect(productRepository.findAndCount).toHaveBeenCalledWith(
-      {
-        where: {
-          tags: {
-            value: {
-              $in: ["test"],
-            },
-          },
-        },
-        options: {
-          fields: undefined,
-          limit: 15,
-          offset: 0,
-          orderBy: {
-            id: "ASC",
-          },
-          withDeleted: undefined,
-          populate: ["tags"],
-        },
-      },
-      expect.any(Object)
-    )
-  })
-})

packages/modules/promotion/src/index.ts

@@ -1,10 +1,3 @@
-import {
-  moduleDefinition,
-  revertMigration,
-  runMigrations,
-} from "./module-definition"
+import { moduleDefinition } from "./module-definition"
 
 export default moduleDefinition
-export { revertMigration, runMigrations }
-
-export * from "./initialize"

packages/modules/promotion/src/initialize/index.ts

@@ -1,31 +0,0 @@
-import {
-  ExternalModuleDeclaration,
-  InternalModuleDeclaration,
-  MODULE_PACKAGE_NAMES,
-  MedusaModule,
-  Modules,
-} from "@medusajs/modules-sdk"
-import { IPromotionModuleService, ModulesSdkTypes } from "@medusajs/types"
-import { moduleDefinition } from "../module-definition"
-import { InitializeModuleInjectableDependencies } from "../types"
-
-export const initialize = async (
-  options?:
-    | ModulesSdkTypes.ModuleServiceInitializeOptions
-    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
-    | ExternalModuleDeclaration
-    | InternalModuleDeclaration,
-  injectedDependencies?: InitializeModuleInjectableDependencies
-): Promise<IPromotionModuleService> => {
-  const loaded = await MedusaModule.bootstrap<IPromotionModuleService>({
-    moduleKey: Modules.PROMOTION,
-    defaultPath: MODULE_PACKAGE_NAMES[Modules.PROMOTION],
-    declaration: options as
-      | InternalModuleDeclaration
-      | ExternalModuleDeclaration,
-    injectedDependencies,
-    moduleExports: moduleDefinition,
-  })
-
-  return loaded[Modules.PROMOTION]
-}

packages/modules/promotion/src/loaders/connection.ts

@@ -1,34 +0,0 @@
-import {
-  InternalModuleDeclaration,
-  LoaderOptions,
-  Modules,
-} from "@medusajs/modules-sdk"
-import { ModulesSdkTypes } from "@medusajs/types"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import { EntitySchema } from "@mikro-orm/core"
-import * as PromotionModels from "../models"
-
-export default async (
-  {
-    options,
-    container,
-    logger,
-  }: LoaderOptions<
-    | ModulesSdkTypes.ModuleServiceInitializeOptions
-    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
-  >,
-  moduleDeclaration?: InternalModuleDeclaration
-): Promise<void> => {
-  const entities = Object.values(PromotionModels) as unknown as EntitySchema[]
-  const pathToMigrations = __dirname + "/../migrations"
-
-  await ModulesSdkUtils.mikroOrmConnectionLoader({
-    moduleName: Modules.PROMOTION,
-    entities,
-    container,
-    options,
-    moduleDeclaration,
-    logger,
-    pathToMigrations,
-  })
-}

packages/modules/promotion/src/loaders/container.ts

@@ -1,10 +0,0 @@
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as ModuleModels from "@models"
-import * as ModuleRepositories from "@repositories"
-import * as ModuleServices from "@services"
-
-export default ModulesSdkUtils.moduleContainerLoaderFactory({
-  moduleModels: ModuleModels,
-  moduleRepositories: ModuleRepositories,
-  moduleServices: ModuleServices,
-})

packages/modules/promotion/src/loaders/index.ts

@@ -1,2 +0,0 @@
-export * from "./connection"
-export * from "./container"

packages/modules/promotion/src/module-definition.ts

@@ -1,30 +1,8 @@
-import { Modules } from "@medusajs/modules-sdk"
 import { ModuleExports } from "@medusajs/types"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as Models from "@models"
 import { PromotionModuleService } from "@services"
-import loadConnection from "./loaders/connection"
-import loadContainer from "./loaders/container"
-
-const migrationScriptOptions = {
-  moduleName: Modules.PROMOTION,
-  models: Models,
-  pathToMigrations: __dirname + "/migrations",
-}
-
-export const runMigrations = ModulesSdkUtils.buildMigrationScript(
-  migrationScriptOptions
-)
-export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
-  migrationScriptOptions
-)
 
 const service = PromotionModuleService
-const loaders = [loadContainer, loadConnection] as any
 
 export const moduleDefinition: ModuleExports = {
   service,
-  loaders,
-  runMigrations,
-  revertMigration,
 }

packages/modules/region/src/index.ts

@@ -1,10 +1,3 @@
-import {
-  moduleDefinition,
-  revertMigration,
-  runMigrations,
-} from "./module-definition"
+import { moduleDefinition } from "./module-definition"
 
 export default moduleDefinition
-export { revertMigration, runMigrations }
-
-export * from "./initialize"

packages/modules/region/src/initialize/index.ts

@@ -1,34 +0,0 @@
-import {
-  ExternalModuleDeclaration,
-  InternalModuleDeclaration,
-  MedusaModule,
-  MODULE_PACKAGE_NAMES,
-  Modules,
-} from "@medusajs/modules-sdk"
-import { IRegionModuleService, ModulesSdkTypes } from "@medusajs/types"
-import { InitializeModuleInjectableDependencies } from "@types"
-
-import { moduleDefinition } from "../module-definition"
-
-export const initialize = async (
-  options?:
-    | ModulesSdkTypes.ModuleServiceInitializeOptions
-    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
-    | ExternalModuleDeclaration
-    | InternalModuleDeclaration,
-  injectedDependencies?: InitializeModuleInjectableDependencies
-): Promise<IRegionModuleService> => {
-  const serviceKey = Modules.REGION
-
-  const loaded = await MedusaModule.bootstrap<IRegionModuleService>({
-    moduleKey: serviceKey,
-    defaultPath: MODULE_PACKAGE_NAMES[Modules.REGION],
-    declaration: options as
-      | InternalModuleDeclaration
-      | ExternalModuleDeclaration,
-    injectedDependencies,
-    moduleExports: moduleDefinition,
-  })
-
-  return loaded[serviceKey]
-}

packages/modules/region/src/loaders/connection.ts

@@ -1,35 +0,0 @@
-import {
-  InternalModuleDeclaration,
-  LoaderOptions,
-  Modules,
-} from "@medusajs/modules-sdk"
-import { ModulesSdkTypes } from "@medusajs/types"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import { EntitySchema } from "@mikro-orm/core"
-
-import * as RegionModels from "@models"
-
-export default async (
-  {
-    options,
-    container,
-    logger,
-  }: LoaderOptions<
-    | ModulesSdkTypes.ModuleServiceInitializeOptions
-    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
-  >,
-  moduleDeclaration?: InternalModuleDeclaration
-): Promise<void> => {
-  const entities = Object.values(RegionModels) as unknown as EntitySchema[]
-  const pathToMigrations = __dirname + "/../migrations"
-
-  await ModulesSdkUtils.mikroOrmConnectionLoader({
-    moduleName: Modules.REGION,
-    entities,
-    container,
-    options,
-    moduleDeclaration,
-    logger,
-    pathToMigrations,
-  })
-}

packages/modules/region/src/loaders/container.ts

@@ -1,10 +0,0 @@
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as ModuleModels from "@models"
-import * as ModuleRepositories from "@repositories"
-import * as ModuleServices from "@services"
-
-export default ModulesSdkUtils.moduleContainerLoaderFactory({
-  moduleModels: ModuleModels,
-  moduleRepositories: ModuleRepositories,
-  moduleServices: ModuleServices,
-})

packages/modules/region/src/loaders/index.ts

@@ -1,4 +1 @@
-export * from "./connection"
-export * from "./container"
 export * from "./defaults"
-

packages/modules/region/src/module-definition.ts

@@ -1,32 +1,11 @@
 import { ModuleExports } from "@medusajs/types"
 import { RegionModuleService } from "./services"
-
-import { Modules } from "@medusajs/modules-sdk"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as RegionModels from "@models"
-import loadConnection from "./loaders/connection"
-import loadContainer from "./loaders/container"
 import loadDefaults from "./loaders/defaults"
 
-const migrationScriptOptions = {
-  moduleName: Modules.REGION,
-  models: RegionModels,
-  pathToMigrations: __dirname + "/migrations",
-}
-
-export const runMigrations = ModulesSdkUtils.buildMigrationScript(
-  migrationScriptOptions
-)
-export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
-  migrationScriptOptions
-)
-
 const service = RegionModuleService
-const loaders = [loadContainer, loadConnection, loadDefaults] as any
+const loaders = [loadDefaults]
 
 export const moduleDefinition: ModuleExports = {
   service,
   loaders,
-  runMigrations,
-  revertMigration,
 }

packages/modules/sales-channel/integration-tests/__tests__/services/sales-channel-module.spec.ts

@@ -2,242 +2,241 @@ import { SqlEntityManager } from "@mikro-orm/postgresql"
 
 import { ISalesChannelModuleService } from "@medusajs/types"
 
-import { initialize } from "../../../src"
-
 import { createSalesChannels } from "../../__fixtures__"
-import { DB_URL, MikroOrmWrapper } from "../../utils"
+import { moduleIntegrationTestRunner, SuiteOptions } from "medusa-test-utils"
+import { Modules } from "@medusajs/modules-sdk"
 
 jest.setTimeout(30000)
 
-describe("Sales Channel Service", () => {
-  let service: ISalesChannelModuleService
-  let testManager: SqlEntityManager
-  let repositoryManager: SqlEntityManager
+moduleIntegrationTestRunner({
+  moduleName: Modules.SALES_CHANNEL,
+  testSuite: ({
+    MikroOrmWrapper,
+    medusaApp,
+  }: SuiteOptions<ISalesChannelModuleService>) => {
+    let service: ISalesChannelModuleService
 
-  beforeEach(async () => {
-    await MikroOrmWrapper.setupDatabase()
-    repositoryManager = await MikroOrmWrapper.forkManager()
-
-    service = await initialize({
-      database: {
-        clientUrl: DB_URL,
-        schema: process.env.MEDUSA_SALES_CHANNEL_DB_SCHEMA,
-      },
+    beforeEach(() => {
+      service = medusaApp.modules[Modules.SALES_CHANNEL]
     })
 
-    testManager = await MikroOrmWrapper.forkManager()
+    describe("Sales Channel Service", () => {
+      let testManager: SqlEntityManager
+      let repositoryManager: SqlEntityManager
 
-    await createSalesChannels(testManager)
-  })
+      beforeEach(async () => {
+        repositoryManager = await MikroOrmWrapper.forkManager()
+        testManager = await MikroOrmWrapper.forkManager()
 
-  afterEach(async () => {
-    await MikroOrmWrapper.clearDatabase()
-  })
-
-  describe("create", () => {
-    it("should create a SalesChannel successfully", async () => {
-      const [created] = await service.create([
-        {
-          name: "test",
-          description: "test",
-        },
-      ])
-
-      const [channel] = await service.list({
-        name: [created.name],
+        await createSalesChannels(testManager)
       })
 
-      expect(channel.name).toEqual("test")
-      expect(channel.description).toEqual("test")
-    })
-  })
+      describe("create", () => {
+        it("should create a SalesChannel successfully", async () => {
+          const [created] = await service.create([
+            {
+              name: "test",
+              description: "test",
+            },
+          ])
 
-  describe("retrieve", () => {
-    const id = "channel-1"
+          const [channel] = await service.list({
+            name: [created.name],
+          })
 
-    it("should return SalesChannel for the given id", async () => {
-      const result = await service.retrieve(id)
-
-      expect(result).toEqual(
-        expect.objectContaining({
-          id,
+          expect(channel.name).toEqual("test")
+          expect(channel.description).toEqual("test")
         })
-      )
-    })
-
-    it("should throw an error when SalesChannelId with id does not exist", async () => {
-      let error
-
-      try {
-        await service.retrieve("does-not-exist")
-      } catch (e) {
-        error = e
-      }
-
-      expect(error.message).toEqual(
-        "SalesChannel with id: does-not-exist was not found"
-      )
-    })
-  })
-
-  describe("update", () => {
-    const id = "channel-2"
-
-    it("should update the name of the SalesChannel successfully", async () => {
-      await service.update(id, {
-        name: "Update name 2",
-        is_disabled: true,
       })
 
-      const channel = await service.retrieve(id)
+      describe("retrieve", () => {
+        const id = "channel-1"
 
-      expect(channel.name).toEqual("Update name 2")
-      expect(channel.is_disabled).toEqual(true)
-    })
+        it("should return SalesChannel for the given id", async () => {
+          const result = await service.retrieve(id)
 
-    it("should throw an error when a id does not exist", async () => {
-      let error
-
-      try {
-        await service.update("does-not-exist", {
-          name: "does-not-exist",
+          expect(result).toEqual(
+            expect.objectContaining({
+              id,
+            })
+          )
         })
-      } catch (e) {
-        error = e
-      }
 
-      expect(error.message).toEqual(
-        'SalesChannel with id "does-not-exist" not found'
-      )
-    })
-  })
+        it("should throw an error when SalesChannelId with id does not exist", async () => {
+          let error
 
-  describe("list", () => {
-    it("should return a list of SalesChannels", async () => {
-      const result = await service.list()
+          try {
+            await service.retrieve("does-not-exist")
+          } catch (e) {
+            error = e
+          }
 
-      expect(result).toEqual([
-        expect.objectContaining({
-          id: "channel-1",
-        }),
-        expect.objectContaining({
-          id: "channel-2",
-        }),
-        expect.objectContaining({
-          id: "channel-3",
-        }),
-      ])
-    })
-
-    it("should list SalesChannels by name", async () => {
-      const result = await service.list({
-        name: ["Channel 2", "Channel 3"],
+          expect(error.message).toEqual(
+            "SalesChannel with id: does-not-exist was not found"
+          )
+        })
       })
 
-      expect(result).toEqual([
-        expect.objectContaining({
-          id: "channel-2",
-        }),
-        expect.objectContaining({
-          id: "channel-3",
-        }),
-      ])
-    })
-  })
+      describe("update", () => {
+        const id = "channel-2"
 
-  describe("listAndCount", () => {
-    it("should return sales channels and count", async () => {
-      const [result, count] = await service.listAndCount()
+        it("should update the name of the SalesChannel successfully", async () => {
+          await service.update(id, {
+            name: "Update name 2",
+            is_disabled: true,
+          })
 
-      expect(count).toEqual(3)
-      expect(result).toEqual([
-        expect.objectContaining({
-          id: "channel-1",
-        }),
-        expect.objectContaining({
-          id: "channel-2",
-        }),
-        expect.objectContaining({
-          id: "channel-3",
-        }),
-      ])
-    })
+          const channel = await service.retrieve(id)
 
-    it("should return sales channels and count when filtered", async () => {
-      const [result, count] = await service.listAndCount({
-        id: ["channel-2"],
+          expect(channel.name).toEqual("Update name 2")
+          expect(channel.is_disabled).toEqual(true)
+        })
+
+        it("should throw an error when a id does not exist", async () => {
+          let error
+
+          try {
+            await service.update("does-not-exist", {
+              name: "does-not-exist",
+            })
+          } catch (e) {
+            error = e
+          }
+
+          expect(error.message).toEqual(
+            'SalesChannel with id "does-not-exist" not found'
+          )
+        })
       })
 
-      expect(count).toEqual(1)
-      expect(result).toEqual([
-        expect.objectContaining({
-          id: "channel-2",
-        }),
-      ])
-    })
+      describe("list", () => {
+        it("should return a list of SalesChannels", async () => {
+          const result = await service.list()
 
-    it("should return sales channels and count when using skip and take", async () => {
-      const [results, count] = await service.listAndCount(
-        {},
-        { skip: 1, take: 1 }
-      )
+          expect(result).toEqual([
+            expect.objectContaining({
+              id: "channel-1",
+            }),
+            expect.objectContaining({
+              id: "channel-2",
+            }),
+            expect.objectContaining({
+              id: "channel-3",
+            }),
+          ])
+        })
 
-      expect(count).toEqual(3)
-      expect(results).toEqual([
-        expect.objectContaining({
-          id: "channel-2",
-        }),
-      ])
-    })
+        it("should list SalesChannels by name", async () => {
+          const result = await service.list({
+            name: ["Channel 2", "Channel 3"],
+          })
 
-    it("should return requested fields", async () => {
-      const [result, count] = await service.listAndCount(
-        {},
-        {
-          take: 1,
-          select: ["id", "name"],
-        }
-      )
-
-      const serialized = JSON.parse(JSON.stringify(result))
-
-      expect(count).toEqual(3)
-      expect(serialized).toEqual([
-        {
-          id: "channel-1",
-          name: "Channel 1",
-        },
-      ])
-    })
-
-    it("should filter disabled channels", async () => {
-      const [result, count] = await service.listAndCount(
-        { is_disabled: true },
-        { select: ["id"] }
-      )
-
-      const serialized = JSON.parse(JSON.stringify(result))
-
-      expect(count).toEqual(1)
-      expect(serialized).toEqual([
-        {
-          id: "channel-3",
-        },
-      ])
-    })
-  })
-
-  describe("delete", () => {
-    const id = "channel-2"
-
-    it("should delete the SalesChannel given an id successfully", async () => {
-      await service.delete([id])
-
-      const result = await service.list({
-        id: [id],
+          expect(result).toEqual([
+            expect.objectContaining({
+              id: "channel-2",
+            }),
+            expect.objectContaining({
+              id: "channel-3",
+            }),
+          ])
+        })
       })
 
-      expect(result).toHaveLength(0)
+      describe("listAndCount", () => {
+        it("should return sales channels and count", async () => {
+          const [result, count] = await service.listAndCount()
+
+          expect(count).toEqual(3)
+          expect(result).toEqual([
+            expect.objectContaining({
+              id: "channel-1",
+            }),
+            expect.objectContaining({
+              id: "channel-2",
+            }),
+            expect.objectContaining({
+              id: "channel-3",
+            }),
+          ])
+        })
+
+        it("should return sales channels and count when filtered", async () => {
+          const [result, count] = await service.listAndCount({
+            id: ["channel-2"],
+          })
+
+          expect(count).toEqual(1)
+          expect(result).toEqual([
+            expect.objectContaining({
+              id: "channel-2",
+            }),
+          ])
+        })
+
+        it("should return sales channels and count when using skip and take", async () => {
+          const [results, count] = await service.listAndCount(
+            {},
+            { skip: 1, take: 1 }
+          )
+
+          expect(count).toEqual(3)
+          expect(results).toEqual([
+            expect.objectContaining({
+              id: "channel-2",
+            }),
+          ])
+        })
+
+        it("should return requested fields", async () => {
+          const [result, count] = await service.listAndCount(
+            {},
+            {
+              take: 1,
+              select: ["id", "name"],
+            }
+          )
+
+          const serialized = JSON.parse(JSON.stringify(result))
+
+          expect(count).toEqual(3)
+          expect(serialized).toEqual([
+            {
+              id: "channel-1",
+              name: "Channel 1",
+            },
+          ])
+        })
+
+        it("should filter disabled channels", async () => {
+          const [result, count] = await service.listAndCount(
+            { is_disabled: true },
+            { select: ["id"] }
+          )
+
+          const serialized = JSON.parse(JSON.stringify(result))
+
+          expect(count).toEqual(1)
+          expect(serialized).toEqual([
+            {
+              id: "channel-3",
+            },
+          ])
+        })
+      })
+
+      describe("delete", () => {
+        const id = "channel-2"
+
+        it("should delete the SalesChannel given an id successfully", async () => {
+          await service.delete([id])
+
+          const result = await service.list({
+            id: [id],
+          })
+
+          expect(result).toHaveLength(0)
+        })
+      })
     })
-  })
+  },
 })

packages/modules/sales-channel/src/index.ts

@@ -1,27 +1,7 @@
-import { Modules } from "@medusajs/modules-sdk"
-import { ModulesSdkUtils } from "@medusajs/utils"
-
-import * as SalesChannelModels from "@models"
-
 import { moduleDefinition } from "./module-definition"
 
 export default moduleDefinition
 
-const migrationScriptOptions = {
-  moduleName: Modules.SALES_CHANNEL,
-  models: SalesChannelModels,
-  pathToMigrations: __dirname + "/migrations",
-}
-
-export const runMigrations = ModulesSdkUtils.buildMigrationScript(
-  migrationScriptOptions
-)
-export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
-  migrationScriptOptions
-)
-
-export * from "./initialize"
 export * from "./types"
-export * from "./loaders"
 export * from "./models"
 export * from "./services"

packages/modules/sales-channel/src/initialize/index.ts

@@ -1,34 +0,0 @@
-import {
-  ExternalModuleDeclaration,
-  InternalModuleDeclaration,
-  MedusaModule,
-  MODULE_PACKAGE_NAMES,
-  Modules,
-} from "@medusajs/modules-sdk"
-import { ModulesSdkTypes, ISalesChannelModuleService } from "@medusajs/types"
-import { InitializeModuleInjectableDependencies } from "@types"
-
-import { moduleDefinition } from "../module-definition"
-
-export const initialize = async (
-  options?:
-    | ModulesSdkTypes.ModuleServiceInitializeOptions
-    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
-    | ExternalModuleDeclaration
-    | InternalModuleDeclaration,
-  injectedDependencies?: InitializeModuleInjectableDependencies
-): Promise<ISalesChannelModuleService> => {
-  const serviceKey = Modules.SALES_CHANNEL
-
-  const loaded = await MedusaModule.bootstrap<ISalesChannelModuleService>({
-    moduleKey: serviceKey,
-    defaultPath: MODULE_PACKAGE_NAMES[Modules.SALES_CHANNEL],
-    declaration: options as
-      | InternalModuleDeclaration
-      | ExternalModuleDeclaration,
-    injectedDependencies,
-    moduleExports: moduleDefinition,
-  })
-
-  return loaded[serviceKey]
-}

packages/modules/sales-channel/src/loaders/connection.ts

@@ -1,37 +0,0 @@
-import {
-  InternalModuleDeclaration,
-  LoaderOptions,
-  Modules,
-} from "@medusajs/modules-sdk"
-import { ModulesSdkTypes } from "@medusajs/types"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import { EntitySchema } from "@mikro-orm/core"
-
-import * as SalesChannelModels from "@models"
-
-export default async (
-  {
-    options,
-    container,
-    logger,
-  }: LoaderOptions<
-    | ModulesSdkTypes.ModuleServiceInitializeOptions
-    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
-  >,
-  moduleDeclaration?: InternalModuleDeclaration
-): Promise<void> => {
-  const entities = Object.values(
-    SalesChannelModels
-  ) as unknown as EntitySchema[]
-  const pathToMigrations = __dirname + "/../migrations"
-
-  await ModulesSdkUtils.mikroOrmConnectionLoader({
-    moduleName: Modules.SALES_CHANNEL,
-    entities,
-    container,
-    options,
-    moduleDeclaration,
-    logger,
-    pathToMigrations,
-  })
-}

packages/modules/sales-channel/src/loaders/container.ts

@@ -1,10 +0,0 @@
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as ModuleModels from "@models"
-import * as ModuleRepositories from "@repositories"
-import * as ModuleServices from "@services"
-
-export default ModulesSdkUtils.moduleContainerLoaderFactory({
-  moduleModels: ModuleModels,
-  moduleRepositories: ModuleRepositories,
-  moduleServices: ModuleServices,
-})

packages/modules/sales-channel/src/loaders/index.ts

@@ -1,2 +0,0 @@
-export * from "./connection"
-export * from "./container"

packages/modules/sales-channel/src/module-definition.ts

@@ -1,13 +1,8 @@
 import { ModuleExports } from "@medusajs/types"
 import { SalesChannelModuleService } from "@services"
 
-import loadConnection from "./loaders/connection"
-import loadContainer from "./loaders/container"
-
 const service = SalesChannelModuleService
-const loaders = [loadContainer, loadConnection] as any
 
 export const moduleDefinition: ModuleExports = {
   service,
-  loaders,
 }

packages/modules/sales-channel/src/repositories/index.ts

@@ -1 +0,0 @@
-export { MikroOrmBaseRepository as BaseRepository } from "@medusajs/utils"

packages/modules/sales-channel/src/services/__fixtures__/sales-channel.ts

@@ -1,11 +0,0 @@
-import { asValue } from "awilix"
-
-export const salesChannelRepositoryMock = {
-  salesChannelRepository: asValue({
-    find: jest.fn().mockImplementation(async ({ where: { code } }) => {
-      return [{}]
-    }),
-    findAndCount: jest.fn().mockResolvedValue([[], 0]),
-    getFreshManager: jest.fn().mockResolvedValue({}),
-  }),
-}

packages/modules/sales-channel/src/services/__tests__/index.ts

@@ -0,0 +1 @@
+it("noop", () => {})

packages/modules/sales-channel/src/services/__tests__/sales-channle.spec.ts

@@ -1,47 +0,0 @@
-import { createMedusaContainer } from "@medusajs/utils"
-import { asValue } from "awilix"
-import ContainerLoader from "../../loaders/container"
-import { salesChannelRepositoryMock } from "../__fixtures__/sales-channel"
-
-describe("Sales channel service", function () {
-  let container
-
-  beforeEach(async function () {
-    jest.clearAllMocks()
-
-    container = createMedusaContainer()
-    container.register("manager", asValue({}))
-
-    await ContainerLoader({ container })
-
-    container.register(salesChannelRepositoryMock)
-  })
-
-  it("should list sales channels with filters and relations", async function () {
-    const salesChannelRepository = container.resolve("salesChannelRepository")
-    const salesChannelService = container.resolve("salesChannelService")
-
-    const config = {
-      select: ["id", "name"],
-    }
-
-    await salesChannelService.list({}, config)
-
-    expect(salesChannelRepository.find).toHaveBeenCalledWith(
-      {
-        where: {},
-        options: {
-          fields: ["id", "name"],
-          limit: 15,
-          offset: 0,
-          orderBy: {
-            id: "ASC",
-          },
-          withDeleted: undefined,
-          populate: [],
-        },
-      },
-      expect.any(Object)
-    )
-  })
-})

packages/modules/stock-location-next/src/index.ts

@@ -1,14 +1,6 @@
-import { Modules, initializeFactory } from "@medusajs/modules-sdk"
-
 import { moduleDefinition } from "./module-definition"
 
 export * from "./models"
 export * from "./services"
 
-export const initialize = initializeFactory({
-  moduleName: Modules.STOCK_LOCATION,
-  moduleDefinition,
-})
-export const runMigrations = moduleDefinition.runMigrations
-export const revertMigration = moduleDefinition.revertMigration
 export default moduleDefinition

packages/modules/stock-location-next/src/module-definition.ts

@@ -1,44 +1,8 @@
-import * as StockLocationModels from "@models"
-import * as StockLocationRepostiories from "@repositories"
-import * as StockLocationServices from "@services"
-
-import { Modules } from "@medusajs/modules-sdk"
-import { ModuleExports } from "@medusajs/types"
-import { ModulesSdkUtils } from "@medusajs/utils"
 import { StockLocationModuleService } from "@services"
-
-const migrationScriptOptions = {
-  moduleName: Modules.STOCK_LOCATION,
-  models: StockLocationModels,
-  pathToMigrations: __dirname + "/migrations",
-}
-
-const runMigrations = ModulesSdkUtils.buildMigrationScript(
-  migrationScriptOptions
-)
-
-const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
-  migrationScriptOptions
-)
-
-const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
-  moduleModels: StockLocationModels,
-  moduleRepositories: StockLocationRepostiories,
-  moduleServices: StockLocationServices,
-})
-
-const connectionLoader = ModulesSdkUtils.mikroOrmConnectionLoaderFactory({
-  moduleName: Modules.STOCK_LOCATION,
-  moduleModels: Object.values(StockLocationModels),
-  migrationsPath: __dirname + "/migrations",
-})
+import { ModuleExports } from "@medusajs/types"
 
 const service = StockLocationModuleService
-const loaders = [containerLoader, connectionLoader]
 
 export const moduleDefinition: ModuleExports = {
   service,
-  loaders,
-  revertMigration,
-  runMigrations,
 }

packages/modules/store/src/index.ts

@@ -1,14 +1,7 @@
 import { moduleDefinition } from "./module-definition"
-import { initializeFactory, Modules } from "@medusajs/modules-sdk"
 
 export * from "./types"
 export * from "./models"
 export * from "./services"
 
-export const initialize = initializeFactory({
-  moduleName: Modules.STORE,
-  moduleDefinition,
-})
-export const runMigrations = moduleDefinition.runMigrations
-export const revertMigration = moduleDefinition.revertMigration
 export default moduleDefinition

packages/modules/store/src/module-definition.ts

@@ -1,44 +1,8 @@
 import { ModuleExports } from "@medusajs/types"
-import * as ModuleServices from "@services"
 import { StoreModuleService } from "@services"
-import { Modules } from "@medusajs/modules-sdk"
-import * as Models from "@models"
-import * as ModuleModels from "@models"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as ModuleRepositories from "@repositories"
-
-const migrationScriptOptions = {
-  moduleName: Modules.STORE,
-  models: Models,
-  pathToMigrations: __dirname + "/migrations",
-}
-
-const runMigrations = ModulesSdkUtils.buildMigrationScript(
-  migrationScriptOptions
-)
-
-const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
-  migrationScriptOptions
-)
-
-const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
-  moduleModels: ModuleModels,
-  moduleRepositories: ModuleRepositories,
-  moduleServices: ModuleServices,
-})
-
-const connectionLoader = ModulesSdkUtils.mikroOrmConnectionLoaderFactory({
-  moduleName: Modules.STORE,
-  moduleModels: Object.values(Models),
-  migrationsPath: __dirname + "/migrations",
-})
 
 const service = StoreModuleService
-const loaders = [containerLoader, connectionLoader] as any
 
 export const moduleDefinition: ModuleExports = {
   service,
-  loaders,
-  revertMigration,
-  runMigrations,
 }

packages/modules/tax/src/index.ts

@@ -1,13 +1,6 @@
-import { initializeFactory, Modules } from "@medusajs/modules-sdk"
 import { moduleDefinition } from "./module-definition"
 
 export * from "./models"
 export * from "./services"
 
-export const initialize = initializeFactory({
-  moduleName: Modules.TAX,
-  moduleDefinition,
-})
-export const runMigrations = moduleDefinition.runMigrations
-export const revertMigration = moduleDefinition.revertMigration
 export default moduleDefinition

packages/modules/tax/src/module-definition.ts

@@ -1,44 +1,11 @@
-import { MikroOrmBaseRepository, ModulesSdkUtils } from "@medusajs/utils"
-import { Modules } from "@medusajs/modules-sdk"
 import { ModuleExports } from "@medusajs/types"
-import * as Models from "@models"
-import * as ModuleModels from "@models"
-import * as ModuleServices from "@services"
 import { TaxModuleService } from "@services"
 import loadProviders from "./loaders/providers"
 
-const migrationScriptOptions = {
-  moduleName: Modules.TAX,
-  models: Models,
-  pathToMigrations: __dirname + "/migrations",
-}
-
-const runMigrations = ModulesSdkUtils.buildMigrationScript(
-  migrationScriptOptions
-)
-
-const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
-  migrationScriptOptions
-)
-
-const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
-  moduleModels: ModuleModels,
-  moduleRepositories: { BaseRepository: MikroOrmBaseRepository },
-  moduleServices: ModuleServices,
-})
-
-const connectionLoader = ModulesSdkUtils.mikroOrmConnectionLoaderFactory({
-  moduleName: Modules.TAX,
-  moduleModels: Object.values(Models),
-  migrationsPath: __dirname + "/migrations",
-})
-
 const service = TaxModuleService
-const loaders = [containerLoader, connectionLoader, loadProviders] as any
+const loaders = [loadProviders]
 
 export const moduleDefinition: ModuleExports = {
   service,
   loaders,
-  revertMigration,
-  runMigrations,
 }

packages/modules/user/src/index.ts

@@ -1,11 +1,3 @@
-import {
-  moduleDefinition,
-  revertMigration,
-  runMigrations,
-} from "./module-definition"
+import { moduleDefinition } from "./module-definition"
 
 export default moduleDefinition
-export { revertMigration, runMigrations }
-
-export * from "./initialize"
-export * from "./loaders"

packages/modules/user/src/initialize/index.ts

@@ -1,31 +0,0 @@
-import {
-  ExternalModuleDeclaration,
-  InternalModuleDeclaration,
-  MODULE_PACKAGE_NAMES,
-  MedusaModule,
-  Modules,
-} from "@medusajs/modules-sdk"
-import { IUserModuleService, ModulesSdkTypes } from "@medusajs/types"
-
-import { InitializeModuleInjectableDependencies } from "../types"
-import { moduleDefinition } from "../module-definition"
-
-export const initialize = async (
-  options?:
-    | ModulesSdkTypes.ModuleBootstrapDeclaration
-    | ModulesSdkTypes.ModuleServiceInitializeOptions
-    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions,
-  injectedDependencies?: InitializeModuleInjectableDependencies
-): Promise<IUserModuleService> => {
-  const loaded = await MedusaModule.bootstrap<IUserModuleService>({
-    moduleKey: Modules.USER,
-    defaultPath: MODULE_PACKAGE_NAMES[Modules.USER],
-    declaration: options as
-      | InternalModuleDeclaration
-      | ExternalModuleDeclaration,
-    injectedDependencies,
-    moduleExports: moduleDefinition,
-  })
-
-  return loaded[Modules.USER]
-}

packages/modules/user/src/loaders/connection.ts

@@ -1,36 +0,0 @@
-import * as UserModels from "../models"
-
-import {
-  InternalModuleDeclaration,
-  LoaderOptions,
-  Modules,
-} from "@medusajs/modules-sdk"
-
-import { EntitySchema } from "@mikro-orm/core"
-import { ModulesSdkTypes } from "@medusajs/types"
-import { ModulesSdkUtils } from "@medusajs/utils"
-
-export default async (
-  {
-    options,
-    container,
-    logger,
-  }: LoaderOptions<
-    | ModulesSdkTypes.ModuleServiceInitializeOptions
-    | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
-  >,
-  moduleDeclaration?: InternalModuleDeclaration
-): Promise<void> => {
-  const entities = Object.values(UserModels) as unknown as EntitySchema[]
-  const pathToMigrations = __dirname + "/../migrations"
-
-  await ModulesSdkUtils.mikroOrmConnectionLoader({
-    moduleName: Modules.USER,
-    entities,
-    container,
-    options,
-    moduleDeclaration,
-    logger,
-    pathToMigrations,
-  })
-}

packages/modules/user/src/loaders/container.ts

@@ -1,10 +0,0 @@
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as ModuleModels from "@models"
-import * as ModuleRepositories from "@repositories"
-import * as ModuleServices from "@services"
-
-export default ModulesSdkUtils.moduleContainerLoaderFactory({
-  moduleModels: ModuleModels,
-  moduleRepositories: ModuleRepositories,
-  moduleServices: ModuleServices,
-})

packages/modules/user/src/loaders/index.ts

@@ -1,2 +0,0 @@
-export * from "./connection"
-export * from "./container"

packages/modules/user/src/module-definition.ts

@@ -1,31 +1,8 @@
-import * as Models from "@models"
-
 import { UserModuleService } from "@services"
 import { ModuleExports } from "@medusajs/types"
-import { Modules } from "@medusajs/modules-sdk"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import loadConnection from "./loaders/connection"
-import loadContainer from "./loaders/container"
-
-const migrationScriptOptions = {
-  moduleName: Modules.USER,
-  models: Models,
-  pathToMigrations: __dirname + "/migrations",
-}
-
-export const runMigrations = ModulesSdkUtils.buildMigrationScript(
-  migrationScriptOptions
-)
-export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
-  migrationScriptOptions
-)
 
 const service = UserModuleService
-const loaders = [loadContainer, loadConnection] as any
 
 export const moduleDefinition: ModuleExports = {
   service,
-  loaders,
-  runMigrations,
-  revertMigration,
 }