feat: Add support for creating payment methods to payment module (#11063)

CLOSES CLO-407

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

@@ -1,6 +1,5 @@
 import {
   CreatePaymentProviderSession,
-  PaymentMethodResponse,
   PaymentProviderError,
   PaymentProviderSessionResponse,
   ProviderWebhookPayload,
@@ -73,10 +72,6 @@ export class SystemProviderService extends AbstractPaymentProvider {
     return {}
   }
 
-  async listPaymentMethods(_): Promise<PaymentMethodResponse[]> {
-    return []
-  }
-
   async getWebhookActionAndData(
     data: ProviderWebhookPayload["payload"]
   ): Promise<WebhookActionResult> {

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

@@ -4,6 +4,7 @@ import {
   Context,
   CreateCaptureDTO,
   CreatePaymentCollectionDTO,
+  CreatePaymentMethodDTO,
   CreatePaymentSessionDTO,
   CreateRefundDTO,
   DAL,
@@ -914,10 +915,16 @@ export default class PaymentModuleService
     config: FindConfig<PaymentMethodDTO> = {},
     @MedusaContext() sharedContext?: Context
   ): Promise<PaymentMethodDTO[]> {
-    return await this.paymentProviderService_.listPaymentMethods(
+    const res = await this.paymentProviderService_.listPaymentMethods(
       filters.provider_id,
       filters.context
     )
+
+    return res.map((item) => ({
+      id: item.id,
+      data: item.data,
+      provider_id: filters.provider_id,
+    }))
   }
 
   @InjectManager()
@@ -932,7 +939,48 @@ export default class PaymentModuleService
         filters.context
       )
 
-    return [paymentMethods, paymentMethods.length]
+    const normalizedResponse = paymentMethods.map((item) => ({
+      id: item.id,
+      data: item.data,
+      provider_id: filters.provider_id,
+    }))
+
+    return [normalizedResponse, paymentMethods.length]
+  }
+
+  // @ts-ignore
+  createPaymentMethods(
+    data: CreatePaymentCollectionDTO,
+    sharedContext?: Context
+  ): Promise<PaymentCollectionDTO>
+
+  createPaymentMethods(
+    data: CreatePaymentMethodDTO[],
+    sharedContext?: Context
+  ): Promise<PaymentMethodDTO[]>
+  @InjectManager()
+  async createPaymentMethods(
+    data: CreatePaymentMethodDTO | CreatePaymentMethodDTO[],
+    @MedusaContext() sharedContext?: Context
+  ): Promise<PaymentMethodDTO | PaymentMethodDTO[]> {
+    const input = Array.isArray(data) ? data : [data]
+
+    const result = await promiseAll(
+      input.map((item) =>
+        this.paymentProviderService_.savePaymentMethod(item.provider_id, item)
+      ),
+      { aggregateErrors: true }
+    )
+
+    const normalizedResponse = result.map((item, i) => {
+      return {
+        id: item.id,
+        data: item.data,
+        provider_id: input[i].provider_id,
+      }
+    })
+
+    return Array.isArray(data) ? normalizedResponse : normalizedResponse[0]
   }
 
   @InjectManager()

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

@@ -12,6 +12,8 @@ import {
   PaymentProviderSessionResponse,
   PaymentSessionStatus,
   ProviderWebhookPayload,
+  SavePaymentMethod,
+  SavePaymentMethodResponse,
   UpdatePaymentProviderSession,
   WebhookActionResult,
 } from "@medusajs/framework/types"
@@ -73,7 +75,7 @@ Please make sure that the provider is registered in the container and it is conf
   async updateSession(
     providerId: string,
     sessionInput: UpdatePaymentProviderSession
-  ): Promise<Record<string, unknown> | undefined> {
+  ): Promise<PaymentProviderSessionResponse["data"]> {
     const provider = this.retrieveProvider(providerId)
 
     const paymentResponse = await provider.updatePayment(sessionInput)
@@ -157,9 +159,37 @@ Please make sure that the provider is registered in the container and it is conf
     context: PaymentProviderContext
   ): Promise<PaymentMethodResponse[]> {
     const provider = this.retrieveProvider(providerId)
+    if (!provider.listPaymentMethods) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Provider ${providerId} does not support listing payment methods`
+      )
+    }
+
     return await provider.listPaymentMethods(context)
   }
 
+  async savePaymentMethod(
+    providerId: string,
+    input: SavePaymentMethod
+  ): Promise<SavePaymentMethodResponse> {
+    const provider = this.retrieveProvider(providerId)
+    if (!provider.savePaymentMethod) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Provider ${providerId} does not support saving payment methods`
+      )
+    }
+
+    const res = await provider.savePaymentMethod(input)
+
+    if (isPaymentProviderError(res)) {
+      this.throwPaymentProviderError(res)
+    }
+
+    return res as SavePaymentMethodResponse
+  }
+
   async getWebhookActionAndData(
     providerId: string,
     data: ProviderWebhookPayload["payload"]