feat: Region Module (basic CRUD) (#6315)

packages/region/integration-tests/__tests__/region-module.spec.ts

@@ -0,0 +1,101 @@
+import { Modules } from "@medusajs/modules-sdk"
+import { IRegionModuleService } from "@medusajs/types"
+import { DefaultsUtils } from "@medusajs/utils"
+import { initModules } from "medusa-test-utils"
+import { MikroOrmWrapper } from "../utils"
+import { getInitModuleConfig } from "../utils/get-init-module-config"
+
+jest.setTimeout(30000)
+
+describe("Region Module Service", () => {
+  let service: IRegionModuleService
+  let shutdownFunc: () => Promise<void>
+
+  beforeEach(async () => {
+    await MikroOrmWrapper.setupDatabase()
+
+    const initModulesConfig = getInitModuleConfig()
+    const { medusaApp, shutdown } = await initModules(initModulesConfig)
+    service = medusaApp.modules[Modules.REGION]
+
+    shutdownFunc = shutdown
+  })
+
+  afterEach(async () => {
+    await MikroOrmWrapper.clearDatabase()
+    await shutdownFunc()
+  })
+
+  it("should create countries and currencies on application start", async () => {
+    const countries = await service.listCountries()
+    const currencies = await service.listCurrencies()
+
+    expect(countries.length).toBeGreaterThan(0)
+    expect(currencies.length).toBeGreaterThan(0)
+  })
+
+  it("should create countries added to default ones", async () => {
+    const [, count] = await service.listAndCountCountries()
+    const initialCountries = DefaultsUtils.defaultCountries.length
+
+    expect(count).toEqual(initialCountries)
+
+    DefaultsUtils.defaultCountries.push({
+      name: "Dogecoin",
+      alpha2: "DOGE",
+      alpha3: "DOGE",
+      numeric: "420",
+    })
+
+    await service.createDefaultCountriesAndCurrencies()
+
+    const [, newCount] = await service.listAndCountCountries()
+    expect(newCount).toEqual(initialCountries + 1)
+  })
+
+  it("should create and list a region", async () => {
+    const createdRegion = await service.create({
+      name: "Europe",
+      currency_code: "EUR",
+    })
+
+    expect(createdRegion).toEqual(
+      expect.objectContaining({
+        id: createdRegion.id,
+        name: "Europe",
+        currency_code: "EUR",
+        currency: expect.objectContaining({
+          code: "eur",
+          name: "Euro",
+        }),
+        countries: [],
+      })
+    )
+
+    const region = await service.retrieve(createdRegion.id, {
+      relations: ["currency", "countries"],
+    })
+
+    expect(region).toEqual(
+      expect.objectContaining({
+        id: region.id,
+        name: "Europe",
+        currency_code: "EUR",
+        currency: expect.objectContaining({
+          code: "eur",
+          name: "Euro",
+        }),
+        countries: [],
+      })
+    )
+  })
+
+  it("should fail when currency does not exist", async () => {
+    await expect(
+      service.create({
+        name: "Europe",
+        currency_code: "DOGECOIN",
+      })
+    ).rejects.toThrowError("Currency with code: DOGECOIN was not found")
+  })
+})

packages/region/integration-tests/setup-env.js

@@ -0,0 +1,6 @@
+if (typeof process.env.DB_TEMP_NAME === "undefined") {
+  const tempName = parseInt(process.env.JEST_WORKER_ID || "1")
+  process.env.DB_TEMP_NAME = `medusa-region-integration-${tempName}`
+}
+
+process.env.MEDUSA_REGION_DB_SCHEMA = "public"

packages/region/integration-tests/setup.js

@@ -0,0 +1,3 @@
+import { JestUtils } from "medusa-test-utils"
+
+JestUtils.afterAllHookDropDatabase()

packages/region/integration-tests/utils/config.ts

@@ -0,0 +1,6 @@
+import { ModuleServiceInitializeOptions } from "@medusajs/types"
+
+export const databaseOptions: ModuleServiceInitializeOptions["database"] = {
+  schema: "public",
+  clientUrl: "medusa-region-test",
+}

packages/region/integration-tests/utils/database.ts

@@ -0,0 +1,18 @@
+import { TestDatabaseUtils } from "medusa-test-utils"
+
+import * as RegionModels from "@models"
+
+const pathToMigrations = "../../src/migrations"
+const mikroOrmEntities = RegionModels as unknown as any[]
+
+export const MikroOrmWrapper = TestDatabaseUtils.getMikroOrmWrapper(
+  mikroOrmEntities,
+  pathToMigrations
+)
+
+export const MikroOrmConfig = TestDatabaseUtils.getMikroOrmConfig(
+  mikroOrmEntities,
+  pathToMigrations
+)
+
+export const DB_URL = TestDatabaseUtils.getDatabaseURL()

packages/region/integration-tests/utils/get-init-module-config.ts

@@ -0,0 +1,33 @@
+import { Modules, ModulesDefinition } from "@medusajs/modules-sdk"
+
+import { DB_URL } from "./database"
+
+export function getInitModuleConfig() {
+  const moduleOptions = {
+    defaultAdapterOptions: {
+      database: {
+        clientUrl: DB_URL,
+        schema: process.env.MEDUSA_REGION_DB_SCHEMA,
+      },
+    },
+  }
+
+  const injectedDependencies = {}
+
+  const modulesConfig_ = {
+    [Modules.REGION]: {
+      definition: ModulesDefinition[Modules.REGION],
+      options: moduleOptions,
+    },
+  }
+
+  return {
+    injectedDependencies,
+    modulesConfig: modulesConfig_,
+    databaseConfig: {
+      clientUrl: DB_URL,
+      schema: process.env.MEDUSA_REGION_DB_SCHEMA,
+    },
+    joinerConfig: [],
+  }
+}

packages/region/integration-tests/utils/index.ts

@@ -0,0 +1,3 @@
+export * from "./config"
+export * from "./database"
+