@easypayment/medusa-paypal 0.2.7 → 0.2.8

package/src/api/store/paypal-complete/route.ts

@@ -1,46 +1,76 @@
-import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
-import { Pool } from "pg"
-
-export async function POST(req: MedusaRequest, res: MedusaResponse) {
-  const { cart_id } = req.body as { cart_id: string; order_id?: string; capture_id?: string }
-
-  if (!cart_id) {
-    return res.status(400).json({ error: "cart_id is required" })
-  }
-
-  const pool = new Pool({ connectionString: process.env.DATABASE_URL })
-  try {
-    // Only update authorized_at — do NOT touch paypal object
-    // capture_id and order_id are already correctly saved by capture-order route
-    const { rows } = await pool.query(
-      `UPDATE payment_session
-       SET status = 'authorized',
-           data   = data || jsonb_build_object('authorized_at', $1::text)
-       WHERE id = (
-         SELECT ps.id
-         FROM payment_session ps
-         JOIN payment_collection pc ON ps.payment_collection_id = pc.id
-         JOIN cart_payment_collection cpc ON cpc.payment_collection_id = pc.id
-         WHERE cpc.cart_id = $2
-           AND ps.provider_id LIKE '%paypal%'
-         ORDER BY ps.created_at DESC
-         LIMIT 1
-       )
-       RETURNING id, status`,
-      [new Date().toISOString(), cart_id]
-    )
-
-    console.log("[paypal-complete] session authorized:", rows)
-
-    if (!rows.length) {
-      return res.status(400).json({ error: "No PayPal payment session found for cart" })
-    }
-
-    return res.json({ success: true, session_id: rows[0].id })
-  } catch (e: any) {
-    console.error("[paypal-complete] error:", e?.message || e)
-    return res.status(500).json({ error: e?.message || "Internal error" })
-  } finally {
-    await pool.end()
-  }
+import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import type { IPaymentModuleService } from "@medusajs/framework/types"
+import { Modules } from "@medusajs/framework/utils"
+import type PayPalModuleService from "../../../modules/paypal/service"
+
+export async function POST(req: MedusaRequest, res: MedusaResponse) {
+  const { cart_id } = req.body as { cart_id: string }
+
+  if (!cart_id) {
+    return res.status(400).json({ error: "cart_id is required" })
+  }
+
+  try {
+    // Step 1 — read paymentAction from DB settings (same pattern as capture-order)
+    const paypal = req.scope.resolve<PayPalModuleService>("paypal_onboarding")
+    const settings = await paypal.getSettings().catch(() => ({}))
+    const settingsData =
+      settings && typeof settings === "object" && "data" in settings
+        ? ((settings as { data?: Record<string, any> }).data ?? {})
+        : {}
+    const additionalSettings = (settingsData.additional_settings || {}) as Record<string, any>
+    const paymentAction =
+      typeof additionalSettings.paymentAction === "string"
+        ? additionalSettings.paymentAction
+        : "capture"
+
+    // "authorize" mode → session status = "authorized"
+    // "capture" mode  → session status = "captured"
+    const sessionStatus = paymentAction === "authorize" ? "authorized" : "captured"
+    const timestampKey = paymentAction === "authorize" ? "authorized_at" : "captured_at"
+
+    // Step 2 — find the PayPal session for this cart
+    const query = req.scope.resolve("query")
+    const { data: carts } = await query.graph({
+      entity: "cart",
+      fields: [
+        "id",
+        "payment_collection.payment_sessions.id",
+        "payment_collection.payment_sessions.data",
+        "payment_collection.payment_sessions.provider_id",
+        "payment_collection.payment_sessions.created_at",
+        "payment_collection.payment_sessions.amount",  
+        "payment_collection.payment_sessions.currency_code",
+      ],
+      filters: { id: cart_id },
+    })
+
+    const sessions = carts?.[0]?.payment_collection?.payment_sessions || []
+    const session = sessions
+      .filter((s: any) => String(s.provider_id || "").includes("paypal"))
+      .sort(
+        (a: any, b: any) =>
+          new Date(b.created_at || 0).getTime() - new Date(a.created_at || 0).getTime()
+      )[0]
+
+    if (!session) {
+      return res.status(400).json({ error: "No PayPal payment session found for cart" })
+    }
+
+    // Step 3 — update session with correct status + amount
+    const paymentModule = req.scope.resolve(Modules.PAYMENT) as IPaymentModuleService
+    await (paymentModule as any).updatePaymentSession({
+      id: session.id,
+      data: { ...(session.data || {}), [timestampKey]: new Date().toISOString() },
+      status: sessionStatus as any,
+      amount: session.amount, 
+      currency_code: session.currency_code,
+    })
+
+    console.log(`[paypal-complete] session ${sessionStatus}:`, session.id)
+    return res.json({ success: true, session_id: session.id })
+  } catch (e: any) {
+    console.error("[paypal-complete] error:", e?.message || e)
+    return res.status(500).json({ error: e?.message || "Internal error" })
+  }
 }

package/src/jobs/paypal-reconcile.ts

@@ -1,5 +1,8 @@
 import type { MedusaContainer } from "@medusajs/framework/types"
+import { Modules } from "@medusajs/framework/utils"
 import type PayPalModuleService from "../modules/paypal/service"
+import { PAYPAL_MODULE } from "../modules/paypal"
+import { PAYPAL_PROVIDER_IDS } from "../modules/paypal/utils/provider-ids"
 
 const STATUS_MAP: Record<string, "pending" | "authorized" | "captured" | "canceled"> = {
   CREATED: "pending",
@@ -10,11 +13,20 @@ const STATUS_MAP: Record<string, "pending" | "authorized" | "captured" | "cancel
 }
 
 export default async function paypalReconcile(container: MedusaContainer) {
-  const paymentSessionService = container.resolve("payment_session") as any
-  const paypal = container.resolve<PayPalModuleService>("paypal_onboarding")
+  // FIX 3a: was container.resolve("payment_session") as any
+  // Modules.PAYMENT is the official typed constant for the Medusa payment module.
+  // listPaymentSessions and updatePaymentSession are methods on the payment module service.
+  const paymentModule = container.resolve(Modules.PAYMENT) as any
 
-  const sessions = await paymentSessionService.list({
-    provider_id: ["pp_paypal_paypal", "pp_paypal_card_paypal_card"],
+  // FIX 3b: was container.resolve<PayPalModuleService>("paypal_onboarding")
+  // PAYPAL_MODULE is the exported constant from modules/paypal/index.ts
+  const paypal = container.resolve<PayPalModuleService>(PAYPAL_MODULE)
+
+  // FIX 3c: was ["pp_paypal_paypal", "pp_paypal_card_paypal_card"]
+  // PAYPAL_PROVIDER_IDS is the exported array from modules/paypal/utils/provider-ids.ts
+  // If the provider IDs ever change in one place, this file updates automatically.
+  const sessions = await paymentModule.listPaymentSessions({
+    provider_id: [...PAYPAL_PROVIDER_IDS],
     status: ["pending", "authorized"],
   })
 
@@ -66,8 +78,11 @@ export default async function paypalReconcile(container: MedusaContainer) {
         })
       }
 
-      await paymentSessionService.update(session.id, {
+      // FIX 3d: was paymentSessionService.update(session.id, { ... })
+      // updatePaymentSession is the correct method name on the payment module service.
+      await paymentModule.updatePaymentSession(session.id, {
         status,
+        amount: session.amount,
         data: {
           ...(session.data || {}),
           paypal: {
@@ -132,4 +147,4 @@ export default async function paypalReconcile(container: MedusaContainer) {
 export const config = {
   name: "paypal-reconcile",
   schedule: "*/15 * * * *",
-}
+}

package/src/modules/paypal/service.ts

@@ -236,7 +236,9 @@ class PayPalModuleService extends MedusaService({
     let json: any = {}
     try {
       json = text ? JSON.parse(text) : {}
-    } catch {}
+    } catch (e: any) {
+      console.warn("[PayPal] Failed to parse response JSON — using empty object:", e?.message)
+    }
 
     if (!resp.ok) {
       throw new Error(
@@ -548,7 +550,9 @@ class PayPalModuleService extends MedusaService({
     let tokenJson: any = {}
     try {
       tokenJson = tokenText ? JSON.parse(tokenText) : {}
-    } catch {}
+    } catch (e: any) {
+      console.warn("[PayPal] Failed to parse token response JSON:", e?.message)
+    }
 
     if (!tokenRes.ok) {
       throw new Error(
@@ -583,7 +587,9 @@ class PayPalModuleService extends MedusaService({
     let credJson: any = {}
     try {
       credJson = credText ? JSON.parse(credText) : {}
-    } catch {}
+    } catch (e: any) {
+      console.warn("[PayPal] Failed to parse token response JSON:", e?.message)
+    }
 
     if (!credRes.ok) {
       throw new Error(
@@ -1032,12 +1038,41 @@ class PayPalModuleService extends MedusaService({
     return { data: (row?.data || {}) as Record<string, any> }
   }
 
+  /**
+   * Deep-merge patch into current settings.
+   * Nested objects (additional_settings, api_details, etc.) are merged,
+   * not replaced.
+   */
+  private deepMerge(
+    target: Record<string, any>,
+    source: Record<string, any>
+  ): Record<string, any> {
+    const result = { ...target }
+    for (const key of Object.keys(source)) {
+      const sv = source[key]
+      const tv = target[key]
+      if (
+        sv !== null &&
+        typeof sv === "object" &&
+        !Array.isArray(sv) &&
+        tv !== null &&
+        typeof tv === "object" &&
+        !Array.isArray(tv)
+      ) {
+        result[key] = this.deepMerge(tv, sv)
+      } else {
+        result[key] = sv
+      }
+    }
+    return result
+  }
+
   async saveSettings(patch: Record<string, any>) {
     const rows = await this.listPayPalSettings({})
     const row = rows?.[0]
     const current = (row?.data || {}) as Record<string, any>
 
-    const next = { ...current, ...patch }
+    const next = this.deepMerge(current, patch)
 
     if (!row) {
       const created = await this.createPayPalSettings({ data: next })

package/src/modules/paypal/utils/paypal-auth.ts

@@ -0,0 +1,32 @@
+/**
+ * Shared PayPal API authentication helpers.
+ * Import these instead of copying into each route.
+ */
+export function getPayPalApiBase(environment: string): string {
+  return environment === "live"
+    ? "https://api-m.paypal.com"
+    : "https://api-m.sandbox.paypal.com"
+}
+
+export async function getPayPalAccessToken(opts: {
+  environment: string
+  client_id: string
+  client_secret: string
+}): Promise<{ accessToken: string; base: string }> {
+  const base = getPayPalApiBase(opts.environment)
+  const auth = Buffer.from(`${opts.client_id}:${opts.client_secret}`).toString("base64")
+  const resp = await fetch(`${base}/v1/oauth2/token`, {
+    method: "POST",
+    headers: {
+      Authorization: `Basic ${auth}`,
+      "Content-Type": "application/x-www-form-urlencoded",
+    },
+    body: "grant_type=client_credentials",
+  })
+  const text = await resp.text()
+  if (!resp.ok) {
+    throw new Error(`PayPal token error (${resp.status}): ${text}`)
+  }
+  const json = JSON.parse(text)
+  return { accessToken: String(json.access_token), base }
+}

package/src/modules/paypal/webhook-processor.ts

@@ -1,6 +1,8 @@
 import type { MedusaContainer } from "@medusajs/framework/types"
+import { ContainerRegistrationKeys, Modules } from "@medusajs/framework/utils"
 import type PayPalModuleService from "./service"
 import { isPayPalProviderId } from "./utils/provider-ids"
+import { PAYPAL_MODULE } from "./index"
 
 export const EVENT_STATUS_MAP: Record<string, "authorized" | "captured" | "canceled" | "error"> = {
   "CHECKOUT.ORDER.APPROVED": "authorized",
@@ -125,7 +127,9 @@ async function resolveDisputeOrderId(
   orderId?: string | null,
   cartId?: string | null
 ) {
-  const query = container.resolve("query") as any
+  // FIX 4a: was container.resolve("query") as any
+  // ContainerRegistrationKeys.QUERY is the official typed constant for the Medusa query helper
+  const query = container.resolve(ContainerRegistrationKeys.QUERY)
   const cleanedOrderId = orderId?.trim()
   const cleanedCartId = cartId?.trim()
 
@@ -188,15 +192,22 @@ async function updatePaymentSession(
   status: string,
   data: Record<string, unknown>
 ) {
-  const paymentCollectionService = container.resolve("payment_collection") as any
-  const paymentSessionService = container.resolve("payment_session") as any
+  // FIX 4b: was container.resolve("payment_collection") as any
+  //         and container.resolve("payment_session") as any
+  // Modules.PAYMENT is the official typed constant that resolves the Medusa payment module.
+  // It gives access to both payment collections and payment sessions through one service.
+  const paymentModule = container.resolve(Modules.PAYMENT) as any
+
+  const pc = await paymentModule.retrievePaymentCollectionByCartId?.(cartId).catch(() => null)
+    ?? await paymentModule.listPaymentCollections({ cart_id: cartId })
+        .then((r: any[]) => r?.[0] ?? null)
+        .catch(() => null)
 
-  const pc = await paymentCollectionService.retrieveByCartId(cartId).catch(() => null)
   if (!pc?.id) {
     return
   }
 
-  const sessions = await paymentSessionService.list({ payment_collection_id: pc.id })
+  const sessions = await paymentModule.listPaymentSessions({ payment_collection_id: pc.id })
   const paypalSession = sessions?.find((s: any) => isPayPalProviderId(s.provider_id))
   if (!paypalSession) {
     return
@@ -210,7 +221,7 @@ async function updatePaymentSession(
     ? mergeRefunds(existingRefunds, incomingRefunds)
     : existingRefunds
 
-  await paymentSessionService.update(paypalSession.id, {
+  await paymentModule.updatePaymentSession(paypalSession.id, {
     status,
     data: {
       ...existingData,
@@ -239,7 +250,10 @@ export async function processPayPalWebhookEvent(
     payload: Record<string, any>
   }
 ) {
-  const paypal = container.resolve<PayPalModuleService>("paypal_onboarding")
+  // FIX 4c: was container.resolve<PayPalModuleService>("paypal_onboarding")
+  // PAYPAL_MODULE is the exported constant from ./index.ts — value is "paypal_onboarding"
+  // Using the constant means if the key ever changes, this file updates automatically.
+  const paypal = container.resolve<PayPalModuleService>(PAYPAL_MODULE)
   const resource = normalizeResource(input.payload)
   const { orderId, captureId, refundId, cartId } = extractIdentifiers(resource)
   const disputeDetails =
@@ -310,4 +324,4 @@ export async function processPayPalWebhookEvent(
     disputeId: disputeDetails?.disputeId,
     resource,
   }
-}
+}

package/tsconfig.json

@@ -17,7 +17,7 @@
     "allowSyntheticDefaultImports": true,
     "resolveJsonModule": true,
     "skipLibCheck": true,
-    "strict": false
+    "strict": true
   },
   "include": [
     "src/**/*.ts",