@easypayment/medusa-paypal-ui 1.2.2 → 1.2.3

package/src/client/http.ts

@@ -1,204 +1,214 @@
-export type HttpOptions = {
-  baseUrl: string
-  publishableApiKey?: string
-  /**
-   * `credentials` mode for every request. Defaults to "include" (the
-   * historical behavior, required when the backend sits behind cookie-based
-   * gateways like Cloudflare Access). Set to "omit" or "same-origin" when the
-   * backend answers with `Access-Control-Allow-Origin: *` — browsers reject
-   * credentialed requests against a wildcard CORS origin outright.
-   */
-  credentials?: RequestCredentials
-}
-
-export type RequestOptions = {
-  /**
-   * Number of extra attempts on transient failures (network error, timeout,
-   * HTTP 429/5xx). Only use for idempotent calls — the PayPal capture/complete
-   * endpoints are idempotent server-side, so a retried request after a network
-   * blip re-uses the existing result instead of duplicating work. Default 0.
-   */
-  retries?: number
-}
-
-class HttpError extends Error {
-  status: number
-  constructor(message: string, status: number) {
-    super(message)
-    this.name = "HttpError"
-    this.status = status
-  }
-}
-
-const RETRY_BASE_DELAY_MS = 400
-
-function isRetryableStatus(status: number): boolean {
-  return status === 429 || status >= 500
-}
-
-function isRetryableError(err: unknown): boolean {
-  // Network failures and our own timeout error are safe to retry.
-  return err instanceof Error && !(err instanceof HttpError)
-}
-
-const wait = (ms: number) => new Promise((r) => setTimeout(r, ms))
-
-/** Best-effort extraction of a `{ message: string }` payload from a response body. */
-function extractJsonMessage(text: string): string | null {
-  if (!text) return null
-  try {
-    const parsed = JSON.parse(text)
-    const message = parsed?.message
-    if (typeof message === "string" && message.trim()) {
-      return message.trim().slice(0, 500)
-    }
-  } catch {
-    // not JSON — caller falls back to the raw text
-  }
-  return null
-}
-
-function toHeaderRecord(headers?: RequestInit["headers"]): Record<string, string> {
-  if (!headers) {
-    return {}
-  }
-
-  if (headers instanceof Headers) {
-    return Object.fromEntries(headers.entries())
-  }
-
-  if (Array.isArray(headers)) {
-    return Object.fromEntries(headers)
-  }
-
-  return { ...headers }
-}
-
-export function createHttpClient(opts: HttpOptions) {
-  const base = opts.baseUrl.replace(/\/+$/, "")
-
-  async function attempt<T>(path: string, init?: RequestInit): Promise<T> {
-    const url = `${base}${path.startsWith("/") ? "" : "/"}${path}`
-    const headers: Record<string, string> = {
-      Accept: "application/json",
-      ...toHeaderRecord(init?.headers),
-    }
-
-    if (opts.publishableApiKey) {
-      headers["x-publishable-api-key"] = opts.publishableApiKey
-    }
-
-    // Always arm the timeout — a caller-supplied signal composes with it
-    // rather than replacing it. Without this, hook-issued requests (which
-    // always pass an abort signal) could hang forever on a stalled
-    // connection. The timer also covers reading the body: a server that sends
-    // headers then stalls the response stream would otherwise hang the
-    // request indefinitely with the old header-only timeout.
-    const timeoutMs = 30_000
-    const controller = new AbortController()
-    const timeoutId = setTimeout(() => controller.abort(), timeoutMs)
-    const callerSignal = init?.signal ?? null
-    const onCallerAbort = () => controller.abort()
-    if (callerSignal) {
-      if (callerSignal.aborted) controller.abort()
-      else callerSignal.addEventListener("abort", onCallerAbort)
-    }
-    let res: Response
-    let text: string
-    try {
-      res = await fetch(url, {
-        ...init,
-        headers,
-        credentials: opts.credentials ?? "include",
-        signal: controller.signal,
-      })
-      text = await res.text().catch(() => "")
-    } catch (err) {
-      if (
-        err instanceof Error &&
-        err.name === "AbortError" &&
-        !(callerSignal && callerSignal.aborted)
-      ) {
-        throw new Error(`[PayPal] Request to ${path} timed out after ${timeoutMs / 1000}s`)
-      }
-      throw err
-    } finally {
-      clearTimeout(timeoutId)
-      if (callerSignal) callerSignal.removeEventListener("abort", onCallerAbort)
-    }
-
-    if (!res.ok) {
-      // Backend routes return structured JSON errors ({ message }) written for
-      // the buyer (e.g. unsupported currency, rate-limit, "payment processed
-      // but order not finalized"). Prefer that message over raw response text
-      // or a generic hint so the user sees something actionable instead of a
-      // JSON blob.
-      const parsedMessage = extractJsonMessage(text)
-      if (res.status === 401) {
-        throw new HttpError(
-          parsedMessage ||
-            "[PayPal] Unauthorized (401) — check that your publishable API key is correct and set in NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY",
-          401
-        )
-      }
-      if (res.status === 403) {
-        throw new HttpError(
-          parsedMessage ||
-            "[PayPal] Forbidden (403) — this request is not allowed. Check your CORS and API key settings.",
-          403
-        )
-      }
-      throw new HttpError(
-        parsedMessage ||
-          text.slice(0, 500).replace(/<[^>]*>/g, "") ||
-          `Request failed (${res.status})`,
-        res.status
-      )
-    }
-    if (!text) {
-      throw new HttpError(`[PayPal] Empty response body from ${path} (${res.status})`, res.status)
-    }
-
-    const contentType = res.headers.get("content-type") || ""
-    if (!contentType.includes("application/json")) {
-      throw new Error(
-        `[PayPal] Unexpected non-JSON response (${contentType}) from ${path}`
-      )
-    }
-
-    try {
-      return JSON.parse(text) as T
-    } catch {
-      throw new Error(`[PayPal] Failed to parse JSON response from ${path}`)
-    }
-  }
-
-  async function request<T>(
-    path: string,
-    init?: RequestInit,
-    reqOpts?: RequestOptions
-  ): Promise<T> {
-    const retries = Math.max(0, reqOpts?.retries ?? 0)
-    let lastError: unknown
-    for (let i = 0; i <= retries; i++) {
-      try {
-        return await attempt<T>(path, init)
-      } catch (err) {
-        lastError = err
-        const transient =
-          (err instanceof HttpError && isRetryableStatus(err.status)) ||
-          isRetryableError(err)
-        // Don't retry a caller-supplied AbortSignal cancellation.
-        const aborted =
-          err instanceof Error && err.name === "AbortError" && !!init?.signal
-        if (i >= retries || !transient || aborted) {
-          throw err
-        }
-        await wait(RETRY_BASE_DELAY_MS * Math.pow(2, i) + Math.random() * RETRY_BASE_DELAY_MS)
-      }
-    }
-    throw lastError
-  }
-
-  return { request }
-}
+export type HttpOptions = {
+  baseUrl: string
+  publishableApiKey?: string
+  /**
+   * `credentials` mode for every request. Defaults to "include" (the
+   * historical behavior, required when the backend sits behind cookie-based
+   * gateways like Cloudflare Access). Set to "omit" or "same-origin" when the
+   * backend answers with `Access-Control-Allow-Origin: *` — browsers reject
+   * credentialed requests against a wildcard CORS origin outright.
+   */
+  credentials?: RequestCredentials
+}
+
+export type RequestOptions = {
+  /**
+   * Number of extra attempts on transient failures (network error, timeout,
+   * HTTP 429/5xx). Only use for idempotent calls — the PayPal capture/complete
+   * endpoints are idempotent server-side, so a retried request after a network
+   * blip re-uses the existing result instead of duplicating work. Default 0.
+   */
+  retries?: number
+}
+
+class HttpError extends Error {
+  status: number
+  constructor(message: string, status: number) {
+    super(message)
+    this.name = "HttpError"
+    this.status = status
+  }
+}
+
+const RETRY_BASE_DELAY_MS = 400
+
+function isRetryableStatus(status: number): boolean {
+  return status === 429 || status >= 500
+}
+
+function isRetryableError(err: unknown): boolean {
+  // Network failures and our own timeout error are safe to retry.
+  return err instanceof Error && !(err instanceof HttpError)
+}
+
+const wait = (ms: number) => new Promise((r) => setTimeout(r, ms))
+
+/** Best-effort extraction of a `{ message: string }` payload from a response body. */
+function extractJsonMessage(text: string): string | null {
+  if (!text) return null
+  try {
+    const parsed = JSON.parse(text)
+    const message = parsed?.message
+    if (typeof message === "string" && message.trim()) {
+      return message.trim().slice(0, 500)
+    }
+  } catch {
+    // not JSON — caller falls back to the raw text
+  }
+  return null
+}
+
+function toHeaderRecord(
+  headers?: RequestInit["headers"]
+): Record<string, string> {
+  if (!headers) {
+    return {}
+  }
+
+  if (headers instanceof Headers) {
+    return Object.fromEntries(headers.entries())
+  }
+
+  if (Array.isArray(headers)) {
+    return Object.fromEntries(headers)
+  }
+
+  return { ...headers }
+}
+
+export function createHttpClient(opts: HttpOptions) {
+  const base = opts.baseUrl.replace(/\/+$/, "")
+
+  async function attempt<T>(path: string, init?: RequestInit): Promise<T> {
+    const url = `${base}${path.startsWith("/") ? "" : "/"}${path}`
+    const headers: Record<string, string> = {
+      Accept: "application/json",
+      ...toHeaderRecord(init?.headers),
+    }
+
+    if (opts.publishableApiKey) {
+      headers["x-publishable-api-key"] = opts.publishableApiKey
+    }
+
+    // Always arm the timeout — a caller-supplied signal composes with it
+    // rather than replacing it. Without this, hook-issued requests (which
+    // always pass an abort signal) could hang forever on a stalled
+    // connection. The timer also covers reading the body: a server that sends
+    // headers then stalls the response stream would otherwise hang the
+    // request indefinitely with the old header-only timeout.
+    const timeoutMs = 30_000
+    const controller = new AbortController()
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs)
+    const callerSignal = init?.signal ?? null
+    const onCallerAbort = () => controller.abort()
+    if (callerSignal) {
+      if (callerSignal.aborted) controller.abort()
+      else callerSignal.addEventListener("abort", onCallerAbort)
+    }
+    let res: Response
+    let text: string
+    try {
+      res = await fetch(url, {
+        ...init,
+        headers,
+        credentials: opts.credentials ?? "include",
+        signal: controller.signal,
+      })
+      text = await res.text().catch(() => "")
+    } catch (err) {
+      if (
+        err instanceof Error &&
+        err.name === "AbortError" &&
+        !(callerSignal && callerSignal.aborted)
+      ) {
+        throw new Error(
+          `[PayPal] Request to ${path} timed out after ${timeoutMs / 1000}s`
+        )
+      }
+      throw err
+    } finally {
+      clearTimeout(timeoutId)
+      if (callerSignal) callerSignal.removeEventListener("abort", onCallerAbort)
+    }
+
+    if (!res.ok) {
+      // Backend routes return structured JSON errors ({ message }) written for
+      // the buyer (e.g. unsupported currency, rate-limit, "payment processed
+      // but order not finalized"). Prefer that message over raw response text
+      // or a generic hint so the user sees something actionable instead of a
+      // JSON blob.
+      const parsedMessage = extractJsonMessage(text)
+      if (res.status === 401) {
+        throw new HttpError(
+          parsedMessage ||
+            "[PayPal] Unauthorized (401) — check that your publishable API key is correct and set in NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY",
+          401
+        )
+      }
+      if (res.status === 403) {
+        throw new HttpError(
+          parsedMessage ||
+            "[PayPal] Forbidden (403) — this request is not allowed. Check your CORS and API key settings.",
+          403
+        )
+      }
+      throw new HttpError(
+        parsedMessage ||
+          text.slice(0, 500).replace(/<[^>]*>/g, "") ||
+          `Request failed (${res.status})`,
+        res.status
+      )
+    }
+    if (!text) {
+      throw new HttpError(
+        `[PayPal] Empty response body from ${path} (${res.status})`,
+        res.status
+      )
+    }
+
+    const contentType = res.headers.get("content-type") || ""
+    if (!contentType.includes("application/json")) {
+      throw new Error(
+        `[PayPal] Unexpected non-JSON response (${contentType}) from ${path}`
+      )
+    }
+
+    try {
+      return JSON.parse(text) as T
+    } catch {
+      throw new Error(`[PayPal] Failed to parse JSON response from ${path}`)
+    }
+  }
+
+  async function request<T>(
+    path: string,
+    init?: RequestInit,
+    reqOpts?: RequestOptions
+  ): Promise<T> {
+    const retries = Math.max(0, reqOpts?.retries ?? 0)
+    let lastError: unknown
+    for (let i = 0; i <= retries; i++) {
+      try {
+        return await attempt<T>(path, init)
+      } catch (err) {
+        lastError = err
+        const transient =
+          (err instanceof HttpError && isRetryableStatus(err.status)) ||
+          isRetryableError(err)
+        // Don't retry a caller-supplied AbortSignal cancellation.
+        const aborted =
+          err instanceof Error && err.name === "AbortError" && !!init?.signal
+        if (i >= retries || !transient || aborted) {
+          throw err
+        }
+        await wait(
+          RETRY_BASE_DELAY_MS * Math.pow(2, i) +
+            Math.random() * RETRY_BASE_DELAY_MS
+        )
+      }
+    }
+    throw lastError
+  }
+
+  return { request }
+}

package/src/client/paypal.ts

@@ -1,88 +1,91 @@
-import type { PayPalConfig, PayPalSettingsResponse } from "./types"
-import { createHttpClient, type HttpOptions } from "./http"
-
-/**
- * Fresh idempotency key per create-order ATTEMPT (i.e. per buyer click).
- *
- * The backend derives the PayPal-Request-Id from this header. It must be
- * unique per attempt: PayPal replays the cached response for a reused request
- * id, so a key stable across cart changes would hand back the ORIGINAL order —
- * at the original total — after the buyer edits the cart, charging a stale
- * amount. Reuse/dedup of an unchanged order is handled server-side by the
- * stored-order staleness check, not by this key.
- */
-export function generateIdempotencyKey(): string {
-  try {
-    const c = (globalThis as { crypto?: Crypto }).crypto
-    if (c?.randomUUID) return c.randomUUID()
-  } catch {
-    // fall through
-  }
-  return `pp-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}`
-}
-
-export async function markPaymentComplete(
-  baseUrl: string,
-  cartId: string,
-  publishableApiKey?: string
-): Promise<Record<string, unknown>> {
-  const http = createHttpClient({ baseUrl, publishableApiKey })
-  // Retry transient failures: /store/paypal-complete is idempotent (it returns
-  // already_completed for a finished cart), so a network blip right after
-  // capture — the classic "captured but cart not completed" gap — is retried
-  // instead of stranding a paid-but-unfinalized order.
-  return http.request<Record<string, unknown>>(
-    `/store/paypal-complete`,
-    {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ cart_id: cartId }),
-    },
-    { retries: 3 }
-  )
-}
-
-export function createPayPalStoreApi(opts: HttpOptions) {
-  const http = createHttpClient(opts)
-
-  return {
-    getConfig(cartId?: string, signal?: AbortSignal) {
-      const q = cartId ? `?cart_id=${encodeURIComponent(cartId)}` : ""
-      return http.request<PayPalConfig>(`/store/paypal/config${q}`, { signal })
-    },
-
-    getSettings() {
-      return http.request<PayPalSettingsResponse>(`/store/paypal/settings`)
-    },
-
-    createOrder(cartId: string, isCardPayment = false) {
-      return http.request<{ id: string }>(`/store/paypal/create-order`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          // One key per attempt — see generateIdempotencyKey. Deliberately NOT
-          // sent for capture-order: there the server's deterministic
-          // per-order-id fallback is the correct idempotency scope.
-          "Idempotency-Key": generateIdempotencyKey(),
-        },
-        body: JSON.stringify({ cart_id: cartId, is_card_payment: isCardPayment }),
-      })
-    },
-
-    captureOrder(cartId: string, orderId: string) {
-      // Retry transient failures: capture-order is idempotent server-side (it
-      // short-circuits on an existing capture and PayPal dedupes by request id),
-      // so a network blip during capture doesn't leave the buyer's funds
-      // authorized-but-not-captured with no recovery.
-      return http.request<Record<string, unknown>>(
-        `/store/paypal/capture-order`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ cart_id: cartId, order_id: orderId }),
-        },
-        { retries: 2 }
-      )
-    },
-  }
-}
+import type { PayPalConfig, PayPalSettingsResponse } from "./types"
+import { createHttpClient, type HttpOptions } from "./http"
+
+/**
+ * Fresh idempotency key per create-order ATTEMPT (i.e. per buyer click).
+ *
+ * The backend derives the PayPal-Request-Id from this header. It must be
+ * unique per attempt: PayPal replays the cached response for a reused request
+ * id, so a key stable across cart changes would hand back the ORIGINAL order —
+ * at the original total — after the buyer edits the cart, charging a stale
+ * amount. Reuse/dedup of an unchanged order is handled server-side by the
+ * stored-order staleness check, not by this key.
+ */
+export function generateIdempotencyKey(): string {
+  try {
+    const c = (globalThis as { crypto?: Crypto }).crypto
+    if (c?.randomUUID) return c.randomUUID()
+  } catch {
+    // fall through
+  }
+  return `pp-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}`
+}
+
+export async function markPaymentComplete(
+  baseUrl: string,
+  cartId: string,
+  publishableApiKey?: string
+): Promise<Record<string, unknown>> {
+  const http = createHttpClient({ baseUrl, publishableApiKey })
+  // Retry transient failures: /store/paypal-complete is idempotent (it returns
+  // already_completed for a finished cart), so a network blip right after
+  // capture — the classic "captured but cart not completed" gap — is retried
+  // instead of stranding a paid-but-unfinalized order.
+  return http.request<Record<string, unknown>>(
+    `/store/paypal-complete`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ cart_id: cartId }),
+    },
+    { retries: 3 }
+  )
+}
+
+export function createPayPalStoreApi(opts: HttpOptions) {
+  const http = createHttpClient(opts)
+
+  return {
+    getConfig(cartId?: string, signal?: AbortSignal) {
+      const q = cartId ? `?cart_id=${encodeURIComponent(cartId)}` : ""
+      return http.request<PayPalConfig>(`/store/paypal/config${q}`, { signal })
+    },
+
+    getSettings() {
+      return http.request<PayPalSettingsResponse>(`/store/paypal/settings`)
+    },
+
+    createOrder(cartId: string, isCardPayment = false) {
+      return http.request<{ id: string }>(`/store/paypal/create-order`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          // One key per attempt — see generateIdempotencyKey. Deliberately NOT
+          // sent for capture-order: there the server's deterministic
+          // per-order-id fallback is the correct idempotency scope.
+          "Idempotency-Key": generateIdempotencyKey(),
+        },
+        body: JSON.stringify({
+          cart_id: cartId,
+          is_card_payment: isCardPayment,
+        }),
+      })
+    },
+
+    captureOrder(cartId: string, orderId: string) {
+      // Retry transient failures: capture-order is idempotent server-side (it
+      // short-circuits on an existing capture and PayPal dedupes by request id),
+      // so a network blip during capture doesn't leave the buyer's funds
+      // authorized-but-not-captured with no recovery.
+      return http.request<Record<string, unknown>>(
+        `/store/paypal/capture-order`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ cart_id: cartId, order_id: orderId }),
+        },
+        { retries: 2 }
+      )
+    },
+  }
+}