@fantastic.dev/better-stripe 0.9.0 → 0.10.1

package/src/component/settlement-claims.test.ts

@@ -0,0 +1,77 @@
+// @vitest-environment edge-runtime
+import { convexTest } from "convex-test";
+import { expect, it } from "vitest";
+import { api } from "./_generated/api.js";
+import schema from "./schema.js";
+const modules = import.meta.glob("./**/*.*s");
+it("keeps a claimed allocation immutable and isolated per source charge", async () => {
+  const t = convexTest(schema, modules);
+  const opts = {
+    sourceChargeId: "ch_1",
+    paymentIntentId: "pi_1",
+    gross: 100,
+    currency: "usd",
+    processingFee: 3,
+    platformNet: 7,
+    transfers: [
+      { destinationAccountId: "acct_c", amount: 90, role: "store" as const },
+    ],
+  };
+  const first = await t.mutation(
+    api.settlement.mutations.reserveSettlementAllocation,
+    opts,
+  );
+  const replay = await t.mutation(
+    api.settlement.mutations.reserveSettlementAllocation,
+    {
+      ...opts,
+      transfers: [{ ...opts.transfers[0], amount: 80 }],
+      platformNet: 17,
+    },
+  );
+  expect(replay).toEqual(first);
+  await expect(
+    t.mutation(api.settlement.mutations.reserveSettlementAllocation, {
+      ...opts,
+      sourceChargeId: "ch_invalid",
+      gross: 1,
+    }),
+  ).rejects.toThrow();
+});
+it("persists the term, identity and earliest invoice despite replay and term changes", async () => {
+  const t = convexTest(schema, modules);
+  const opts = {
+    subscriptionId: "sub_1",
+    invoiceId: "in_renewal",
+    firstPaidInvoiceId: "in_first",
+    term: "one_time" as const,
+    affiliateAccountId: "acct_a",
+  };
+  expect(
+    await t.mutation(api.settlement.mutations.claimCommissionInvoice, opts),
+  ).toMatchObject({
+    eligible: false,
+    firstPaidInvoiceId: "in_first",
+    term: "one_time",
+    replay: false,
+  });
+  expect(
+    await t.mutation(api.settlement.mutations.claimCommissionInvoice, {
+      ...opts,
+      invoiceId: "in_first",
+      term: "forever",
+    }),
+  ).toMatchObject({ eligible: true, term: "one_time" });
+  expect(
+    await t.mutation(api.settlement.mutations.claimCommissionInvoice, {
+      ...opts,
+      invoiceId: "in_first",
+    }),
+  ).toMatchObject({ eligible: true, replay: true });
+  await expect(
+    t.mutation(api.settlement.mutations.claimCommissionInvoice, {
+      ...opts,
+      affiliateAccountId: "acct_other",
+    }),
+  ).rejects.toThrow();
+});

package/src/react/components/EmbeddedDisputes.render.test.tsx

@@ -10,6 +10,7 @@
  * tree rendering without throwing via react-dom/server, the disputes_list vs
  * payment_disputes mount switch, and the headless overrides.
  */
+import * as barrel from "../index.js";
 import { createElement } from "react";
 import { renderToStaticMarkup } from "react-dom/server";
 import { beforeEach, describe, expect, it, vi } from "vitest";
@@ -136,8 +137,7 @@ describe("EmbeddedDisputes", () => {
 });
 
 describe("react barrel exports", () => {
-  it("exports ConnectProvider and EmbeddedDisputes", async () => {
-    const barrel = await import("../index.js");
+  it("exports ConnectProvider and EmbeddedDisputes", () => {
     expect(barrel.ConnectProvider).toBe(ConnectProvider);
     expect(barrel.EmbeddedDisputes).toBe(EmbeddedDisputes);
   });

package/src/react/index.payment-element.test.ts

@@ -1,41 +1,26 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { describe, expect, it, vi } from "vitest";
+
+const elements = vi.hoisted(() => ({
+  checkout: Symbol("checkout-payment-element"),
+  paymentIntent: Symbol("elements-payment-element"),
+}));
+vi.mock("@stripe/react-stripe-js", async () => ({
+  ...(await vi.importActual<typeof import("@stripe/react-stripe-js")>(
+    "@stripe/react-stripe-js",
+  )),
+  PaymentElement: elements.paymentIntent,
+}));
+vi.mock("@stripe/react-stripe-js/checkout", async () => ({
+  ...(await vi.importActual<typeof import("@stripe/react-stripe-js/checkout")>(
+    "@stripe/react-stripe-js/checkout",
+  )),
+  PaymentElement: elements.checkout,
+}));
+import * as reactExports from "./index.js";
 
 describe("better-stripe/react PaymentElement exports", () => {
-  afterEach(() => {
-    vi.resetModules();
-    vi.doUnmock("@stripe/react-stripe-js");
-    vi.doUnmock("@stripe/react-stripe-js/checkout");
-  });
-
-  it("uses checkout PaymentElement as the default export and keeps the Elements variant aliased", async () => {
-    const checkoutPaymentElement = Symbol("checkout-payment-element");
-    const elementsPaymentElement = Symbol("elements-payment-element");
-
-    vi.doMock("@stripe/react-stripe-js", async () => {
-      const actual = await vi.importActual<
-        typeof import("@stripe/react-stripe-js")
-      >("@stripe/react-stripe-js");
-
-      return {
-        ...actual,
-        PaymentElement: elementsPaymentElement,
-      };
-    });
-
-    vi.doMock("@stripe/react-stripe-js/checkout", async () => {
-      const actual = await vi.importActual<
-        typeof import("@stripe/react-stripe-js/checkout")
-      >("@stripe/react-stripe-js/checkout");
-
-      return {
-        ...actual,
-        PaymentElement: checkoutPaymentElement,
-      };
-    });
-
-    const reactExports = await import("./index.js");
-
-    expect(reactExports.PaymentElement).toBe(checkoutPaymentElement);
-    expect(reactExports.ElementsPaymentElement).toBe(elementsPaymentElement);
+  it("uses checkout PaymentElement as the default export and keeps the Elements variant aliased", () => {
+    expect(reactExports.PaymentElement).toBe(elements.checkout);
+    expect(reactExports.ElementsPaymentElement).toBe(elements.paymentIntent);
   });
 });

package/src/react/workflows/Checkout.test.tsx

@@ -83,6 +83,9 @@ it("exposes creation errors and retries without losing the selected integration"
   await userEvent.click(screen.getByRole("button", { name: "Retry" }));
   await screen.findByText("Stripe iframe");
   await waitFor(() => expect(createSession).toHaveBeenCalledTimes(2));
+  expect(createSession.mock.calls[1][0].requestId).toBe(
+    createSession.mock.calls[0][0].requestId,
+  );
 });
 it("rejects missing session secrets and initializes Payment Intents through their own callback", async () => {
   const { unmount } = render(
@@ -116,3 +119,30 @@ it("rejects missing session secrets and initializes Payment Intents through thei
     requestId: expect.any(String),
   });
 });
+
+it("keeps an explicit request identity through rerenders and replaces generated identity for a new order", async () => {
+  const createSession = vi
+    .fn()
+    .mockResolvedValue({ stripeSessionId: "cs_test", clientSecret: "secret" });
+  const props = {
+    mode: "embedded" as const,
+    orderKey: "order_one",
+    publishableKey: "pk_test",
+    returnUrl: "https://app.test/receipt",
+    createSession,
+  };
+  const { rerender } = render(
+    <Checkout {...props} requestId="persisted-order" />,
+  );
+  await screen.findByText("Stripe iframe");
+  expect(createSession.mock.calls[0][0].requestId).toBe("persisted-order");
+  rerender(<Checkout {...props} requestId="persisted-order" />);
+  expect(createSession).toHaveBeenCalledTimes(1);
+  rerender(<Checkout {...props} orderKey="order_two" />);
+  await waitFor(() => expect(createSession).toHaveBeenCalledTimes(2));
+  const second = createSession.mock.calls[1][0].requestId;
+  expect(second).not.toBe("persisted-order");
+  rerender(<Checkout {...props} orderKey="order_three" />);
+  await waitFor(() => expect(createSession).toHaveBeenCalledTimes(3));
+  expect(createSession.mock.calls[2][0].requestId).not.toBe(second);
+});

package/src/react/workflows/Checkout.tsx

@@ -1,5 +1,5 @@
 "use client";
-import type { ReactNode } from "react";
+import { useState, type ReactNode } from "react";
 import { EmbeddedCheckout } from "../components/EmbeddedCheckout.js";
 import { useWorkflowResource } from "./useWorkflowResource.js";
 import {
@@ -36,6 +36,8 @@ type Common = CheckoutFormOptions & {
   publishableKey: string;
   /** Changes when the price, signed-in customer, or referral attribution changes. */
   orderKey: string;
+  /** Optional durable logical-order identity, persisted by the host app. */
+  requestId?: string;
   returnUrl: string;
   onNavigate?: (url: string) => void;
   children?: (state: CheckoutRenderProps) => ReactNode;
@@ -57,11 +59,16 @@ export type CheckoutProps = Common &
   );
 /** All checkout integrations share one unstyled lifecycle. Callbacks must authenticate and validate prices on the server. */
 export function Checkout(props: CheckoutProps) {
-  return <CheckoutBody key={`${props.orderKey}:${props.mode}`} {...props} />;
+  return (
+    <CheckoutBody
+      key={`${props.orderKey}:${props.mode}:${props.requestId ?? ""}`}
+      {...props}
+    />
+  );
 }
 function CheckoutBody(props: CheckoutProps) {
+  const [requestId] = useState(() => props.requestId ?? crypto.randomUUID());
   const state = useWorkflowResource(async () => {
-    const requestId = crypto.randomUUID();
     const result =
       props.mode === "payment-intent"
         ? await props.createPaymentIntent({ requestId })

package/src/react/workflows/Payouts.test.tsx

@@ -110,3 +110,36 @@ it("keeps completed payouts out of upcoming and sorts the remaining arrivals", a
   );
   expect(screen.getAllByText("po_paid")).toHaveLength(1);
 });
+it("distinguishes an unavailable account from an empty balance and labels upcoming previews", async () => {
+  const load = vi.fn().mockResolvedValue({
+    status: "not_ready",
+    reason: "account_unavailable",
+    balances: [],
+    upcoming: [],
+    payouts: [],
+    nextCursor: null,
+    upcomingComplete: true,
+  });
+  const { unmount } = render(<Payouts scopeKey="unavailable" load={load} />);
+  expect((await screen.findByRole("alert")).textContent).toContain(
+    "not available",
+  );
+  expect(screen.queryByText("Not scheduled")).toBeNull();
+  unmount();
+  render(
+    <Payouts
+      scopeKey="preview"
+      load={async () => ({
+        status: "ready",
+        balances: [],
+        upcoming: [],
+        payouts: [],
+        nextCursor: null,
+        upcomingComplete: false,
+      })}
+    />,
+  );
+  expect(
+    await screen.findByText(/Upcoming payouts are a bounded preview/),
+  ).toBeTruthy();
+});

package/src/react/workflows/Payouts.tsx

@@ -1,4 +1,8 @@
 "use client";
+import type {
+  RecipientPayoutSnapshot,
+  RecipientPayoutRow,
+} from "../../client/connect/payoutSnapshot.js";
 import { useState, type ReactNode } from "react";
 import { Connect, type ConnectProps } from "./Connect.js";
 import { useWorkflowAction } from "./useWorkflowAction.js";
@@ -9,20 +13,14 @@ import {
   type WorkflowColumn,
 } from "./Collection.js";
 import { formatPrice } from "../lib/price-helpers.js";
-export type PayoutRow = {
-  id: string;
-  amount: number;
-  currency: string;
-  status: string;
-  /** Unix milliseconds. */ arrivalDate: number | null;
-  created: number;
-};
-export type PayoutSnapshot = {
-  balances: { currency: string; available: number; pending: number }[];
-  payouts: PayoutRow[];
-  upcoming: PayoutRow[];
-  nextCursor: string | null;
-};
+export type PayoutRow = RecipientPayoutRow;
+export type PayoutSnapshot = Pick<
+  RecipientPayoutSnapshot,
+  "balances" | "payouts" | "upcoming" | "nextCursor"
+> &
+  Partial<
+    Pick<RecipientPayoutSnapshot, "status" | "reason" | "upcomingComplete">
+  >;
 export type PayoutsRenderProps = {
   data: PayoutSnapshot | undefined;
   error: string | null;
@@ -169,7 +167,10 @@ function NativePayouts({
       </button>
       {error && <p role="alert">{error}</p>}
       {isLoading && !data && <p role="status">Loading payouts…</p>}
-      {data && (
+      {data?.status === "not_ready" && (
+        <p role="alert">Stripe account data is not available yet.</p>
+      )}
+      {data && data.status !== "not_ready" && (
         <>
           <dl>
             {data.balances.map((balance) => (
@@ -188,6 +189,11 @@ function NativePayouts({
             </dd>
           </dl>
           <h3>Upcoming payouts</h3>
+          {data.upcomingComplete === false && (
+            <p>
+              Upcoming payouts are a bounded preview. More may be scheduled.
+            </p>
+          )}
           <PayoutHistory
             rows={upcomingPayouts}
             emptyLabel="No upcoming payouts scheduled."