@easypayment/medusa-paypal 0.4.7 → 0.4.8

package/src/api/store/paypal/config/route.ts

@@ -1,103 +1,103 @@
-import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
-import type PayPalModuleService from "../../../../modules/paypal/service"
-import {
-  getPayPalCurrencyCompatibility,
-  getPayPalSupportedCurrencies,
-  normalizeCurrencyCode,
-} from "../../../../modules/paypal/utils/currencies"
-
-export async function GET(req: MedusaRequest, res: MedusaResponse) {
-  const paypal = req.scope.resolve<PayPalModuleService>("paypal_onboarding")
-  try {
-    const creds = await paypal.getActiveCredentials()
-    const apiDetails = await paypal.getApiDetails().catch(() => null)
-    const client_token = await paypal.generateClientToken({ locale: "en_US" }).catch(() => "")
-    const cartId = (req.query?.cart_id as string) || ""
-    const query = req.scope.resolve("query")
-    let currency = normalizeCurrencyCode(
-      apiDetails?.apiDetails?.currency_code || process.env.PAYPAL_CURRENCY || "EUR"
-    )
-    if (cartId) {
-      const { data: carts } = await query.graph({
-        entity: "cart",
-        fields: ["id", "currency_code", "region.currency_code"],
-        filters: { id: cartId },
-      })
-      const cart = carts?.[0]
-      if (cart) {
-        currency = normalizeCurrencyCode(
-          cart.region?.currency_code || cart.currency_code || currency
-        )
-      }
-    }
-    const compatibility = getPayPalCurrencyCompatibility({
-      currencyCode: currency,
-      paypalCurrencyOverride:
-        apiDetails?.apiDetails?.currency_code || process.env.PAYPAL_CURRENCY,
-    })
-
-    // Read settings so frontend SDK mirrors admin controls.
-    const settings = await paypal.getSettings().catch(() => ({}))
-    const data =
-      settings && typeof settings === "object" && "data" in settings
-        ? ((settings as any).data || {})
-        : {}
-
-    const additionalSettings =
-      data && typeof data === "object"
-        ? ((data as Record<string, any>).additional_settings || {})
-        : {}
-
-    const paypalSettings =
-      data && typeof data === "object"
-        ? ((data as Record<string, any>).paypal_settings || {})
-        : {}
-
-    const paymentAction =
-      typeof additionalSettings.paymentAction === "string"
-        ? additionalSettings.paymentAction
-        : "capture"
-
-    // P1 — enforce disable at API level: return 403 when admin disables PayPal wallet
-    if (paypalSettings.enabled === false) {
-      return res.status(403).json({ message: "PayPal is currently disabled." })
-    }
-
-
-    // P2 — read advanced card payments settings
-    const advancedCardSettings =
-      data && typeof data === "object"
-        ? ((data as Record<string, any>).advanced_card_payments || {})
-        : {}
-
-    const cardEnabled: boolean = advancedCardSettings.enabled !== false
-
-    const cardThreeDS =
-      typeof advancedCardSettings.threeDS === "string"
-        ? advancedCardSettings.threeDS
-        : "when_required"
-
-    return res.json({
-      environment: creds.environment,
-      client_id: creds.client_id,
-      currency: compatibility.currency,
-      currency_supported: compatibility.supported,
-      currency_errors: compatibility.errors,
-      supported_currencies: getPayPalSupportedCurrencies(),
-      client_token,
-      intent: paymentAction,
-      paypal_enabled: paypalSettings.enabled ?? true,
-      paypal_title: paypalSettings.title || "PayPal",
-      card_enabled: cardEnabled,
-      card_title: advancedCardSettings.title || "Credit or Debit Card",
-      card_three_ds: cardThreeDS,                                          // ← added
-      button_color: paypalSettings.buttonColor || "gold",
-      button_shape: paypalSettings.buttonShape || "rect",
-      button_width: paypalSettings.buttonWidth || "responsive",
-      button_height: paypalSettings.buttonHeight ?? 45,
-      button_label: paypalSettings.buttonLabel || "paypal",
-    })
-  } catch (e: any) {
-    return res.status(500).json({ message: e?.message || "Failed to load PayPal config" })
-  }
+import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import type PayPalModuleService from "../../../../modules/paypal/service"
+import {
+  getPayPalCurrencyCompatibility,
+  getPayPalSupportedCurrencies,
+  normalizeCurrencyCode,
+} from "../../../../modules/paypal/utils/currencies"
+
+export async function GET(req: MedusaRequest, res: MedusaResponse) {
+  const paypal = req.scope.resolve<PayPalModuleService>("paypal_onboarding")
+  try {
+    const creds = await paypal.getActiveCredentials()
+    const apiDetails = await paypal.getApiDetails().catch(() => null)
+    const client_token = await paypal.generateClientToken({ locale: "en_US" }).catch(() => "")
+    const cartId = (req.query?.cart_id as string) || ""
+    const query = req.scope.resolve("query")
+    let currency = normalizeCurrencyCode(
+      apiDetails?.apiDetails?.currency_code || process.env.PAYPAL_CURRENCY || "EUR"
+    )
+    if (cartId) {
+      const { data: carts } = await query.graph({
+        entity: "cart",
+        fields: ["id", "currency_code", "region.currency_code"],
+        filters: { id: cartId },
+      })
+      const cart = carts?.[0]
+      if (cart) {
+        currency = normalizeCurrencyCode(
+          cart.region?.currency_code || cart.currency_code || currency
+        )
+      }
+    }
+    const compatibility = getPayPalCurrencyCompatibility({
+      currencyCode: currency,
+      paypalCurrencyOverride:
+        apiDetails?.apiDetails?.currency_code || process.env.PAYPAL_CURRENCY,
+    })
+
+    // Read settings so frontend SDK mirrors admin controls.
+    const settings = await paypal.getSettings().catch(() => ({}))
+    const data =
+      settings && typeof settings === "object" && "data" in settings
+        ? ((settings as any).data || {})
+        : {}
+
+    const additionalSettings =
+      data && typeof data === "object"
+        ? ((data as Record<string, any>).additional_settings || {})
+        : {}
+
+    const paypalSettings =
+      data && typeof data === "object"
+        ? ((data as Record<string, any>).paypal_settings || {})
+        : {}
+
+    const paymentAction =
+      typeof additionalSettings.paymentAction === "string"
+        ? additionalSettings.paymentAction
+        : "capture"
+
+    // P1 — enforce disable at API level: return 403 when admin disables PayPal wallet
+    if (paypalSettings.enabled === false) {
+      return res.status(403).json({ message: "PayPal is currently disabled." })
+    }
+
+
+    // P2 — read advanced card payments settings
+    const advancedCardSettings =
+      data && typeof data === "object"
+        ? ((data as Record<string, any>).advanced_card_payments || {})
+        : {}
+
+    const cardEnabled: boolean = advancedCardSettings.enabled !== false
+
+    const cardThreeDS =
+      typeof advancedCardSettings.threeDS === "string"
+        ? advancedCardSettings.threeDS
+        : "when_required"
+
+    return res.json({
+      environment: creds.environment,
+      client_id: creds.client_id,
+      currency: compatibility.currency,
+      currency_supported: compatibility.supported,
+      currency_errors: compatibility.errors,
+      supported_currencies: getPayPalSupportedCurrencies(),
+      client_token,
+      intent: paymentAction,
+      paypal_enabled: paypalSettings.enabled ?? true,
+      paypal_title: paypalSettings.title || "PayPal",
+      card_enabled: cardEnabled,
+      card_title: advancedCardSettings.title || "Credit or Debit Card",
+      card_three_ds: cardThreeDS,                                          // ← added
+      button_color: paypalSettings.buttonColor || "gold",
+      button_shape: paypalSettings.buttonShape || "rect",
+      button_width: paypalSettings.buttonWidth || "responsive",
+      button_height: paypalSettings.buttonHeight ?? 45,
+      button_label: paypalSettings.buttonLabel || "paypal",
+    })
+  } catch (e: any) {
+    return res.status(500).json({ message: e?.message || "Failed to load PayPal config" })
+  }
 }

package/src/api/store/paypal/create-order/route.ts

@@ -1,6 +1,6 @@
 import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
 import { randomUUID } from "crypto"
-import { getCurrencyExponent, formatAmountForPayPal } from "../../../../modules/paypal/utils/amounts"
+import { getCurrencyExponent } from "../../../../modules/paypal/utils/amounts"
 import {
   assertPayPalCurrencySupported,
   normalizeCurrencyCode,
@@ -101,117 +101,6 @@ function resolveCancelUrl(req: MedusaRequest) {
   return `${configured.replace(/\/$/, "")}/cart`
 }
 
-// ---------------------------------------------------------------------------
-// buildPayPalLineItems
-//
-// This function mirrors the WooCommerce PayPal plugin reconciliation logic:
-//
-//  1. Convert each item's line_subtotal from MINOR units (cents) to MAJOR
-//     units (euros/dollars) using the currency exponent factor.
-//     e.g. 1000 cents ÷ 100 = €10.00
-//
-//  2. Compute unit_amount = line_subtotal_major / quantity  (pre-discount
-//     price per unit, rounded to currency decimal places).
-//
-//  3. Sum all (unit_amount × quantity) — this is "roundedItemSum".
-//
-//  4. Compare roundedItemSum with subtotalMajor (cart.subtotal in major
-//     units, already correct from Medusa). If there is any rounding
-//     discrepancy (e.g. ±0.01), insert a single "Line Item Amount Offset"
-//     item worth exactly `diff` to absorb it.
-//     After this: sum(items) === subtotalMajor exactly.
-//
-//  5. breakdown.item_total is ALWAYS set to subtotalMajor — never modified.
-//     The offset item ensures the items array sums to match it.
-//
-//  6. If the final breakdownSum (item_total + shipping + tax - discount)
-//     does not match cart.total, absorb the gap via shipping_discount
-//     (if gap < 0) or by adding to tax_total (if gap > 0).
-//     This guarantees the PayPal order total always matches cart.total exactly.
-// ---------------------------------------------------------------------------
-function buildPayPalLineItems(
-  lineItems: any[],
-  subtotalMajor: number,
-  currency: string,
-  exponent: number,
-  sendItemDetails: boolean
-): { items: any[]; adjustedItemTotal: number } {
-  if (!sendItemDetails || lineItems.length === 0) {
-    return { items: [], adjustedItemTotal: subtotalMajor }
-  }
-
-  // factor = 100 for EUR/USD, 1 for JPY, 1000 for KWD, etc.
-  const factor = Math.pow(10, exponent)
-
-  // Step 1 & 2: Build raw items with proper unit amounts
-  const rawItems = lineItems
-    .map((item: any) => {
-      const quantity = Number(item?.quantity || 0)
-      if (!quantity || Number.isNaN(quantity)) return null
-
-      // item.subtotal is in MINOR units (cents) — must divide by factor
-      const lineSubtotalMinor = Number(
-        item?.subtotal ?? Number(item?.unit_price || 0) * quantity
-      )
-      const lineSubtotalMajor = lineSubtotalMinor / factor
-
-      // unit price per item, rounded to currency decimal places
-      const unitAmount = parseFloat((lineSubtotalMajor / quantity).toFixed(exponent))
-
-      if (Number.isNaN(unitAmount)) return null
-
-      return {
-        quantity,
-        unitAmount,
-        paypalItem: {
-          name: String(item?.title || "Item").slice(0, 127),
-          quantity: String(quantity),
-          unit_amount: {
-            currency_code: currency,
-            value: unitAmount.toFixed(exponent),
-          },
-        },
-      }
-    })
-    .filter(Boolean) as Array<{ quantity: number; unitAmount: number; paypalItem: any }>
-
-  if (rawItems.length === 0) {
-    return { items: [], adjustedItemTotal: subtotalMajor }
-  }
-
-  // Step 3: Sum of (unit_amount × quantity) after rounding
-  const roundedItemSum = rawItems.reduce(
-    (sum, item) => sum + item.unitAmount * item.quantity,
-    0
-  )
-  const roundedItemSumFixed = parseFloat(roundedItemSum.toFixed(exponent))
-
-  // Step 4: Calculate rounding difference
-  // diff = how much to add as an offset item so that:
-  //   roundedItemSumFixed + diff === subtotalMajor
-  const diff = parseFloat((subtotalMajor - roundedItemSumFixed).toFixed(exponent))
-
-  const finalItems = rawItems.map((item) => item.paypalItem)
-
-  if (Math.abs(diff) > 0.000001) {
-    // Insert a tiny offset item to absorb the rounding gap.
-    // After this: sum(finalItems unit_amount × quantity) === subtotalMajor exactly.
-    finalItems.push({
-      name: "Line Item Amount Offset",
-      quantity: "1",
-      unit_amount: {
-        currency_code: currency,
-        value: diff.toFixed(exponent),
-      },
-    })
-    // NOTE: adjustedItemTotal stays as subtotalMajor — do NOT add diff here.
-    // The offset item brings the items sum UP to subtotalMajor.
-    // Adding diff to adjustedItemTotal would cause a double-count.
-  }
-
-  return { items: finalItems, adjustedItemTotal: subtotalMajor }
-}
-
 export async function POST(req: MedusaRequest, res: MedusaResponse) {
   const paypal = req.scope.resolve<PayPalModuleService>("paypal_onboarding")
   let debugId: string | null = null
@@ -230,12 +119,9 @@ export async function POST(req: MedusaRequest, res: MedusaResponse) {
       return res.json({ id: existingOrderId })
     }
 
-    // -------------------------------------------------------------------------
-    // Fetch cart via Query Graph
-    // All monetary fields returned by Medusa are in MAJOR units (e.g. euros)
-    // EXCEPT item-level fields (item.unit_price, item.subtotal, item.total)
-    // which are in MINOR units (cents). This is the root cause of the bug.
-    // -------------------------------------------------------------------------
+    /**
+     * ✅ Medusa v2 cart retrieval via Query Graph
+     */
     const query = req.scope.resolve("query")
 
     const { data } = await query.graph({
@@ -289,11 +175,10 @@ export async function POST(req: MedusaRequest, res: MedusaResponse) {
         : "when_required"
 
     const threeDsMethod: string | null = isCardPayment
-      ? threeDsRaw === "always"
-        ? "SCA_ALWAYS"
-        : "SCA_WHEN_REQUIRED"
+      ? (threeDsRaw === "always"
+          ? "SCA_ALWAYS"
+          : "SCA_WHEN_REQUIRED")
       : null
-
     const configuredCurrency =
       typeof apiDetails.currency_code === "string"
         ? normalizeCurrencyCode(apiDetails.currency_code)
@@ -308,18 +193,7 @@ export async function POST(req: MedusaRequest, res: MedusaResponse) {
     })
 
     const exponent = getCurrencyExponent(currency)
-
-    // -------------------------------------------------------------------------
-    // Cart-level totals — these are already in MAJOR units (euros/dollars)
-    // e.g. cart.total = 20 means €20.00
-    // -------------------------------------------------------------------------
     const totalMajor = Number(cart.total || 0)
-    const subtotalMajor = Number(cart.subtotal || 0)
-    const shippingMajor = Number(cart.shipping_total || 0)
-    const taxMajor = Number(cart.tax_total || 0)
-    const discountMajor = Number(cart.discount_total || 0)
-    const giftCardMajor = Number(cart.gift_card_total || 0)
-
     const value = totalMajor.toFixed(exponent)
 
     const paymentActionRaw =
@@ -327,7 +201,6 @@ export async function POST(req: MedusaRequest, res: MedusaResponse) {
         ? additionalSettings.paymentAction
         : "capture"
     const paymentAction = paymentActionRaw === "authorize" ? "AUTHORIZE" : "CAPTURE"
-
     const brandName =
       typeof additionalSettings.brandName === "string"
         ? additionalSettings.brandName
@@ -358,15 +231,14 @@ export async function POST(req: MedusaRequest, res: MedusaResponse) {
         ? additionalSettings.invoicePrefix
         : ""
     const invoiceId = `${invoicePrefix}${cart.id}`.trim() || cart.id
-
     const returnUrl =
-      typeof apiDetails.storefront_url === "string" && apiDetails.storefront_url.trim()
+      (typeof apiDetails.storefront_url === "string" && apiDetails.storefront_url.trim()
         ? `${apiDetails.storefront_url.replace(/\/$/, "")}/checkout`
-        : resolveReturnUrl(req)
+        : resolveReturnUrl(req))
     const cancelUrl =
-      typeof apiDetails.storefront_url === "string" && apiDetails.storefront_url.trim()
+      (typeof apiDetails.storefront_url === "string" && apiDetails.storefront_url.trim()
         ? `${apiDetails.storefront_url.replace(/\/$/, "")}/cart`
-        : resolveCancelUrl(req)
+        : resolveCancelUrl(req))
 
     const applicationContext: Record<string, any> = {
       ...(brandName ? { brand_name: brandName } : {}),
@@ -376,26 +248,72 @@ export async function POST(req: MedusaRequest, res: MedusaResponse) {
       ...(cancelUrl ? { cancel_url: cancelUrl } : {}),
     }
 
-    // -------------------------------------------------------------------------
-    // Build line items with correct minor→major conversion and reconciliation.
-    // See buildPayPalLineItems() above for full explanation.
-    // -------------------------------------------------------------------------
+    const subtotalMajor = Number(cart.subtotal || 0)
+    const shippingMajor = Number(cart.shipping_total || 0)
+    const taxMajor = Number(cart.tax_total || 0)
+    const discountMajor = Number(cart.discount_total || 0)
+    const giftCardMajor = Number(cart.gift_card_total || 0)
     const lineItems = Array.isArray((cart as any).items) ? (cart as any).items : []
+    // factor converts MINOR units (cents) → MAJOR units (euros)
+    // e.g. item.subtotal=1000, factor=100 → €10.00
+    const factor = Math.pow(10, exponent)
+
+    const purchaseItemsRaw = sendItemDetails
+      ? lineItems
+          .map((item: any) => {
+            const quantity = Number(item?.quantity || 0)
+            // item.subtotal is in MINOR units (cents) — divide by factor to get euros
+            const lineSubtotalMinor = Number(
+              item?.subtotal ?? (Number(item?.unit_price || 0) * quantity)
+            )
+            const lineSubtotalMajor = lineSubtotalMinor / factor
+            const unitAmount =
+              quantity > 0 ? parseFloat((lineSubtotalMajor / quantity).toFixed(exponent)) : 0
+
+            if (!quantity || Number.isNaN(quantity) || Number.isNaN(unitAmount)) {
+              return null
+            }
+
+            return {
+              quantity,
+              unitAmount,
+              paypalItem: {
+                name: String(item?.title || "Item").slice(0, 127),
+                quantity: String(Math.max(1, quantity)),
+                unit_amount: {
+                  currency_code: currency,
+                  value: unitAmount.toFixed(exponent),
+                },
+              },
+            }
+          })
+          .filter(Boolean)
+      : []
 
-    const { items: finalPurchaseItems, adjustedItemTotal } = buildPayPalLineItems(
-      lineItems,
-      subtotalMajor,
-      currency,
-      exponent,
-      sendItemDetails
+    const roundedItemSum = purchaseItemsRaw.reduce(
+      (sum: number, item: any) => sum + item.unitAmount * item.quantity,
+      0
     )
+    const roundedItemSumFixed = parseFloat(roundedItemSum.toFixed(exponent))
+    const diff = parseFloat((subtotalMajor - roundedItemSumFixed).toFixed(exponent))
+
+    const finalPurchaseItems = purchaseItemsRaw.map((item: any) => item.paypalItem)
+    // adjustedItemTotal stays as subtotalMajor — the offset item absorbs the rounding gap
+    // so that sum(unit_amount × quantity) === subtotalMajor exactly
+    const adjustedItemTotal = subtotalMajor
+
+    if (Math.abs(diff) > 0.000001 && sendItemDetails && finalPurchaseItems.length > 0) {
+      finalPurchaseItems.push({
+        name: "Line Item Amount Offset",
+        quantity: "1",
+        unit_amount: {
+          currency_code: currency,
+          value: diff.toFixed(exponent),
+        },
+      })
+    }
 
-    // -------------------------------------------------------------------------
-    // Build the breakdown object.
-    // PayPal rule: item_total + shipping + tax_total - discount - shipping_discount === value
-    // -------------------------------------------------------------------------
     const breakdown: Record<string, any> = {}
-
     if (adjustedItemTotal > 0) {
       breakdown.item_total = {
         currency_code: currency,
@@ -415,8 +333,6 @@ export async function POST(req: MedusaRequest, res: MedusaResponse) {
       }
     }
 
-    // Discounts and gift cards — only include if we are also sending items,
-    // otherwise PayPal rejects breakdown with discount but no items.
     const discountValue = discountMajor + giftCardMajor
     if (discountValue > 0 && finalPurchaseItems.length > 0) {
       breakdown.discount = {
@@ -425,12 +341,6 @@ export async function POST(req: MedusaRequest, res: MedusaResponse) {
       }
     }
 
-    // -------------------------------------------------------------------------
-    // Final reconciliation: ensure breakdown sums exactly to cart total.
-    // If there is a gap (can happen due to rounding across multiple fields),
-    // absorb it via shipping_discount (if we over-counted) or tax_total
-    // (if we under-counted). This is exactly what WooCommerce does.
-    // -------------------------------------------------------------------------
     const breakdownSum = parseFloat(
       (adjustedItemTotal + shippingMajor + taxMajor - discountValue).toFixed(exponent)
     )
@@ -439,14 +349,13 @@ export async function POST(req: MedusaRequest, res: MedusaResponse) {
       const gap = parseFloat((totalMajor - breakdownSum).toFixed(exponent))
 
       if (gap > 0) {
-        // We under-counted — add the gap to tax_total
-        const existingTax = Number(breakdown.tax_total?.value || 0)
         breakdown.tax_total = {
           currency_code: currency,
-          value: parseFloat((existingTax + gap).toFixed(exponent)).toFixed(exponent),
+          value: parseFloat(
+            ((Number(breakdown.tax_total?.value || 0) + gap).toFixed(exponent))
+          ).toFixed(exponent),
         }
       } else {
-        // We over-counted — add shipping_discount to bring total down
         breakdown.shipping_discount = {
           currency_code: currency,
           value: Math.abs(gap).toFixed(exponent),
@@ -462,14 +371,6 @@ export async function POST(req: MedusaRequest, res: MedusaResponse) {
 
     const requestId = resolveIdempotencyKey(req, "create-order", `pp-create-${cart.id}`)
 
-    // Log what we are sending to PayPal for debugging
-    console.info("[PayPal] create-order payload", {
-      cart_id: cart.id,
-      value,
-      breakdown,
-      item_count: finalPurchaseItems.length,
-    })
-
     const ppResp = await fetch(`${base}/v2/checkout/orders`, {
       method: "POST",
       headers: {
@@ -526,7 +427,7 @@ export async function POST(req: MedusaRequest, res: MedusaResponse) {
 
     await attachPayPalOrderToSession(req, cart.id, order.id)
 
-    console.info("[PayPal] create-order success", {
+    console.info("[PayPal] create-order", {
       cart_id: cart.id,
       order_id: order.id,
       request_id: requestId,
@@ -558,4 +459,4 @@ export async function POST(req: MedusaRequest, res: MedusaResponse) {
         : 500
     return res.status(status).json({ message })
   }
-}
+}

package/src/api/store/paypal/settings/route.ts

@@ -1,19 +1,19 @@
-import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
-import type PayPalModuleService from "../../../../modules/paypal/service"
-
-export async function GET(req: MedusaRequest, res: MedusaResponse) {
-  const paypal = req.scope.resolve<PayPalModuleService>("paypal_onboarding")
-  try {
-    const settings = await paypal.getSettings()
-    const data = (settings?.data || {}) as Record<string, any>
-    const additionalSettings = (data.additional_settings || {}) as Record<string, any>
-    const advancedCard = (data.advanced_card_payments || {}) as Record<string, any>
-
-    return res.json({
-      paymentAction: additionalSettings.paymentAction === "authorize" ? "authorize" : "capture",
-      advancedCardEnabled: advancedCard.enabled === true,
-    })
-  } catch (e: any) {
-    return res.status(500).json({ message: e?.message || "Failed to load PayPal settings" })
-  }
-}
+import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import type PayPalModuleService from "../../../../modules/paypal/service"
+
+export async function GET(req: MedusaRequest, res: MedusaResponse) {
+  const paypal = req.scope.resolve<PayPalModuleService>("paypal_onboarding")
+  try {
+    const settings = await paypal.getSettings()
+    const data = (settings?.data || {}) as Record<string, any>
+    const additionalSettings = (data.additional_settings || {}) as Record<string, any>
+    const advancedCard = (data.advanced_card_payments || {}) as Record<string, any>
+
+    return res.json({
+      paymentAction: additionalSettings.paymentAction === "authorize" ? "authorize" : "capture",
+      advancedCardEnabled: advancedCard.enabled === true,
+    })
+  } catch (e: any) {
+    return res.status(500).json({ message: e?.message || "Failed to load PayPal settings" })
+  }
+}