@flopay/js 1.0.0 → 1.0.3

package/dist/index.cjs

@@ -34,8 +34,11 @@ __export(index_exports, {
   FloPayElements: () => FloPayElements,
   PaymentAPI: () => PaymentAPI,
   StripeAdapter: () => StripeAdapter,
+  cacheSessionDisplayData: () => cacheSessionDisplayData,
+  clearSessionDisplayData: () => clearSessionDisplayData,
   createCheckoutSession: () => createCheckoutSession,
   createCheckoutSessionWithRetries: () => createCheckoutSessionWithRetries,
+  getSessionDisplayData: () => getSessionDisplayData,
   loadFloPay: () => loadFloPay
 });
 module.exports = __toCommonJS(index_exports);
@@ -490,6 +493,74 @@ var FloPayElements = class {
 
 // src/payment-api.ts
 var import_shared3 = require("@flopay/shared");
+
+// src/session-display-cache.ts
+var STORAGE_KEY_PREFIX = "flopay_session_display:";
+var DEFAULT_TTL_MS = 60 * 60 * 1e3;
+var memoryStore = /* @__PURE__ */ new Map();
+function storageKey(sessionId) {
+  return `${STORAGE_KEY_PREFIX}${sessionId}`;
+}
+function getSessionStorage() {
+  if (typeof window === "undefined") return null;
+  try {
+    return window.sessionStorage;
+  } catch {
+    return null;
+  }
+}
+function cacheSessionDisplayData(sessionId, data, options) {
+  if (!sessionId) return;
+  const ttl = options?.ttlMs ?? DEFAULT_TTL_MS;
+  const entry = { data, expiresAt: Date.now() + ttl };
+  const storage = getSessionStorage();
+  if (storage) {
+    try {
+      storage.setItem(storageKey(sessionId), JSON.stringify(entry));
+      return;
+    } catch {
+    }
+  }
+  memoryStore.set(sessionId, entry);
+}
+function getSessionDisplayData(sessionId) {
+  if (!sessionId) return null;
+  const storage = getSessionStorage();
+  if (storage) {
+    try {
+      const raw = storage.getItem(storageKey(sessionId));
+      if (raw) {
+        const entry = JSON.parse(raw);
+        if (entry && typeof entry.expiresAt === "number" && entry.expiresAt > Date.now()) {
+          return entry.data;
+        }
+        storage.removeItem(storageKey(sessionId));
+      }
+    } catch {
+    }
+  }
+  const memEntry = memoryStore.get(sessionId);
+  if (memEntry) {
+    if (memEntry.expiresAt > Date.now()) {
+      return memEntry.data;
+    }
+    memoryStore.delete(sessionId);
+  }
+  return null;
+}
+function clearSessionDisplayData(sessionId) {
+  if (!sessionId) return;
+  memoryStore.delete(sessionId);
+  const storage = getSessionStorage();
+  if (storage) {
+    try {
+      storage.removeItem(storageKey(sessionId));
+    } catch {
+    }
+  }
+}
+
+// src/payment-api.ts
 var DEFAULT_PROCESSING_RETRY_AFTER_MS = 1e3;
 var MIN_PROCESSING_RETRY_AFTER_MS = 500;
 var DEFAULT_PROCESSING_TIMEOUT_MS = 15e3;
@@ -537,7 +608,37 @@ var PaymentAPI = class {
     if (!response.ok) {
       throw await buildApiErrorFromResponse(response, "Failed to get checkout session");
     }
-    return response.json();
+    const body = await response.json();
+    return { ...body, data: this.mergeCachedDisplayData(body.data) };
+  }
+  /**
+   * Stash display-only data for a session so subsequent fetches can fill in
+   * fields the backend no longer persists (`overrideAmount`, `totalAmount`,
+   * `providerItemName`, `providerPlanName`).
+   *
+   * Backed by `sessionStorage` in the browser, with an in-memory fallback in
+   * Node/SSR contexts. Default TTL: 1 hour.
+   *
+   * Server-returned values always win — cached values fill in only where the
+   * server returned `null` / `undefined`.
+   *
+   * @example
+   * ```ts
+   * paymentAPI.cacheSessionDisplayData(sessionId, {
+   *   currency: 'USD',
+   *   items: [{ code: 'pro_plan', overrideAmount: 24.99, providerItemName: 'Pro' }],
+   * });
+   * ```
+   */
+  cacheSessionDisplayData(sessionId, data, options) {
+    cacheSessionDisplayData(sessionId, data, options);
+  }
+  /**
+   * Drop any cached display data for a session. Call after the payment
+   * completes; otherwise the TTL handles cleanup.
+   */
+  clearSessionDisplayData(sessionId) {
+    clearSessionDisplayData(sessionId);
   }
   /**
    * Fetch and normalize a checkout session.
@@ -641,27 +742,19 @@ var PaymentAPI = class {
    * Falls back to create + GET if the backend doesn't support `expand`.
    */
   async createAndFetchSession(params) {
+    const sessionCurrency = (0, import_shared3.resolveSessionCurrency)(
+      params.currency,
+      params.items,
+      params.subscriptions
+    );
     const payload = {
       clientId: params.clientId,
       successUrl: params.successUrl,
       cancelUrl: params.cancelUrl,
+      currency: sessionCurrency,
       checkoutMode: params.checkoutMode ?? "full",
-      items: (params.items ?? []).map((item) => ({
-        providerItemId: item.providerItemId,
-        providerItemName: item.providerItemName ?? null,
-        quantity: item.quantity ?? 1,
-        totalAmount: item.totalAmount,
-        overrideAmount: item.overrideAmount ?? null,
-        currency: item.currency ?? "USD"
-      })),
-      subscriptions: (params.subscriptions ?? []).map((sub) => ({
-        providerPlanId: sub.providerPlanId,
-        providerPlanName: sub.providerPlanName ?? null,
-        quantity: sub.quantity ?? 1,
-        totalAmount: sub.totalAmount,
-        overrideAmount: sub.overrideAmount ?? null,
-        currency: sub.currency ?? "USD"
-      })),
+      items: (params.items ?? []).map((item) => (0, import_shared3.buildItemPayload)(item, sessionCurrency)),
+      subscriptions: (params.subscriptions ?? []).map((sub) => (0, import_shared3.buildSubscriptionPayload)(sub, sessionCurrency)),
       accountData: {
         userId: params.account.userId,
         firstName: params.account.firstName ?? null,
@@ -704,8 +797,10 @@ var PaymentAPI = class {
     }
     const body = await response.json();
     if (body.data && "gateway" in body.data) {
+      this.autoCacheDisplayData(body.data.uuid, params);
+      const merged = this.mergeCachedDisplayData(body.data);
       return {
-        ...this.normalizeRawSession(body.data),
+        ...this.normalizeRawSession(merged),
         autoProcessingError: body.autoProcessingError,
         autoProcessingAttempted: body.autoProcessingAttempted,
         autoProcessingPending: body.autoProcessingPending
@@ -715,6 +810,7 @@ var PaymentAPI = class {
     if (!uuid) {
       throw new import_shared3.FloPayError("No session ID returned", "api_error");
     }
+    this.autoCacheDisplayData(uuid, params);
     const unifiedSession = await this.getUnifiedCheckoutSession(uuid);
     return {
       ...unifiedSession,
@@ -794,10 +890,11 @@ var PaymentAPI = class {
   /** Convert raw session to the SDK CheckoutSession shape. */
   toCheckoutSession(raw) {
     const totalAmount = [
-      ...raw.subscriptions.map((s) => s.overrideAmount || s.totalAmount),
-      ...raw.items.map((i) => i.overrideAmount || i.totalAmount)
+      ...raw.subscriptions.map((s) => s.overrideAmount ?? s.totalAmount ?? 0),
+      ...raw.items.map((i) => i.overrideAmount ?? i.totalAmount ?? 0)
     ].reduce((sum, val) => sum + val, 0);
     const amountInCents = Math.round(totalAmount * 100);
+    const currency = raw.currency ?? raw.subscriptions[0]?.currency ?? raw.items[0]?.currency ?? "USD";
     return {
       // Core fields (backward compat)
       id: raw.uuid,
@@ -805,7 +902,7 @@ var PaymentAPI = class {
       mode: raw.subscriptions.length > 0 ? "subscription" : "payment",
       status: this.toCheckoutSessionStatus(raw.status),
       amount: amountInCents,
-      currency: raw.subscriptions[0]?.currency ?? raw.items[0]?.currency ?? "USD",
+      currency,
       customer: {
         id: raw.accountData.userId,
         email: raw.accountData.email,
@@ -882,6 +979,76 @@ var PaymentAPI = class {
   clampRetryAfterMs(retryAfterMs) {
     return Math.max(0, Math.min(retryAfterMs, MAX_PROCESSING_RETRY_AFTER_MS));
   }
+  /**
+   * Stash the display-only fields the consumer passed into a create-session
+   * call. Runs after the backend assigns a UUID so a later GET on the same
+   * session (typically after a redirect) can fill in fields the backend no
+   * longer persists — `overrideAmount`, `totalAmount`, `itemName`, etc.
+   *
+   * No-op when no UUID is available.
+   */
+  autoCacheDisplayData(sessionId, params) {
+    if (!sessionId) return;
+    if (!params.items?.length && !params.subscriptions?.length && !params.currency) {
+      return;
+    }
+    cacheSessionDisplayData(sessionId, {
+      currency: params.currency,
+      items: params.items,
+      subscriptions: params.subscriptions
+    });
+  }
+  /**
+   * Merge cached display-only fields (set by {@link cacheSessionDisplayData})
+   * into a raw session response and mirror the new/legacy name aliases so
+   * readers using either field always get a value when one exists.
+   *
+   * Server values always win — cache fills in only where the server returned
+   * `null` / `undefined`.
+   */
+  mergeCachedDisplayData(raw) {
+    const cached = getSessionDisplayData(raw.uuid);
+    const cachedItems = /* @__PURE__ */ new Map();
+    for (const item of cached?.items ?? []) {
+      const key = item.code ?? item.providerItemId;
+      if (key) cachedItems.set(key, item);
+    }
+    const cachedSubs = /* @__PURE__ */ new Map();
+    for (const sub of cached?.subscriptions ?? []) {
+      const key = sub.code ?? sub.providerPlanId;
+      if (key) cachedSubs.set(key, sub);
+    }
+    return {
+      ...raw,
+      currency: raw.currency ?? cached?.currency,
+      items: raw.items.map((item) => {
+        const key = item.code ?? item.providerItemId;
+        const fallback = key ? cachedItems.get(key) : void 0;
+        const resolvedName = item.itemName ?? item.providerItemName ?? fallback?.itemName ?? fallback?.providerItemName;
+        return {
+          ...item,
+          itemName: resolvedName,
+          providerItemName: resolvedName,
+          totalAmount: item.totalAmount ?? fallback?.totalAmount,
+          overrideAmount: item.overrideAmount ?? fallback?.overrideAmount,
+          currency: item.currency ?? fallback?.currency
+        };
+      }),
+      subscriptions: raw.subscriptions.map((sub) => {
+        const key = sub.code ?? sub.providerPlanId;
+        const fallback = key ? cachedSubs.get(key) : void 0;
+        const resolvedName = sub.subscriptionName ?? sub.providerPlanName ?? fallback?.subscriptionName ?? fallback?.providerPlanName;
+        return {
+          ...sub,
+          subscriptionName: resolvedName,
+          providerPlanName: resolvedName,
+          totalAmount: sub.totalAmount ?? fallback?.totalAmount,
+          overrideAmount: sub.overrideAmount ?? fallback?.overrideAmount,
+          currency: sub.currency ?? fallback?.currency
+        };
+      })
+    };
+  }
 };
 
 // src/flopay.ts
@@ -1015,6 +1182,7 @@ async function loadFloPay(publishableKey, options) {
 }
 
 // src/create-checkout-session.ts
+var import_shared6 = require("@flopay/shared");
 async function createCheckoutSession(options) {
   const {
     billingApiUrl,
@@ -1031,29 +1199,18 @@ async function createCheckoutSession(options) {
     setCookie = true,
     timeoutMs = 12e3,
     clientId,
+    currency,
     utmMetadata
   } = options;
+  const sessionCurrency = (0, import_shared6.resolveSessionCurrency)(currency, items, subscriptions);
   const payload = {
     clientId,
     successUrl,
     cancelUrl,
+    currency: sessionCurrency,
     checkoutMode,
-    items: items.map((item) => ({
-      providerItemId: item.providerItemId,
-      providerItemName: item.providerItemName ?? null,
-      quantity: item.quantity ?? 1,
-      totalAmount: item.totalAmount,
-      overrideAmount: item.overrideAmount ?? null,
-      currency: item.currency ?? "USD"
-    })),
-    subscriptions: subscriptions.map((sub) => ({
-      providerPlanId: sub.providerPlanId,
-      providerPlanName: sub.providerPlanName ?? null,
-      quantity: sub.quantity ?? 1,
-      totalAmount: sub.totalAmount,
-      overrideAmount: sub.overrideAmount ?? null,
-      currency: sub.currency ?? "USD"
-    })),
+    items: items.map((item) => (0, import_shared6.buildItemPayload)(item, sessionCurrency)),
+    subscriptions: subscriptions.map((sub) => (0, import_shared6.buildSubscriptionPayload)(sub, sessionCurrency)),
     accountData: {
       userId: account.userId,
       firstName: account.firstName ?? null,
@@ -1100,6 +1257,13 @@ async function createCheckoutSession(options) {
     if (!uuid) {
       throw new Error("Checkout session created but no UUID was returned by the billing API");
     }
+    if (items.length || subscriptions.length || currency) {
+      cacheSessionDisplayData(uuid, {
+        currency,
+        items,
+        subscriptions
+      });
+    }
     const redirectUrl = new URL(`${checkoutBaseUrl.replace(/\/+$/, "")}/secure`);
     redirectUrl.searchParams.set("id", uuid);
     for (const [key, value] of Object.entries(redirectParams)) {
@@ -1149,8 +1313,11 @@ async function createCheckoutSessionWithRetries(options) {
   FloPayElements,
   PaymentAPI,
   StripeAdapter,
+  cacheSessionDisplayData,
+  clearSessionDisplayData,
   createCheckoutSession,
   createCheckoutSessionWithRetries,
+  getSessionDisplayData,
   loadFloPay
 });
 //# sourceMappingURL=index.cjs.map