feat: Region PaymentProvider link (#6577)

**What**

- Introduce link between Region and PaymentProvider
- Introduce API endpoint `GET /store/regions/:id/payment-providers` for retrieving providers by region
- Add tests for both

packages/payment/src/joiner-config.ts

@@ -1,11 +1,12 @@
 import { Modules } from "@medusajs/modules-sdk"
 import { ModuleJoinerConfig } from "@medusajs/types"
 import { MapToConfig } from "@medusajs/utils"
-import { Payment, PaymentCollection } from "@models"
+import { Payment, PaymentCollection, PaymentProvider } from "@models"
 
 export const LinkableKeys = {
   payment_id: Payment.name,
   payment_collection_id: PaymentCollection.name,
+  payment_provider_id: PaymentProvider.name,
 }
 
 const entityLinkableKeysMap: MapToConfig = {}
@@ -36,5 +37,12 @@ export const joinerConfig: ModuleJoinerConfig = {
         entity: PaymentCollection.name,
       },
     },
+    {
+      name: ["payment_provider", "payment_providers"],
+      args: {
+        entity: PaymentProvider.name,
+        methodSuffix: "PaymentProviders",
+      },
+    },
   ],
 }

packages/payment/src/loaders/defaults.ts

@@ -1,10 +1,26 @@
-import { IPaymentModuleService, LoaderOptions } from "@medusajs/types"
-import { ModuleRegistrationName } from "@medusajs/modules-sdk"
+import {
+  CreatePaymentProviderDTO,
+  LoaderOptions
+} from "@medusajs/types"
 
 export default async ({ container }: LoaderOptions): Promise<void> => {
-  const paymentModuleService: IPaymentModuleService = container.resolve(
-    ModuleRegistrationName.PAYMENT
-  )
+  const providersToLoad = container.resolve("payment_providers")
+  const paymentProviderService = container.resolve("paymentProviderService")
 
-  await paymentModuleService.createProvidersOnLoad()
+  const providers = await paymentProviderService.list({
+    id: providersToLoad,
+  })
+
+  const loadedProvidersMap = new Map(providers.map((p) => [p.id, p]))
+
+  const providersToCreate: CreatePaymentProviderDTO[] = []
+  for (const id of providersToLoad) {
+    if (loadedProvidersMap.has(id)) {
+      continue
+    }
+
+    providersToCreate.push({ id })
+  }
+
+  await paymentProviderService.create(providersToCreate)
 }

packages/payment/src/services/payment-module.ts

@@ -3,16 +3,18 @@ import {
   Context,
   CreateCaptureDTO,
   CreatePaymentCollectionDTO,
-  CreatePaymentProviderDTO,
   CreatePaymentSessionDTO,
   CreateRefundDTO,
   DAL,
+  FilterablePaymentProviderProps,
+  FindConfig,
   InternalModuleDeclaration,
   IPaymentModuleService,
   ModuleJoinerConfig,
   ModulesSdkTypes,
   PaymentCollectionDTO,
   PaymentDTO,
+  PaymentProviderDTO,
   PaymentSessionDTO,
   PaymentSessionStatus,
   ProviderWebhookPayload,
@@ -590,25 +592,23 @@ export default class PaymentModuleService<
     }
   }
 
-  async createProvidersOnLoad() {
-    const providersToLoad = this.__container__["payment_providers"]
+  @InjectManager("baseRepository_")
+  async listPaymentProviders(
+    filters: FilterablePaymentProviderProps = {},
+    config: FindConfig<PaymentProviderDTO> = {},
+    @MedusaContext() sharedContext?: Context
+  ): Promise<PaymentProviderDTO[]> {
+    const providers = await this.paymentProviderService_.list(
+      filters,
+      config,
+      sharedContext
+    )
 
-    const providers = await this.paymentProviderService_.list({
-      // @ts-ignore TODO
-      id: providersToLoad,
-    })
-
-    const loadedProvidersMap = new Map(providers.map((p) => [p.id, p]))
-
-    const providersToCreate: CreatePaymentProviderDTO[] = []
-    for (const id of providersToLoad) {
-      if (loadedProvidersMap.has(id)) {
-        continue
+    return await this.baseRepository_.serialize<PaymentProviderDTO[]>(
+      providers,
+      {
+        populate: true,
       }
-
-      providersToCreate.push({ id })
-    }
-
-    await this.paymentProviderService_.create(providersToCreate)
+    )
   }
 }

packages/payment/src/services/payment-provider.ts

@@ -3,10 +3,13 @@ import {
   CreatePaymentProviderDTO,
   CreatePaymentProviderSession,
   DAL,
+  FilterablePaymentProviderProps,
+  FindConfig,
   InternalModuleDeclaration,
   IPaymentProvider,
   PaymentProviderAuthorizeResponse,
   PaymentProviderDataInput,
+  PaymentProviderDTO,
   PaymentProviderError,
   PaymentProviderSessionResponse,
   PaymentSessionStatus,
@@ -19,6 +22,7 @@ import {
   InjectTransactionManager,
   isPaymentProviderError,
   MedusaContext,
+  ModulesSdkUtils,
 } from "@medusajs/utils"
 import { PaymentProvider } from "@models"
 import { MedusaError } from "medusa-core-utils"
@@ -52,9 +56,19 @@ export default class PaymentProviderService {
 
   @InjectManager("paymentProviderRepository_")
   async list(
+    filters: FilterablePaymentProviderProps,
+    config: FindConfig<PaymentProviderDTO>,
     @MedusaContext() sharedContext?: Context
   ): Promise<PaymentProvider[]> {
-    return await this.paymentProviderRepository_.find(undefined, sharedContext)
+    const queryOptions = ModulesSdkUtils.buildQuery<PaymentProvider>(
+      filters,
+      config
+    )
+
+    return await this.paymentProviderRepository_.find(
+      queryOptions,
+      sharedContext
+    )
   }
 
   retrieveProvider(providerId: string): IPaymentProvider {