@easypayment/medusa-paypal 0.6.7 → 0.6.9

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

@@ -24,7 +24,7 @@ import type {
   ProviderWebhookPayload,
   WebhookActionResult,
 } from "@medusajs/framework/types"
-import { formatAmountForPayPal } from "../utils/amounts"
+import { formatAmountForPayPal, getCurrencyExponent } from "../utils/amounts"
 import {
   assertPayPalCurrencySupported,
   normalizeCurrencyCode,
@@ -709,12 +709,13 @@ class PayPalPaymentProvider extends AbstractPaymentProvider<Options> {
         data.is_final_capture ??
         data.final_capture ??
         undefined
+      const captureExponent = getCurrencyExponent(currencyCode || "EUR")
       const capturePayload =
         amount > 0
           ? {
               amount: {
                 currency_code: currencyCode || "EUR",
-                value: formatAmountForPayPal(amount, currencyCode || "EUR"),
+                value: amount.toFixed(captureExponent),
               },
               ...(typeof isFinalCapture === "boolean"
                 ? { is_final_capture: isFinalCapture }
@@ -816,17 +817,36 @@ class PayPalPaymentProvider extends AbstractPaymentProvider<Options> {
     }
 
     const requestId = this.getIdempotencyKey(input, `refund-${captureId}`)
-    const { amount, currencyCode } = await this.normalizePaymentData(input)
+
+    // ── IMPORTANT: Use input.amount (major units e.g. 20.00) NOT data.amount ──
+    // Medusa v2 passes the refund amount via input.amount in major currency units.
+    // data.amount is the original session amount in minor units (e.g. 2000 cents).
+    // formatAmountForPayPal divides by 100, so using data.amount would give 0.20
+    // instead of 20.00. We must use input.amount directly and format it as-is.
+    const currencyOverride = await this.resolveCurrencyOverride()
+    const currencyCode = normalizeCurrencyCode(
+      data.currency_code || currencyOverride || "EUR"
+    )
+
+    // input.amount is already in major units (e.g. 20.00 EUR)
+    // Just convert to string with correct decimal places
+    // getCurrencyExponent is already available via the amounts utils
+    const exponent = currencyCode.toUpperCase() === "JPY" ? 0
+      : ["BHD", "JOD", "KWD", "OMR", "TND"].includes(currencyCode.toUpperCase()) ? 3
+      : 2
+    const refundAmount = Number(input.amount ?? 0)
+    const refundValue = refundAmount > 0 ? refundAmount.toFixed(exponent) : null
+
     let debugId: string | null = null
 
     try {
       const { accessToken, base } = await this.getPayPalAccessToken()
       const refundPayload: Record<string, any> =
-        amount > 0
+        refundValue
           ? {
               amount: {
                 currency_code: currencyCode || "EUR",
-                value: formatAmountForPayPal(amount, currencyCode || "EUR"),
+                value: refundValue,
               },
             }
           : {}
@@ -870,7 +890,7 @@ class PayPalPaymentProvider extends AbstractPaymentProvider<Options> {
       await this.recordPaymentEvent("refund", {
         capture_id: captureId,
         refund_id: refund?.id,
-        amount,
+        amount: refundAmount,
         currency_code: currencyCode,
         request_id: requestId,
         reason: refundReason,

package/src/subscribers/paypal-order-invoice.ts

@@ -1,15 +1,12 @@
-import type { MedusaContainer } from "@medusajs/framework/types"
+import type { SubscriberArgs, SubscriberConfig } from "@medusajs/framework"
 import type PayPalModuleService from "../modules/paypal/service"
 import { getPayPalAccessToken } from "../modules/paypal/utils/paypal-auth"
 import { isPayPalProviderId } from "../modules/paypal/utils/provider-ids"
 
-export default async function paypalOrderInvoiceSubscriber({
+export default async function paypalOrderInvoiceHandler({
   event,
   container,
-}: {
-  event: { data: { id: string } }
-  container: MedusaContainer
-}) {
+}: SubscriberArgs<{ id: string }>) {
   const orderId = event?.data?.id
   if (!orderId) return
 
@@ -27,6 +24,7 @@ export default async function paypalOrderInvoiceSubscriber({
         "payment_collections.payment_sessions.data",
         "payment_collections.payment_sessions.provider_id",
         "payment_collections.payment_sessions.status",
+        "payment_collections.payment_sessions.created_at",
       ],
       filters: { id: orderId },
     })
@@ -35,21 +33,29 @@ export default async function paypalOrderInvoiceSubscriber({
     if (!order) return
 
     // Find the PayPal session
-    const sessions = order.payment_collections?.flatMap(
+    const sessions = (order.payment_collections || []).flatMap(
       (pc: any) => pc.payment_sessions || []
-    ) || []
+    )
 
     const paypalSession = sessions
       .filter((s: any) => isPayPalProviderId(s.provider_id))
-      .sort((a: any, b: any) =>
-        new Date(b.created_at || 0).getTime() - new Date(a.created_at || 0).getTime()
+      .sort(
+        (a: any, b: any) =>
+          new Date(b.created_at || 0).getTime() -
+          new Date(a.created_at || 0).getTime()
       )[0]
 
-    if (!paypalSession) return
+    if (!paypalSession) {
+      console.info("[PayPal] invoice subscriber: no PayPal session found for order", orderId)
+      return
+    }
 
-    const paypalData = (paypalSession.data?.paypal || {}) as Record<string, any>
+    const paypalData = ((paypalSession.data || {}).paypal || {}) as Record<string, any>
     const paypalOrderId = String(paypalData.order_id || "")
-    if (!paypalOrderId) return
+    if (!paypalOrderId) {
+      console.info("[PayPal] invoice subscriber: no PayPal order_id in session for order", orderId)
+      return
+    }
 
     // Get invoice prefix from settings
     const settings = await paypal.getSettings().catch(() => ({}))
@@ -64,7 +70,7 @@ export default async function paypalOrderInvoiceSubscriber({
         : ""
 
     // Build industry-standard invoice ID: prefix + order display_id
-    // e.g. "WC-139" or "ORD-139"
+    // e.g. "WC-140" or "ORD-140"
     const displayId = String(order.display_id || "")
     const invoiceId = `${invoicePrefix}${displayId}`.trim()
     if (!invoiceId) return
@@ -90,20 +96,20 @@ export default async function paypalOrderInvoiceSubscriber({
 
     if (patchResp.ok || patchResp.status === 204) {
       console.info(
-        `[PayPal] invoice_id updated to "${invoiceId}" for PayPal order ${paypalOrderId} (Medusa order ${orderId})`
+        `[PayPal] invoice_id updated to "${invoiceId}" for PayPal order ${paypalOrderId} (Medusa order #${displayId})`
       )
     } else {
       const text = await patchResp.text().catch(() => "")
       console.warn(
-        `[PayPal] invoice_id patch failed (${patchResp.status}) for order ${paypalOrderId}: ${text}`
+        `[PayPal] invoice_id patch failed (${patchResp.status}) for PayPal order ${paypalOrderId}: ${text}`
       )
     }
   } catch (e: any) {
     // Non-fatal — never block order placement
-    console.warn("[PayPal] paypalOrderInvoiceSubscriber error:", e?.message || e)
+    console.warn("[PayPal] paypalOrderInvoiceHandler error:", e?.message || e)
   }
 }
 
-export const config = {
+export const config: SubscriberConfig = {
   event: "order.placed",
 }