@easypayment/medusa-paypal 0.6.4 → 0.6.6

package/src/modules/paypal/payment-provider/service.ts

@@ -38,7 +38,6 @@ function generateSessionId() {
   try {
     return randomUUID()
   } catch {
-    // Fallback for environments where randomUUID isn't available
     return `pp_${Date.now()}_${Math.random().toString(16).slice(2)}`
   }
 }
@@ -64,65 +63,72 @@ class PayPalPaymentProvider extends AbstractPaymentProvider<Options> {
     }
   }
 
-async resolveSettings() {
-    const paypal = this.resolvePayPalService();
+  async resolveSettings() {
+    const paypal = this.resolvePayPalService()
     if (!paypal) {
-        try {
-            const { Pool: _SettingsPool } = require("pg")
-            const _sPool = new _SettingsPool({ connectionString: process.env.DATABASE_URL })
-            const _sResult = await _sPool
-                .query("SELECT data FROM paypal_settings ORDER BY created_at DESC LIMIT 1")
-                .finally(() => _sPool.end())
-            const _sData = _sResult.rows[0]?.data || {}
-            return {
-                additionalSettings: (_sData.additional_settings || {}) as Record<string, unknown>,
-                apiDetails: (_sData.api_details || {}) as Record<string, unknown>,
-            }
-        } catch {
-            return {
-                additionalSettings: {} as Record<string, unknown>,
-                apiDetails: {} as Record<string, unknown>,
-            }
+      try {
+        const { Pool: _SettingsPool } = require("pg")
+        const _sPool = new _SettingsPool({ connectionString: process.env.DATABASE_URL })
+        const _sResult = await _sPool
+          .query("SELECT data FROM paypal_settings ORDER BY created_at DESC LIMIT 1")
+          .finally(() => _sPool.end())
+        const _sData = _sResult.rows[0]?.data || {}
+        return {
+          additionalSettings: (_sData.additional_settings || {}) as Record<string, unknown>,
+          apiDetails: (_sData.api_details || {}) as Record<string, unknown>,
         }
+      } catch {
+        return {
+          additionalSettings: {} as Record<string, unknown>,
+          apiDetails: {} as Record<string, unknown>,
+        }
+      }
     }
     const settings = await paypal.getSettings().catch(() => ({}))
-    const data = settings && typeof settings === "object" && "data" in settings
+    const data =
+      settings && typeof settings === "object" && "data" in settings
         ? ((settings as any).data ?? {})
         : {}
     return {
-        additionalSettings: (data.additional_settings || {}) as Record<string, unknown>,
-        apiDetails: (data.api_details || {}) as Record<string, unknown>,
+      additionalSettings: (data.additional_settings || {}) as Record<string, unknown>,
+      apiDetails: (data.api_details || {}) as Record<string, unknown>,
     }
-}
+  }
 
   private async resolveCurrencyOverride() {
     const { apiDetails } = await this.resolveSettings()
-    if (typeof apiDetails.currency_code === "string" && apiDetails.currency_code.trim()) {
-      return normalizeCurrencyCode(apiDetails.currency_code)
+    if (typeof apiDetails.currency_code === "string" && (apiDetails.currency_code as string).trim()) {
+      return normalizeCurrencyCode(apiDetails.currency_code as string)
     }
     return normalizeCurrencyCode(process.env.PAYPAL_CURRENCY || "EUR")
   }
 
-    private async getPayPalAccessToken() {
+  private async getPayPalAccessToken() {
     const paypal = this.resolvePayPalService()
     if (!paypal) {
-      // Fallback: load credentials directly from paypal_connection table
       const { Pool: _FbPool } = require("pg")
       const _fbPool = new _FbPool({ connectionString: process.env.DATABASE_URL })
-      const _fbResult = await _fbPool.query(
-        "SELECT metadata, environment, seller_client_id, seller_client_secret FROM paypal_connection WHERE status='connected' ORDER BY created_at DESC LIMIT 1"
-      ).finally(() => _fbPool.end())
+      const _fbResult = await _fbPool
+        .query(
+          "SELECT metadata, environment, seller_client_id, seller_client_secret FROM paypal_connection WHERE status='connected' ORDER BY created_at DESC LIMIT 1"
+        )
+        .finally(() => _fbPool.end())
       const _fbRow = _fbResult.rows[0]
       if (!_fbRow) throw new Error("No active PayPal connection found in DB")
       const _fbEnv = _fbRow.environment || "sandbox"
-      const _fbCreds = (_fbRow.metadata && _fbRow.metadata.credentials && _fbRow.metadata.credentials[_fbEnv]) || {}
+      const _fbCreds =
+        (_fbRow.metadata && _fbRow.metadata.credentials && _fbRow.metadata.credentials[_fbEnv]) || {}
       const _fbId = _fbCreds.client_id || _fbRow.seller_client_id
       const _fbSec = _fbCreds.client_secret || _fbRow.seller_client_secret
-      const _fbBase = _fbEnv === "live" ? "https://api-m.paypal.com" : "https://api-m.sandbox.paypal.com"
+      const _fbBase =
+        _fbEnv === "live" ? "https://api-m.paypal.com" : "https://api-m.sandbox.paypal.com"
       const _fbAuth = Buffer.from(`${_fbId}:${_fbSec}`).toString("base64")
       const _fbResp = await fetch(`${_fbBase}/v1/oauth2/token`, {
         method: "POST",
-        headers: { Authorization: `Basic ${_fbAuth}`, "Content-Type": "application/x-www-form-urlencoded" },
+        headers: {
+          Authorization: `Basic ${_fbAuth}`,
+          "Content-Type": "application/x-www-form-urlencoded",
+        },
         body: "grant_type=client_credentials",
       })
       const _fbText = await _fbResp.text()
@@ -155,7 +161,6 @@ async resolveSettings() {
     return { accessToken: String(json.access_token), base }
   }
 
-
   private async getOrderDetails(orderId: string) {
     const { accessToken, base } = await this.getPayPalAccessToken()
     const resp = await fetch(`${base}/v2/checkout/orders/${orderId}`, {
@@ -174,7 +179,10 @@ async resolveSettings() {
     return JSON.parse(text)
   }
 
-  private getIdempotencyKey(input: { context?: { idempotency_key?: string } }, suffix: string) {
+  private getIdempotencyKey(
+    input: { context?: { idempotency_key?: string } },
+    suffix: string
+  ) {
     const key = input?.context?.idempotency_key?.trim()
     if (key) {
       return `${key}-${suffix}`
@@ -198,47 +206,20 @@ async resolveSettings() {
 
   private mapCaptureStatus(status?: string) {
     const normalized = String(status || "").toUpperCase()
-    if (!normalized) {
-      return null
-    }
-
-    if (normalized === "COMPLETED") {
-      return "captured"
-    }
-
-    if (normalized === "PENDING") {
-      return "pending"
-    }
-
-    if (["DENIED", "DECLINED", "FAILED"].includes(normalized)) {
-      return "error"
-    }
-
-    if (["REFUNDED", "PARTIALLY_REFUNDED", "REVERSED"].includes(normalized)) {
-      return "canceled"
-    }
-
+    if (!normalized) return null
+    if (normalized === "COMPLETED") return "captured"
+    if (normalized === "PENDING") return "pending"
+    if (["DENIED", "DECLINED", "FAILED"].includes(normalized)) return "error"
+    if (["REFUNDED", "PARTIALLY_REFUNDED", "REVERSED"].includes(normalized)) return "canceled"
     return null
   }
 
   private mapAuthorizationStatus(status?: string) {
     const normalized = String(status || "").toUpperCase()
-    if (!normalized) {
-      return null
-    }
-
-    if (["CREATED", "APPROVED", "PENDING"].includes(normalized)) {
-      return "authorized"
-    }
-
-    if (["VOIDED", "EXPIRED"].includes(normalized)) {
-      return "canceled"
-    }
-
-    if (["DENIED", "DECLINED", "FAILED"].includes(normalized)) {
-      return "error"
-    }
-
+    if (!normalized) return null
+    if (["CREATED", "APPROVED", "PENDING"].includes(normalized)) return "authorized"
+    if (["VOIDED", "EXPIRED"].includes(normalized)) return "canceled"
+    if (["DENIED", "DECLINED", "FAILED"].includes(normalized)) return "error"
     return null
   }
 
@@ -252,87 +233,53 @@ async resolveSettings() {
         stack: error.stack,
         cause:
           cause instanceof Error
-            ? {
-                name: cause.name,
-                message: cause.message,
-                stack: cause.stack,
-              }
+            ? { name: cause.name, message: cause.message, stack: cause.stack }
             : cause,
       }
     }
-
-    return {
-      message: String(error),
-    }
+    return { message: String(error) }
   }
 
   private mapOrderStatus(status?: string) {
     const normalized = String(status || "").toUpperCase()
-    if (!normalized) {
-      return "pending"
-    }
-
-    if (normalized === "COMPLETED") {
-      return "captured"
-    }
-
-    if (normalized === "APPROVED") {
-      return "authorized"
-    }
-
-    if (["VOIDED", "CANCELLED"].includes(normalized)) {
-      return "canceled"
-    }
-
-    if (["CREATED", "SAVED", "PAYER_ACTION_REQUIRED"].includes(normalized)) {
-      return "pending"
-    }
-
-    if (["FAILED", "EXPIRED"].includes(normalized)) {
-      return "error"
-    }
-
+    if (!normalized) return "pending"
+    if (normalized === "COMPLETED") return "captured"
+    if (normalized === "APPROVED") return "authorized"
+    if (["VOIDED", "CANCELLED"].includes(normalized)) return "canceled"
+    if (["CREATED", "SAVED", "PAYER_ACTION_REQUIRED"].includes(normalized)) return "pending"
+    if (["FAILED", "EXPIRED"].includes(normalized)) return "error"
     return "pending"
   }
 
   private async recordFailure(eventType: string, metadata?: Record<string, unknown>) {
     const paypal = this.resolvePayPalService()
-    if (!paypal) {
-      return
-    }
-
+    if (!paypal) return
     try {
       await paypal.recordPaymentLog(eventType, metadata)
       await paypal.recordAuditEvent(eventType, metadata)
       await paypal.recordMetric(eventType)
     } catch {
-      // ignore audit logging failures
+      // ignore
     }
   }
 
   private async recordSuccess(metricName: string) {
     const paypal = this.resolvePayPalService()
-    if (!paypal) {
-      return
-    }
-
+    if (!paypal) return
     try {
       await paypal.recordMetric(metricName)
     } catch {
-      // ignore metrics failures
+      // ignore
     }
   }
 
   private async recordPaymentEvent(eventType: string, metadata?: Record<string, unknown>) {
     const paypal = this.resolvePayPalService()
-    if (!paypal) {
-      return
-    }
-
+    if (!paypal) return
     try {
       await paypal.recordPaymentLog(eventType, metadata)
     } catch {
-      // ignore payment logging failures
+      // ignore
     }
   }
 
@@ -341,7 +288,6 @@ async resolveSettings() {
   ): Promise<CreateAccountHolderOutput> {
     const customerId = input.context?.customer?.id
     const externalId = customerId ? `paypal_${customerId}` : `paypal_${generateSessionId()}`
-
     return {
       id: externalId,
       data: {
@@ -351,13 +297,7 @@ async resolveSettings() {
     }
   }
 
-  /**
-   * Create a payment session when the customer selects PayPal.
-   * Must return an object containing an `id` and `data`.
-   */
-  async initiatePayment(
-    input: InitiatePaymentInput
-  ): Promise<InitiatePaymentOutput> {
+  async initiatePayment(input: InitiatePaymentInput): Promise<InitiatePaymentOutput> {
     const providerId = (input.data as Record<string, any> | undefined)?.provider_id
     try {
       const currencyOverride = await this.resolveCurrencyOverride()
@@ -368,8 +308,6 @@ async resolveSettings() {
         currencyCode,
         paypalCurrencyOverride: currencyOverride,
       })
-
-
       return {
         id: generateSessionId(),
         data: {
@@ -380,15 +318,6 @@ async resolveSettings() {
         },
       }
     } catch (error) {
-      console.error("[PayPal] provider initiate failed", {
-        provider_id: providerId,
-        payment_collection_id: (input.data as Record<string, any> | undefined)
-          ?.payment_collection_id,
-        cart_id: (input.data as Record<string, any> | undefined)?.cart_id,
-        amount: input.amount,
-        currency_code: input.currency_code,
-        error: this.serializeError(error),
-      })
       await this.recordFailure("initiate_failed", {
         error: this.serializeError(error),
         currency_code: input.currency_code,
@@ -409,9 +338,7 @@ async resolveSettings() {
       currencyCode,
       paypalCurrencyOverride: currencyOverride,
     })
-
     const providerId = (input.data as Record<string, any> | undefined)?.provider_id
-
     return {
       data: {
         ...(input.data || {}),
@@ -426,104 +353,152 @@ async resolveSettings() {
     input: AuthorizePaymentInput
   ): Promise<AuthorizePaymentOutput> {
     const { data, amount, currencyCode } = await this.normalizePaymentData(input)
-
     const existingPayPal = (data.paypal || {}) as Record<string, any>
-if (
-  existingPayPal.capture_id ||
-  existingPayPal.authorization_id ||
-  (data as any).authorized_at ||
-  (data as any).captured_at
-) {
-  const { additionalSettings } = await this.resolveSettings()
-  const paymentAction =
-    typeof additionalSettings.paymentAction === "string"
-      ? additionalSettings.paymentAction
-      : "capture"
-  const returnStatus = paymentAction === "authorize" ? "authorized" : "captured"
-  return {
-    status: returnStatus,
-    data: {
-      ...(input.data || {}),
-      ...(paymentAction === "authorize"
-        ? { authorized_at: new Date().toISOString() }
-        : { captured_at: new Date().toISOString() }),
-    },
-  }
-}
-
 
-    const requestId = this.getIdempotencyKey(input, "authorize")
-    let debugId: string | null = null
     const { additionalSettings } = await this.resolveSettings()
     const paymentActionRaw =
       typeof additionalSettings.paymentAction === "string"
         ? additionalSettings.paymentAction
         : "capture"
-    const orderIntent = paymentActionRaw === "authorize" ? "AUTHORIZE" : "CAPTURE"
-
-    try {
-      const { accessToken, base } = await this.getPayPalAccessToken()
-      const existingPayPal = (data.paypal || {}) as Record<string, any>
-      let orderId = String(existingPayPal.order_id || data.order_id || "")
-      let order: Record<string, any> | null = null
-      let authorization: any = null
+    const returnStatus = paymentActionRaw === "authorize" ? "authorized" : "captured"
+    const timestampKey = paymentActionRaw === "authorize" ? "authorized_at" : "captured_at"
+
+    // ── CASE 1: Already processed (has capture_id, authorization_id, or timestamp) ──
+    if (
+      existingPayPal.capture_id ||
+      existingPayPal.authorization_id ||
+      (data as any).authorized_at ||
+      (data as any).captured_at
+    ) {
+      console.info("[PayPal] authorizePayment: session already processed, returning", returnStatus)
+      return {
+        status: returnStatus,
+        data: {
+          ...(input.data || {}),
+          [timestampKey]: (data as any)[timestampKey] || new Date().toISOString(),
+        },
+      }
+    }
 
-      if (!orderId) {
-        const value = formatAmountForPayPal(amount, currencyCode || "EUR")
+    // ── CASE 2: Has order_id — fetch current status from PayPal ──────────────
+    // This is the KEY fix: capture-order already processed the payment but
+    // Medusa's cart/complete workflow calls authorizePayment again with the
+    // original session data (before capture-order wrote authorization_id).
+    // We fetch the live PayPal order to get the real status.
+    const orderId = String(existingPayPal.order_id || data.order_id || "")
+    if (orderId) {
+      try {
+        console.info("[PayPal] authorizePayment: fetching live order status for", orderId)
+        const order = await this.getOrderDetails(orderId)
+        const capture = order?.purchase_units?.[0]?.payments?.captures?.[0]
+        const authorization = order?.purchase_units?.[0]?.payments?.authorizations?.[0]
+
+        // Order was already captured or authorized by capture-order route
+        if (capture?.id || authorization?.id) {
+          console.info("[PayPal] authorizePayment: order already processed by PayPal, returning", returnStatus)
+          return {
+            status: returnStatus,
+            data: {
+              ...(input.data || {}),
+              paypal: {
+                ...existingPayPal,
+                order_id: orderId,
+                order,
+                authorization_id: authorization?.id || existingPayPal.authorization_id,
+                capture_id: capture?.id || existingPayPal.capture_id,
+              },
+              [timestampKey]: new Date().toISOString(),
+            },
+          }
+        }
 
-        const orderPayload = {
-          intent: orderIntent,
-          purchase_units: [
-            {
-              reference_id: data.cart_id || data.payment_collection_id || undefined,
-              custom_id: data.session_id || data.cart_id || data.payment_collection_id || undefined,
-              amount: {
-                currency_code: currencyCode || "EUR",
-                value,
+        // Order exists and is APPROVED — customer completed PayPal flow
+        // but capture-order hasn't run yet (edge case). Mark as authorized.
+        if (["APPROVED", "CREATED", "SAVED"].includes(String(order?.status || "").toUpperCase())) {
+          console.info("[PayPal] authorizePayment: order approved, marking authorized")
+          return {
+            status: "authorized",
+            data: {
+              ...(input.data || {}),
+              paypal: {
+                ...existingPayPal,
+                order_id: orderId,
+                order,
               },
+              authorized_at: new Date().toISOString(),
             },
-          ],
-          custom_id: data.session_id || data.cart_id || data.payment_collection_id || undefined,
+          }
         }
+      } catch (e: any) {
+        // Non-fatal — log and fall through to creating a new order below
+        console.warn("[PayPal] authorizePayment: order lookup failed:", e?.message)
+      }
+    }
 
-        const ppResp = await fetch(`${base}/v2/checkout/orders`, {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${accessToken}`,
-            "Content-Type": "application/json",
-            "PayPal-Request-Id": requestId,
+    // ── CASE 3: No order_id — create a new PayPal order ──────────────────────
+    // This handles the rare case where Medusa calls authorizePayment before
+    // the frontend has created a PayPal order (e.g. admin-created orders).
+    const requestId = this.getIdempotencyKey(input, "authorize")
+    let debugId: string | null = null
+    const orderIntent = paymentActionRaw === "authorize" ? "AUTHORIZE" : "CAPTURE"
+
+    try {
+      const { accessToken, base } = await this.getPayPalAccessToken()
+      const value = formatAmountForPayPal(amount, currencyCode || "EUR")
+
+      const orderPayload = {
+        intent: orderIntent,
+        purchase_units: [
+          {
+            reference_id: data.cart_id || data.payment_collection_id || undefined,
+            custom_id:
+              data.session_id || data.cart_id || data.payment_collection_id || undefined,
+            amount: {
+              currency_code: currencyCode || "EUR",
+              value,
+            },
           },
-          body: JSON.stringify(orderPayload),
-        })
+        ],
+        custom_id:
+          data.session_id || data.cart_id || data.payment_collection_id || undefined,
+      }
 
-        const ppText = await ppResp.text()
-        debugId = ppResp.headers.get("paypal-debug-id")
-        if (!ppResp.ok) {
-          throw new Error(
-            `PayPal create order error (${ppResp.status}): ${ppText}${
-              debugId ? ` debug_id=${debugId}` : ""
-            }`
-          )
-        }
+      const ppResp = await fetch(`${base}/v2/checkout/orders`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json",
+          "PayPal-Request-Id": requestId,
+        },
+        body: JSON.stringify(orderPayload),
+      })
 
-        order = JSON.parse(ppText) as Record<string, any>
-        orderId = String(order.id || "")
-      } else {
-        order = (await this.getOrderDetails(orderId)) as Record<string, any> | null
+      const ppText = await ppResp.text()
+      debugId = ppResp.headers.get("paypal-debug-id")
+      if (!ppResp.ok) {
+        throw new Error(
+          `PayPal create order error (${ppResp.status}): ${ppText}${
+            debugId ? ` debug_id=${debugId}` : ""
+          }`
+        )
       }
 
-      if (!order || !orderId) {
+      const order = JSON.parse(ppText) as Record<string, any>
+      const newOrderId = String(order.id || "")
+
+      if (!order || !newOrderId) {
         throw new Error("Unable to resolve PayPal order details for authorization.")
       }
 
       const existingAuthorization =
         order?.purchase_units?.[0]?.payments?.authorizations?.[0] || null
 
+      let authorization: any = null
       if (existingAuthorization) {
         authorization = order
       } else {
         const authorizeResp = await fetch(
-          `${base}/v2/checkout/orders/${orderId}/authorize`,
+          `${base}/v2/checkout/orders/${newOrderId}/authorize`,
           {
             method: "POST",
             headers: {
@@ -553,7 +528,7 @@ if (
 
       await this.recordSuccess("authorize_success")
       await this.recordPaymentEvent("authorize", {
-        order_id: orderId,
+        order_id: newOrderId,
         authorization_id: authorizationId,
         amount,
         currency_code: currencyCode,
@@ -566,7 +541,7 @@ if (
           ...(input.data || {}),
           paypal: {
             ...((input.data || {}).paypal as Record<string, unknown>),
-            order_id: orderId,
+            order_id: newOrderId,
             order: order || authorization,
             authorization_id: authorizationId,
             authorizations:
@@ -587,9 +562,7 @@ if (
     }
   }
 
-  async retrievePayment(
-    input: RetrievePaymentInput
-  ): Promise<RetrievePaymentOutput> {
+  async retrievePayment(input: RetrievePaymentInput): Promise<RetrievePaymentOutput> {
     const data = (input.data || {}) as Record<string, any>
     const paypalData = (data.paypal || {}) as Record<string, any>
     const orderId = String(paypalData.order_id || data.order_id || "")
@@ -614,9 +587,7 @@ if (
     }
   }
 
-  async getPaymentStatus(
-    input: GetPaymentStatusInput
-  ): Promise<GetPaymentStatusOutput> {
+  async getPaymentStatus(input: GetPaymentStatusInput): Promise<GetPaymentStatusOutput> {
     const data = (input.data || {}) as Record<string, any>
     const paypalData = (data.paypal || {}) as Record<string, any>
     const orderId = String(paypalData.order_id || data.order_id || "")
@@ -656,9 +627,7 @@ if (
     }
   }
 
-  async capturePayment(
-    input: CapturePaymentInput
-  ): Promise<CapturePaymentOutput> {
+  async capturePayment(input: CapturePaymentInput): Promise<CapturePaymentOutput> {
     const data = (input.data || {}) as Record<string, any>
     const paypalData = (data.paypal || {}) as Record<string, any>
     const orderId = String(paypalData.order_id || data.order_id || "")
@@ -704,9 +673,11 @@ if (
           },
         }
       }
+
       const resolvedIntent = String(
         order?.intent || paypalData.order?.intent || data.intent || ""
       ).toUpperCase()
+
       if (!authorizationId && resolvedIntent === "AUTHORIZE") {
         const authorizeResp = await fetch(
           `${base}/v2/checkout/orders/${orderId}/authorize`,
@@ -782,9 +753,7 @@ if (
       const capture = JSON.parse(ppText)
       const captureId =
         capture?.id || capture?.purchase_units?.[0]?.payments?.captures?.[0]?.id
-      const existingCaptures = Array.isArray(paypalData.captures)
-        ? paypalData.captures
-        : []
+      const existingCaptures = Array.isArray(paypalData.captures) ? paypalData.captures : []
       const captureEntry = {
         id: captureId,
         status: capture?.status,
@@ -827,9 +796,7 @@ if (
     }
   }
 
-  async refundPayment(
-    input: RefundPaymentInput
-  ): Promise<RefundPaymentOutput> {
+  async refundPayment(input: RefundPaymentInput): Promise<RefundPaymentOutput> {
     const data = (input.data || {}) as Record<string, any>
     const paypalData = (data.paypal || {}) as Record<string, any>
     const captureId = String(paypalData.capture_id || data.capture_id || "")
@@ -936,9 +903,7 @@ if (
     }
   }
 
-  async cancelPayment(
-    input: CancelPaymentInput
-  ): Promise<CancelPaymentOutput> {
+  async cancelPayment(input: CancelPaymentInput): Promise<CancelPaymentOutput> {
     const data = (input.data || {}) as Record<string, any>
     const paypalData = (data.paypal || {}) as Record<string, any>
     const orderId = String(paypalData.order_id || data.order_id || "")
@@ -985,7 +950,6 @@ if (
         await this.recordPaymentEvent("void", {
           order_id: orderId,
           authorization_id: authorizationId,
-          request_id: requestId,
         })
       } else if (captureId) {
         const { accessToken, base } = await this.getPayPalAccessToken()
@@ -1024,12 +988,6 @@ if (
         paypalData.refunds = [...existingRefunds, refundEntry]
 
         await this.recordSuccess("cancel_refund_success")
-        await this.recordPaymentEvent("cancel_refund", {
-          order_id: orderId,
-          capture_id: captureId,
-          refund_id: refund?.id,
-          request_id: requestId,
-        })
       }
 
       return {
@@ -1058,16 +1016,10 @@ if (
     }
   }
 
-  async deletePayment(
-    _input: DeletePaymentInput
-  ): Promise<DeletePaymentOutput> {
+  async deletePayment(_input: DeletePaymentInput): Promise<DeletePaymentOutput> {
     return { data: {} }
   }
 
-  /**
-   * Required by AbstractPaymentProvider in Medusa v2.
-   * This is used by /hooks/payment/{identifier}_{providerId}
-   */
   async getWebhookActionAndData(
     payload: ProviderWebhookPayload["payload"]
   ): Promise<WebhookActionResult> {