Chore/rm main entity concept (#7709)

**What**
Update the `MedusaService` class, factory and types to remove the concept of main modules. The idea being that all method will be explicitly named and suffixes to represent the object you are trying to manipulate.
This pr also includes various fixes in different modules

Co-authored-by: Stevche Radevski <4820812+sradevski@users.noreply.github.com>
Co-authored-by: Oli Juhl <59018053+olivermrbl@users.noreply.github.com>

packages/modules/region/src/index.ts

@@ -1,3 +1,9 @@
-import { moduleDefinition } from "./module-definition"
+import { ModuleExports } from "@medusajs/types"
+import { RegionModuleService } from "./services"
+import loadDefaults from "./loaders/defaults"
 
+const moduleDefinition: ModuleExports = {
+  service: RegionModuleService,
+  loaders: [loadDefaults],
+}
 export default moduleDefinition

packages/modules/region/src/joiner-config.ts

@@ -1,36 +1,11 @@
 import { Modules } from "@medusajs/modules-sdk"
-import { ModuleJoinerConfig } from "@medusajs/types"
-import { MapToConfig } from "@medusajs/utils"
-import { Country, Region } from "@models"
+import {
+  buildEntitiesNameToLinkableKeysMap,
+  defineJoinerConfig,
+  MapToConfig,
+} from "@medusajs/utils"
 
-export const LinkableKeys = {
-  region_id: Region.name,
-  country_iso: Country.name,
-}
+export const joinerConfig = defineJoinerConfig(Modules.REGION)
 
-const entityLinkableKeysMap: MapToConfig = {}
-Object.entries(LinkableKeys).forEach(([key, value]) => {
-  entityLinkableKeysMap[value] ??= []
-  entityLinkableKeysMap[value].push({
-    mapTo: key,
-    valueFrom: key.split("_").pop()!,
-  })
-})
-
-export const entityNameToLinkableKeysMap: MapToConfig = entityLinkableKeysMap
-
-export const joinerConfig: ModuleJoinerConfig = {
-  serviceName: Modules.REGION,
-  primaryKeys: ["id"],
-  linkableKeys: LinkableKeys,
-  alias: [
-    {
-      name: ["region", "regions"],
-      args: { entity: Region.name },
-    },
-    {
-      name: ["country", "countries"],
-      args: { entity: Country.name, methodSuffix: "Countries" },
-    },
-  ],
-} as ModuleJoinerConfig
+export const entityNameToLinkableKeysMap: MapToConfig =
+  buildEntitiesNameToLinkableKeysMap(joinerConfig.linkableKeys)

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

@@ -1,11 +0,0 @@
-import { ModuleExports } from "@medusajs/types"
-import { RegionModuleService } from "./services"
-import loadDefaults from "./loaders/defaults"
-
-const service = RegionModuleService
-const loaders = [loadDefaults]
-
-export const moduleDefinition: ModuleExports = {
-  service,
-  loaders,
-}

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

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

packages/modules/region/src/scripts/bin/run-seed.ts

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-
-import { Modules } from "@medusajs/modules-sdk"
-import { ModulesSdkUtils } from "@medusajs/utils"
-import * as RegionModels from "@models"
-import { EOL } from "os"
-import { createRegions } from "../seed-utils"
-
-const args = process.argv
-const path = args.pop() as string
-
-export default (async () => {
-  const { config } = await import("dotenv")
-  config()
-  if (!path) {
-    throw new Error(
-      `filePath is required.${EOL}Example: medusa-region-seed <filePath>`
-    )
-  }
-
-  const run = ModulesSdkUtils.buildSeedScript({
-    moduleName: Modules.REGION,
-    models: RegionModels,
-    pathToMigrations: __dirname + "/../../migrations",
-    seedHandler: async ({ manager, data }) => {
-      const { regionData } = data
-      await createRegions(manager, regionData)
-    },
-  })
-  await run({ path })
-})()

packages/modules/region/src/scripts/seed-utils.ts

@@ -1,16 +0,0 @@
-import { RequiredEntityData } from "@mikro-orm/core"
-import { SqlEntityManager } from "@mikro-orm/postgresql"
-import { Region } from "@models"
-
-export async function createRegions(
-  manager: SqlEntityManager,
-  data: RequiredEntityData<Region>[]
-) {
-  const regions = data.map((region) => {
-    return manager.create(Region, region)
-  })
-
-  await manager.persistAndFlush(regions)
-
-  return regions
-}

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

@@ -20,7 +20,7 @@ import {
   isString,
   MedusaContext,
   MedusaError,
-  ModulesSdkUtils,
+  MedusaService,
   promiseAll,
   removeUndefined,
 } from "@medusajs/utils"
@@ -36,25 +36,20 @@ type InjectedDependencies = {
   countryService: ModulesSdkTypes.IMedusaInternalService<any>
 }
 
-const generateMethodForModels = { Country }
-
-export default class RegionModuleService<
-    TRegion extends Region = Region,
-    TCountry extends Country = Country
-  >
-  extends ModulesSdkUtils.MedusaService<
-    RegionDTO,
-    {
-      Country: {
-        dto: RegionCountryDTO
-      }
+export default class RegionModuleService
+  extends MedusaService<{
+    Region: {
+      dto: RegionDTO
     }
-  >(Region, generateMethodForModels, entityNameToLinkableKeysMap)
+    Country: {
+      dto: RegionCountryDTO
+    }
+  }>({ Region, Country }, entityNameToLinkableKeysMap)
   implements IRegionModuleService
 {
   protected baseRepository_: DAL.RepositoryService
-  protected readonly regionService_: ModulesSdkTypes.IMedusaInternalService<TRegion>
-  protected readonly countryService_: ModulesSdkTypes.IMedusaInternalService<TCountry>
+  protected readonly regionService_: ModulesSdkTypes.IMedusaInternalService<Region>
+  protected readonly countryService_: ModulesSdkTypes.IMedusaInternalService<Country>
 
   constructor(
     { baseRepository, regionService, countryService }: InjectedDependencies,
@@ -71,22 +66,24 @@ export default class RegionModuleService<
     return joinerConfig
   }
 
-  async create(
+  //@ts-expect-error
+  async createRegions(
     data: CreateRegionDTO[],
     sharedContext?: Context
   ): Promise<RegionDTO[]>
-  async create(
+  async createRegions(
     data: CreateRegionDTO,
     sharedContext?: Context
   ): Promise<RegionDTO>
+
   @InjectManager("baseRepository_")
-  async create(
+  async createRegions(
     data: CreateRegionDTO | CreateRegionDTO[],
     @MedusaContext() sharedContext: Context = {}
   ): Promise<RegionDTO | RegionDTO[]> {
     const input = Array.isArray(data) ? data : [data]
 
-    const result = await this.create_(input, sharedContext)
+    const result = await this.createRegions_(input, sharedContext)
 
     return await this.baseRepository_.serialize<RegionDTO[]>(
       Array.isArray(data) ? result : result[0]
@@ -94,7 +91,7 @@ export default class RegionModuleService<
   }
 
   @InjectTransactionManager("baseRepository_")
-  async create_(
+  async createRegions_(
     data: CreateRegionDTO[],
     @MedusaContext() sharedContext: Context = {}
   ): Promise<Region[]> {
@@ -132,16 +129,17 @@ export default class RegionModuleService<
     return result
   }
 
-  async upsert(
+  async upsertRegions(
     data: UpsertRegionDTO[],
     sharedContext?: Context
   ): Promise<RegionDTO[]>
-  async upsert(
+  async upsertRegions(
     data: UpsertRegionDTO,
     sharedContext?: Context
   ): Promise<RegionDTO>
+
   @InjectTransactionManager("baseRepository_")
-  async upsert(
+  async upsertRegions(
     data: UpsertRegionDTO | UpsertRegionDTO[],
     @MedusaContext() sharedContext: Context = {}
   ): Promise<RegionDTO | RegionDTO[]> {
@@ -156,10 +154,10 @@ export default class RegionModuleService<
     const operations: Promise<Region[]>[] = []
 
     if (forCreate.length) {
-      operations.push(this.create_(forCreate, sharedContext))
+      operations.push(this.createRegions_(forCreate, sharedContext))
     }
     if (forUpdate.length) {
-      operations.push(this.update_(forUpdate, sharedContext))
+      operations.push(this.updateRegions_(forUpdate, sharedContext))
     }
 
     const result = (await promiseAll(operations)).flat()
@@ -168,18 +166,20 @@ export default class RegionModuleService<
     )
   }
 
-  async update(
+  //@ts-expect-error
+  async updateRegions(
     id: string,
     data: UpdateRegionDTO,
     sharedContext?: Context
   ): Promise<RegionDTO>
-  async update(
+  async updateRegions(
     selector: FilterableRegionProps,
     data: UpdateRegionDTO,
     sharedContext?: Context
   ): Promise<RegionDTO[]>
+
   @InjectManager("baseRepository_")
-  async update(
+  async updateRegions(
     idOrSelector: string | FilterableRegionProps,
     data: UpdateRegionDTO,
     @MedusaContext() sharedContext: Context = {}
@@ -200,7 +200,10 @@ export default class RegionModuleService<
       }))
     }
 
-    const updateResult = await this.update_(normalizedInput, sharedContext)
+    const updateResult = await this.updateRegions_(
+      normalizedInput,
+      sharedContext
+    )
 
     const regions = await this.baseRepository_.serialize<
       RegionDTO[] | RegionDTO
@@ -210,7 +213,7 @@ export default class RegionModuleService<
   }
 
   @InjectTransactionManager("baseRepository_")
-  protected async update_(
+  protected async updateRegions_(
     data: UpdateRegionInput[],
     @MedusaContext() sharedContext: Context = {}
   ): Promise<Region[]> {
@@ -282,7 +285,7 @@ export default class RegionModuleService<
   private async validateCountries(
     countries: string[] | undefined,
     sharedContext: Context
-  ): Promise<TCountry[]> {
+  ): Promise<Country[]> {
     if (!countries?.length) {
       return []
     }

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

@@ -1,5 +1,4 @@
 import { Logger, UpdateRegionDTO } from "@medusajs/types"
-import { Country } from "@models"
 
 export type InitializeModuleInjectableDependencies = {
   logger?: Logger