feat(payment): Payment providers are upserted upon loading (#9090)

integration-tests/modules/__tests__/payment/payment-providers.spec.ts

@@ -29,14 +29,19 @@ medusaIntegrationTestRunner({
         )
 
         expect(response.status).toEqual(200)
-        expect(response.data.payment_providers).toEqual([
+        expect(response.data.payment_providers).toEqual(
-          expect.objectContaining({
+          expect.arrayContaining([
-            id: "pp_system_default_2",
+            expect.objectContaining({
-          }),
+              id: "pp_system_default_2",
-          expect.objectContaining({
+              is_enabled: true,
-            id: "pp_system_default",
+            }),
-          }),
+            expect.objectContaining({
-        ])
+              id: "pp_system_default",
+              is_enabled: true,
+            }),
+          ])
+        )
+
         expect(response.data.count).toEqual(2)
       })
     })

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

@@ -7,8 +7,10 @@ import {
 } from "@medusajs/types"
 import { Lifetime, asFunction, asValue } from "awilix"
 
-import * as providers from "../providers"
 import { PaymentProviderService } from "@services"
+import * as providers from "../providers"
+
+const PROVIDER_REGISTRATION_KEY = "payment_providers"
 
 const registrationFn = async (klass, container, pluginOptions) => {
   const key = `pp_${klass.PROVIDER}_${pluginOptions.id}`
@@ -19,7 +21,7 @@ const registrationFn = async (klass, container, pluginOptions) => {
     }),
   })
 
-  container.registerAdd("payment_providers", asValue(key))
+  container.registerAdd(PROVIDER_REGISTRATION_KEY, asValue(key))
 }
 
 export default async ({
@@ -48,25 +50,27 @@ export default async ({
 const registerProvidersInDb = async ({
   container,
 }: LoaderOptions): Promise<void> => {
-  const providersToLoad = container.resolve<string[]>("payment_providers")
+  const providersToLoad = container.resolve<string[]>(PROVIDER_REGISTRATION_KEY)
   const paymentProviderService = container.resolve<PaymentProviderService>(
     "paymentProviderService"
   )
 
-  const providers = await paymentProviderService.list({
+  const existingProviders = await paymentProviderService.list(
-    id: providersToLoad,
+    { id: providersToLoad },
-  })
+    { take: null }
+  )
 
-  const loadedProvidersMap = new Map(providers.map((p) => [p.id, p]))
+  const upsertData: CreatePaymentProviderDTO[] = []
 
-  const providersToCreate: CreatePaymentProviderDTO[] = []
+  for (const { id } of existingProviders) {
-  for (const id of providersToLoad) {
+    if (!providersToLoad.includes(id)) {
-    if (loadedProvidersMap.has(id)) {
+      upsertData.push({ id, is_enabled: false })
-      continue
     }
-
-    providersToCreate.push({ id })
   }
 
-  await paymentProviderService.create(providersToCreate)
+  for (const id of providersToLoad) {
+    upsertData.push({ id, is_enabled: true })
+  }
+
+  await paymentProviderService.upsert(upsertData)
 }

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

@@ -1,16 +1,10 @@
 import {
   BigNumberInput,
-  Context,
-  CreatePaymentProviderDTO,
   CreatePaymentProviderSession,
   DAL,
-  FilterablePaymentProviderProps,
-  FindConfig,
-  InternalModuleDeclaration,
   IPaymentProvider,
   PaymentProviderAuthorizeResponse,
   PaymentProviderDataInput,
-  PaymentProviderDTO,
   PaymentProviderError,
   PaymentProviderSessionResponse,
   PaymentSessionStatus,
@@ -19,10 +13,7 @@ import {
   WebhookActionResult,
 } from "@medusajs/types"
 import {
-  InjectManager,
-  InjectTransactionManager,
   isPaymentProviderError,
-  MedusaContext,
   MedusaError,
   ModulesSdkUtils,
 } from "@medusajs/utils"
@@ -34,64 +25,12 @@ type InjectedDependencies = {
   [key: `pp_${string}`]: IPaymentProvider
 }
 
-export default class PaymentProviderService {
+export default class PaymentProviderService extends ModulesSdkUtils.MedusaInternalService<InjectedDependencies>(
-  protected readonly container_: InjectedDependencies
+  PaymentProvider
-  protected readonly paymentProviderRepository_: DAL.RepositoryService
+) {
-
-  constructor(
-    container: InjectedDependencies,
-
-    protected readonly moduleDeclaration: InternalModuleDeclaration
-  ) {
-    this.container_ = container
-    this.paymentProviderRepository_ = container.paymentProviderRepository
-  }
-
-  @InjectTransactionManager("paymentProviderRepository_")
-  async create(
-    data: CreatePaymentProviderDTO[],
-    @MedusaContext() sharedContext?: Context
-  ): Promise<PaymentProvider[]> {
-    return await this.paymentProviderRepository_.create(data, sharedContext)
-  }
-
-  @InjectManager("paymentProviderRepository_")
-  async list(
-    filters?: FilterablePaymentProviderProps,
-    config?: FindConfig<PaymentProviderDTO>,
-    @MedusaContext() sharedContext?: Context
-  ): Promise<PaymentProvider[]> {
-    const queryOptions = ModulesSdkUtils.buildQuery<PaymentProvider>(
-      filters,
-      config
-    )
-
-    return await this.paymentProviderRepository_.find(
-      queryOptions,
-      sharedContext
-    )
-  }
-
-  @InjectManager("paymentProviderRepository_")
-  async listAndCount(
-    filters: FilterablePaymentProviderProps,
-    config: FindConfig<PaymentProviderDTO>,
-    @MedusaContext() sharedContext?: Context
-  ): Promise<[PaymentProvider[], number]> {
-    const queryOptions = ModulesSdkUtils.buildQuery<PaymentProvider>(
-      filters,
-      config
-    )
-
-    return await this.paymentProviderRepository_.findAndCount(
-      queryOptions,
-      sharedContext
-    )
-  }
-
   retrieveProvider(providerId: string): IPaymentProvider {
     try {
-      return this.container_[providerId] as IPaymentProvider
+      return this.__container__[providerId] as IPaymentProvider
     } catch (e) {
       throw new MedusaError(
         MedusaError.Types.NOT_FOUND,