@easypayment/medusa-paypal 0.1.0

package/src/admin/routes/settings/paypal/reconciliation-status/page.tsx

@@ -0,0 +1,165 @@
+import React, { useCallback, useEffect, useState } from "react"
+import PayPalTabs from "../_components/Tabs"
+
+type ReconciliationStatus = {
+  runs?: number
+  last_run_at?: string | null
+  last_run_status?: string | null
+  last_success_at?: string | null
+  last_failure_at?: string | null
+  sessions_checked?: number
+  sessions_updated?: number
+  drift_count?: number
+  last_drift_at?: string | null
+  last_drift_order_id?: string | null
+  last_error?: string | null
+}
+
+function formatDate(value?: string | null) {
+  if (!value) {
+    return "—"
+  }
+  const parsed = new Date(value)
+  if (Number.isNaN(parsed.getTime())) {
+    return value
+  }
+  return parsed.toLocaleString()
+}
+
+export default function PayPalReconciliationStatusPage() {
+  const [status, setStatus] = useState<ReconciliationStatus>({})
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+
+  const fetchStatus = useCallback(async () => {
+    try {
+      setLoading(true)
+      setError(null)
+      const response = await fetch("/admin/paypal/reconciliation-status", {
+        credentials: "include",
+        headers: {
+          Accept: "application/json",
+        },
+      })
+
+      if (!response.ok) {
+        const message = await response.text().catch(() => "")
+        throw new Error(message || "Failed to load reconciliation status.")
+      }
+
+      const data = await response.json().catch(() => ({}))
+      setStatus((data?.status as ReconciliationStatus) || {})
+    } catch (fetchError: any) {
+      setError(fetchError?.message || "Failed to load reconciliation status.")
+      setStatus({})
+    } finally {
+      setLoading(false)
+    }
+  }, [])
+
+  useEffect(() => {
+    fetchStatus()
+  }, [fetchStatus])
+
+  return (
+    <div className="p-6">
+      <div className="flex flex-col gap-6">
+        <div>
+          <h1 className="text-xl font-semibold text-ui-fg-base">
+            PayPal Reconciliation Status
+          </h1>
+          <p className="mt-1 text-sm text-ui-fg-subtle">
+            Monitor reconciliation health and drift detection for PayPal payment sessions.
+          </p>
+        </div>
+
+        <PayPalTabs />
+
+        <div className="rounded-xl border border-ui-border-base bg-ui-bg-base shadow-sm">
+          <div className="border-b border-ui-border-base p-4">
+            <div className="flex items-center justify-between gap-4">
+              <div className="text-base font-semibold text-ui-fg-base">
+                Latest reconciliation run
+              </div>
+              <button
+                type="button"
+                onClick={fetchStatus}
+                className="rounded-md border border-ui-border-base px-3 py-2 text-sm text-ui-fg-base"
+                disabled={loading}
+              >
+                {loading ? "Refreshing..." : "Refresh"}
+              </button>
+            </div>
+          </div>
+          <div className="p-4">
+            {error ? (
+              <div className="rounded-md border border-red-200 bg-red-50 p-3 text-sm text-red-600">
+                {error}
+              </div>
+            ) : null}
+
+            {!error && Object.keys(status).length === 0 ? (
+              <div className="text-sm text-ui-fg-subtle">
+                {loading ? "Loading reconciliation status..." : "No reconciliation data yet."}
+              </div>
+            ) : null}
+
+            {Object.keys(status).length > 0 ? (
+              <div className="grid gap-4 text-sm text-ui-fg-base md:grid-cols-2">
+                <div className="rounded-lg border border-ui-border-base bg-ui-bg-subtle p-3">
+                  <div className="text-ui-fg-subtle">Last run</div>
+                  <div className="mt-1 font-medium">{formatDate(status.last_run_at)}</div>
+                </div>
+                <div className="rounded-lg border border-ui-border-base bg-ui-bg-subtle p-3">
+                  <div className="text-ui-fg-subtle">Last run status</div>
+                  <div className="mt-1 font-medium capitalize">
+                    {status.last_run_status || "—"}
+                  </div>
+                </div>
+                <div className="rounded-lg border border-ui-border-base bg-ui-bg-subtle p-3">
+                  <div className="text-ui-fg-subtle">Last success</div>
+                  <div className="mt-1 font-medium">{formatDate(status.last_success_at)}</div>
+                </div>
+                <div className="rounded-lg border border-ui-border-base bg-ui-bg-subtle p-3">
+                  <div className="text-ui-fg-subtle">Last failure</div>
+                  <div className="mt-1 font-medium">{formatDate(status.last_failure_at)}</div>
+                </div>
+                <div className="rounded-lg border border-ui-border-base bg-ui-bg-subtle p-3">
+                  <div className="text-ui-fg-subtle">Sessions checked</div>
+                  <div className="mt-1 font-medium">{status.sessions_checked ?? 0}</div>
+                </div>
+                <div className="rounded-lg border border-ui-border-base bg-ui-bg-subtle p-3">
+                  <div className="text-ui-fg-subtle">Sessions updated</div>
+                  <div className="mt-1 font-medium">{status.sessions_updated ?? 0}</div>
+                </div>
+                <div className="rounded-lg border border-ui-border-base bg-ui-bg-subtle p-3">
+                  <div className="text-ui-fg-subtle">Drift detections</div>
+                  <div className="mt-1 font-medium">{status.drift_count ?? 0}</div>
+                </div>
+                <div className="rounded-lg border border-ui-border-base bg-ui-bg-subtle p-3">
+                  <div className="text-ui-fg-subtle">Last drift order</div>
+                  <div className="mt-1 font-medium">
+                    {status.last_drift_order_id || "—"}
+                  </div>
+                  <div className="mt-1 text-xs text-ui-fg-subtle">
+                    {formatDate(status.last_drift_at)}
+                  </div>
+                </div>
+                <div className="rounded-lg border border-ui-border-base bg-ui-bg-subtle p-3 md:col-span-2">
+                  <div className="text-ui-fg-subtle">Last error</div>
+                  <div className="mt-1 font-medium">
+                    {status.last_error || "No errors recorded."}
+                  </div>
+                </div>
+                <div className="rounded-lg border border-ui-border-base bg-ui-bg-subtle p-3 md:col-span-2">
+                  <div className="text-ui-fg-subtle">Total runs</div>
+                  <div className="mt-1 font-medium">{status.runs ?? 0}</div>
+                </div>
+              </div>
+            ) : null}
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}

package/src/api/admin/payment-collections/[id]/payment-sessions/route.ts

@@ -0,0 +1,32 @@
+import { createPaymentSessionsWorkflow } from "@medusajs/core-flows"
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import { normalizePayPalProviderId } from "../../../../../modules/paypal/utils/provider-ids"
+
+type CreatePaymentSessionBody = {
+  provider_id: string
+  data?: Record<string, unknown>
+  customer_id?: string
+}
+
+export async function POST(req: MedusaRequest, res: MedusaResponse) {
+  const collectionId = req.params.id
+  const { provider_id, data, customer_id } = req.body as CreatePaymentSessionBody
+  const normalizedProviderId = normalizePayPalProviderId(provider_id)
+
+  if (!normalizedProviderId) {
+    return res.status(400).json({
+      message: `Provider ${provider_id} is not a valid PayPal provider`,
+    })
+  }
+
+  const { result } = await createPaymentSessionsWorkflow(req.scope).run({
+    input: {
+      payment_collection_id: collectionId,
+      provider_id: normalizedProviderId,
+      customer_id,
+      data,
+    },
+  })
+
+  res.status(200).json({ payment_session: result })
+}

package/src/api/admin/paypal/audit-logs/route.ts

@@ -0,0 +1,13 @@
+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")
+  const q = (req.query || {}) as Record<string, any>
+  const limitRaw = Number(q.limit || 50)
+  const limit = Number.isFinite(limitRaw) ? Math.min(Math.max(limitRaw, 1), 200) : 50
+
+  const logs = await paypal.getAuditLogs(limit)
+
+  return res.json({ logs })
+}

package/src/api/admin/paypal/disconnect/route.ts

@@ -0,0 +1,8 @@
+import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import type PayPalModuleService from "../../../../modules/paypal/service"
+
+export async function POST(req: MedusaRequest, res: MedusaResponse) {
+  const paypal = req.scope.resolve<PayPalModuleService>("paypal_onboarding")
+  await paypal.disconnect()
+  return res.json({ ok: true })
+}

package/src/api/admin/paypal/disputes/[id]/route.ts

@@ -0,0 +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")
+  const disputeId = String(req.params?.id || "").trim()
+
+  if (!disputeId) {
+    return res.status(400).json({ message: "dispute id is required" })
+  }
+
+  const matches = await paypal.listPayPalDisputes({ dispute_id: disputeId })
+  const dispute = matches?.[0]
+  if (!dispute) {
+    return res.status(404).json({ message: "Dispute not found" })
+  }
+
+  return res.json({ dispute })
+}

package/src/api/admin/paypal/disputes/route.ts

@@ -0,0 +1,30 @@
+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")
+
+  const query = (req.query || {}) as Record<string, string | string[] | undefined>
+  const filters: Record<string, string> = {}
+
+  const addFilter = (key: string) => {
+    const value = query[key]
+    if (Array.isArray(value)) {
+      if (value[0]) {
+        filters[key] = value[0]
+      }
+      return
+    }
+    if (typeof value === "string" && value.trim()) {
+      filters[key] = value.trim()
+    }
+  }
+
+  addFilter("status")
+  addFilter("order_id")
+  addFilter("cart_id")
+  addFilter("dispute_id")
+
+  const disputes = await paypal.listPayPalDisputes(filters)
+  return res.json({ disputes })
+}

package/src/api/admin/paypal/disputes/summary/route.ts

@@ -0,0 +1,18 @@
+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")
+  const disputes = await paypal.listPayPalDisputes({})
+  const counts: Record<string, number> = {}
+
+  for (const dispute of disputes || []) {
+    const status = dispute.status || "unknown"
+    counts[status] = (counts[status] || 0) + 1
+  }
+
+  return res.json({
+    total: disputes?.length ?? 0,
+    statuses: counts,
+  })
+}

package/src/api/admin/paypal/environment/route.ts

@@ -0,0 +1,25 @@
+import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import type PayPalModuleService from "../../../../modules/paypal/service"
+
+type Body = {
+  environment?: "sandbox" | "live"
+}
+
+export async function GET(req: MedusaRequest, res: MedusaResponse) {
+  const paypal = req.scope.resolve<PayPalModuleService>("paypal_onboarding")
+  const status = await paypal.getStatus()
+  return res.json({ environment: status.environment })
+}
+
+export async function POST(req: MedusaRequest, res: MedusaResponse) {
+  try {
+    const paypal = req.scope.resolve<PayPalModuleService>("paypal_onboarding")
+    const body = (req.body || {}) as Body
+    const env = body.environment === "live" ? "live" : "sandbox"
+    await paypal.setEnvironment(env)
+    const status = await paypal.getStatus()
+    return res.json(status)
+  } catch (e: any) {
+    return res.status(500).json({ message: e?.message || "Unknown error" })
+  }
+}

package/src/api/admin/paypal/onboard-complete/route.ts

@@ -0,0 +1,44 @@
+import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import type PayPalModuleService from "../../../../modules/paypal/service"
+
+/**
+ * Helpful response for browser address-bar tests.
+ * The onboarding callback must call this endpoint via POST.
+ */
+export async function GET(_req: MedusaRequest, res: MedusaResponse) {
+  return res.status(405).json({
+    message:
+      "Method Not Allowed. Use POST with JSON: { authCode, sharedId, env }. This endpoint is called by the PayPal onboarding callback.",
+  })
+}
+
+export async function POST(req: MedusaRequest, res: MedusaResponse) {
+  const paypal = req.scope.resolve<PayPalModuleService>("paypal_onboarding")
+  const body = req.body as { authCode?: string; sharedId?: string; env?: "sandbox" | "live" }
+
+  if (!body?.authCode || !body?.sharedId) {
+    return res.status(400).json({ message: "Missing authCode/sharedId" })
+  }
+
+  try {
+    // Useful for debugging "No response" / hanging requests
+    console.log("[PayPal] /admin/paypal/onboard-complete", {
+      env: body.env,
+      hasAuthCode: !!body.authCode,
+      hasSharedId: !!body.sharedId,
+    })
+
+    await paypal.exchangeAndSaveSellerCredentials({
+      authCode: body.authCode,
+      sharedId: body.sharedId,
+      env: body.env,
+    })
+
+    return res.json({ ok: true })
+  } catch (e: any) {
+    console.error("[PayPal] onboard-complete failed", e)
+    return res.status(500).json({
+      message: e?.message || "Failed to exchange and save PayPal credentials",
+    })
+  }
+}

package/src/api/admin/paypal/onboarding-link/route.ts

@@ -0,0 +1,45 @@
+import type {
+  AuthenticatedMedusaRequest,
+  MedusaRequest,
+  MedusaResponse,
+} from "@medusajs/framework/http"
+import type PayPalModuleService from "../../../../modules/paypal/service"
+
+type Body = {
+  email?: string
+  products?: string[]
+}
+
+export async function POST(req: AuthenticatedMedusaRequest, res: MedusaResponse) {
+  try {
+    const paypal = req.scope.resolve<PayPalModuleService>("paypal_onboarding")
+    const body = (req.body || {}) as Body
+    const authEmail =
+      typeof req.auth_context?.user_metadata?.email === "string"
+        ? String(req.auth_context.user_metadata.email)
+        : undefined
+    const email = authEmail ?? body.email ?? "admin@paypal.com"
+
+    const link = await paypal.createOnboardingLink({
+      email,
+      products: body.products,
+    })
+
+    return res.json({
+      status: "pending",
+      onboarding_url: link.onboarding_url,
+      return_url: link.return_url,
+    })
+  } catch (e: any) {
+    console.error("[paypal_onboarding] onboarding-link error:", e?.message || e, e?.stack)
+    return res.status(500).json({
+      message: e?.message || "Unknown error",
+    })
+  }
+}
+
+export async function GET(req: MedusaRequest, res: MedusaResponse) {
+  return res.status(405).json({
+    message: "Use POST /admin/paypal/onboarding-link",
+  })
+}

package/src/api/admin/paypal/onboarding-status/route.ts

@@ -0,0 +1,18 @@
+import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import type PayPalModuleService from "../../../../modules/paypal/service"
+
+export async function GET(req: MedusaRequest, res: MedusaResponse) {
+  try {
+    const paypal = req.scope.resolve<PayPalModuleService>("paypal_onboarding")
+    const status = await paypal.getStatus()
+    return res.json(status)
+  } catch (e: any) {
+    // ✅ Avoid breaking Admin UI with Medusa's generic "unknown_error"
+    console.error("[paypal_onboarding] onboarding-status error:", e?.message || e, e?.stack)
+    return res.json({
+      environment: "sandbox",
+      status: "disconnected",
+      error: e?.message || "Unknown error",
+    })
+  }
+}

package/src/api/admin/paypal/reconciliation-status/route.ts

@@ -0,0 +1,7 @@
+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")
+  return res.json(await paypal.getReconciliationStatus())
+}

package/src/api/admin/paypal/rotate-credentials/route.ts

@@ -0,0 +1,8 @@
+import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import type PayPalModuleService from "../../../../modules/paypal/service"
+
+export async function POST(req: MedusaRequest, res: MedusaResponse) {
+  const paypal = req.scope.resolve<PayPalModuleService>("paypal_onboarding")
+  const result = await paypal.rotateCredentialEncryptionKey()
+  return res.json(result)
+}

package/src/api/admin/paypal/save-credentials/route.ts

@@ -0,0 +1,14 @@
+import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import type PayPalModuleService from "../../../../modules/paypal/service"
+
+export async function POST(req: MedusaRequest, res: MedusaResponse) {
+  const paypal = req.scope.resolve<PayPalModuleService>("paypal_onboarding")
+  const body = req.body as { clientId?: string; clientSecret?: string }
+
+  if (!body?.clientId || !body?.clientSecret) {
+    return res.status(400).json({ message: "Missing clientId/clientSecret" })
+  }
+
+  await paypal.saveSellerCredentials({ clientId: body.clientId, clientSecret: body.clientSecret })
+  return res.json({ ok: true })
+}

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

@@ -0,0 +1,14 @@
+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")
+  return res.json(await paypal.getSettings())
+}
+
+export async function POST(req: MedusaRequest, res: MedusaResponse) {
+  const paypal = req.scope.resolve<PayPalModuleService>("paypal_onboarding")
+
+  const patch = (req.body && typeof req.body === "object") ? (req.body as Record<string, any>) : {}
+  return res.json(await paypal.saveSettings(patch))
+}

package/src/api/admin/paypal/status/route.ts

@@ -0,0 +1,12 @@
+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")
+
+  const q = (req.query || {}) as Record<string, any>
+  const envParam = (q.environment || q.env) as string | undefined
+  const env = envParam === "live" ? "live" : envParam === "sandbox" ? "sandbox" : undefined
+
+  return res.json(await paypal.getStatus(env))
+}

package/src/api/store/payment-collections/[id]/payment-sessions/route.ts

@@ -0,0 +1,51 @@
+import { createPaymentSessionsWorkflow } from "@medusajs/core-flows"
+import { MedusaResponse, MedusaStoreRequest, refetchEntity } from "@medusajs/framework/http"
+import { normalizePayPalProviderId } from "../../../../../modules/paypal/utils/provider-ids"
+
+type CreatePaymentSessionBody = {
+  provider_id: string
+  data?: Record<string, unknown>
+}
+
+export async function POST(req: MedusaStoreRequest, res: MedusaResponse) {
+  const collectionId = req.params.id
+  const { provider_id, data } = req.body as CreatePaymentSessionBody
+  const normalizedProviderId = normalizePayPalProviderId(provider_id)
+  const providerId = normalizedProviderId ?? provider_id
+  const sessionData = normalizedProviderId
+    ? { ...(data || {}), provider_id: providerId }
+    : data
+
+  try {
+    await createPaymentSessionsWorkflow(req.scope).run({
+      input: {
+        payment_collection_id: collectionId,
+        provider_id: providerId,
+        customer_id: req.auth_context?.actor_id,
+        data: sessionData,
+      },
+    })
+  } catch (error: any) {
+    console.error(
+      "[paypal] payment session creation failed",
+      error?.message || error,
+      error?.stack
+    )
+    return res.status(400).json({
+      code: "paypal_payment_session_error",
+      type: "paypal_payment_session_error",
+      message: error?.message || "Unable to create PayPal payment session",
+    })
+  }
+
+  const paymentCollection = await refetchEntity({
+    entity: "payment_collection",
+    idOrFilter: collectionId,
+    scope: req.scope,
+    fields: req.queryConfig.fields,
+  })
+
+  res.status(200).json({
+    payment_collection: paymentCollection,
+  })
+}