@fantastic.dev/better-stripe 0.6.0 → 0.7.0

package/src/component/connect/mutations.ts

@@ -1,7 +1,7 @@
 import { v } from "convex/values";
 
-import type { Id } from "../_generated/dataModel";
-import { mutation } from "../_generated/server";
+import type { Doc, Id } from "../_generated/dataModel";
+import { mutation, type MutationCtx } from "../_generated/server";
 import { feeRoutingFields } from "../lib/fees";
 import { computeReversalSlices } from "../lib/reversals";
 import {
@@ -12,6 +12,20 @@ import {
   transferFields,
 } from "./validators";
 
+async function paymentSeller(
+  ctx: MutationCtx,
+  stripePaymentIntentId?: string,
+): Promise<string | undefined> {
+  if (!stripePaymentIntentId) return undefined;
+  const payment = await ctx.db
+    .query("payments")
+    .withIndex("by_stripe_payment_intent_id", (q) =>
+      q.eq("stripePaymentIntentId", stripePaymentIntentId),
+    )
+    .first();
+  return payment?.destinationAccountId;
+}
+
 // =============================================================================
 // PAYMENT MUTATIONS
 // =============================================================================
@@ -87,6 +101,26 @@ export const upsertPayment = mutation({
       }
     }
 
+    // A refund/dispute can arrive before the platform charge has its seller
+    // routing metadata. Reconcile those case owners once routing is known.
+    const sellerAccountId =
+      args.destinationAccountId ?? existing?.destinationAccountId;
+    if (sellerAccountId) {
+      for (const table of ["refunds", "disputes"] as const) {
+        const cases = await ctx.db
+          .query(table)
+          .withIndex("by_stripe_payment_intent_id", (q) =>
+            q.eq("stripePaymentIntentId", args.stripePaymentIntentId),
+          )
+          .take(100);
+        for (const record of cases)
+          if (!record.accountId)
+            await ctx.db.patch(table, record._id, {
+              accountId: sellerAccountId,
+            });
+      }
+    }
+
     return null;
   },
 });
@@ -140,10 +174,13 @@ export const upsertRefund = mutation({
       )
       .first();
 
+    const accountId =
+      args.accountId ?? (await paymentSeller(ctx, args.stripePaymentIntentId));
+    const record = { ...args, ...(accountId ? { accountId } : {}) };
     if (existing) {
-      await ctx.db.patch("refunds", existing._id, args);
+      await ctx.db.patch("refunds", existing._id, record);
     } else {
-      await ctx.db.insert("refunds", args);
+      await ctx.db.insert("refunds", record);
     }
 
     // Denormalize cumulative refund state onto the linked `payments` row so
@@ -278,10 +315,13 @@ export const upsertDispute = mutation({
       )
       .first();
 
+    const accountId =
+      args.accountId ?? (await paymentSeller(ctx, args.stripePaymentIntentId));
+    const record = { ...args, ...(accountId ? { accountId } : {}) };
     if (existing) {
-      await ctx.db.patch("disputes", existing._id, args);
+      await ctx.db.patch("disputes", existing._id, record);
     } else {
-      await ctx.db.insert("disputes", args);
+      await ctx.db.insert("disputes", record);
     }
 
     return null;
@@ -311,7 +351,8 @@ function deriveReversalState(
   return {
     reversedAmount: reversedAmount > 0 ? reversedAmount : undefined,
     reversalStatus,
-    status: reversalStatus === "fully_reversed" ? ("reversed" as const) : baseStatus,
+    status:
+      reversalStatus === "fully_reversed" ? ("reversed" as const) : baseStatus,
   };
 }
 
@@ -333,7 +374,11 @@ export const upsertTransfer = mutation({
         existing.reversedAmount ?? 0,
         args.reversedAmount ?? 0,
       );
-      const derived = deriveReversalState(args.amount, reversedAmount, args.status);
+      const derived = deriveReversalState(
+        args.amount,
+        reversedAmount,
+        args.status,
+      );
       await ctx.db.patch("transfers", existing._id, { ...args, ...derived });
     } else {
       const derived = deriveReversalState(
@@ -459,21 +504,27 @@ export const claimReversalSlices = mutation({
     if (existingOp) {
       const slices = [];
       for (const s of existingOp.slices) {
-        slices.push({ ...s, confirmed: await confirmedFor(s.stripeTransferId) });
+        slices.push({
+          ...s,
+          confirmed: await confirmedFor(s.stripeTransferId),
+        });
       }
       return { replay: true, slices };
     }
 
     // Original split legs only — reinstatement payouts are audit rows and
     // must never be re-reversed (mirrors listTransfersByCharge).
-    const rows = (
-      await ctx.db
-        .query("transfers")
-        .withIndex("by_source_charge_id", (q) =>
-          q.eq("sourceChargeId", args.sourceChargeId),
-        )
-        .take(50)
-    ).filter((t) => !t.reinstatement);
+    // Claim every original split leg, including those beyond the former
+    // 50-row preview. Read/write limits abort the transaction before a partial
+    // claim can commit; no Stripe call happens until this mutation succeeds.
+    const rows: Doc<"transfers">[] = [];
+    for await (const transfer of ctx.db
+      .query("transfers")
+      .withIndex("by_source_charge_id", (q) =>
+        q.eq("sourceChargeId", args.sourceChargeId),
+      )) {
+      if (!transfer.reinstatement) rows.push(transfer);
+    }
 
     const byId = new Map(rows.map((r) => [r.stripeTransferId, r]));
     const slices = computeReversalSlices(

package/src/component/connect/queries.ts

@@ -293,24 +293,32 @@ export const getTransferByStripeId = query({
 /**
  * All transfers funded from one charge (the legs of a split).
  *
- * ⚠️ CAPPED at `limit ?? 50` rows. Unlike the per-account earnings view this is
- * safe in practice — a single sale has a handful of split legs, far below the
- * cap (BTS-64) — but pass a higher `limit` if you ever split across many
- * recipients.
+ * Returns every original split leg unless an explicit limit is provided.
+ * Reinstatement audit rows do not consume that limit. Database read/response
+ * limits fail the query rather than silently returning incomplete money data.
  */
 export const listTransfersByCharge = query({
   args: { sourceChargeId: v.string(), limit: v.optional(v.number()) },
   returns: v.array(transferDocValidator),
   handler: async (ctx, args) => {
-    const rows = await ctx.db
+    if (
+      args.limit !== undefined &&
+      (!Number.isInteger(args.limit) || args.limit < 0)
+    ) {
+      throw new Error("limit must be a non-negative integer");
+    }
+    const rows: Doc<"transfers">[] = [];
+    if (args.limit === 0) return rows;
+    for await (const transfer of ctx.db
       .query("transfers")
       .withIndex("by_source_charge_id", (q) =>
         q.eq("sourceChargeId", args.sourceChargeId),
-      )
-      .take(args.limit ?? 50);
-    // Exclude reinstatement payouts — this returns the original split legs the
-    // reverse/split engines act on (reinstatement rows are audit-only here).
-    return rows.filter((t) => !t.reinstatement);
+      )) {
+      if (transfer.reinstatement) continue;
+      rows.push(transfer);
+      if (args.limit !== undefined && rows.length >= args.limit) break;
+    }
+    return rows;
   },
 });
 

package/src/component/reversal-races.test.ts

@@ -296,7 +296,47 @@ describe("BTS-63 race 1 — refund path: concurrent DISTINCT refunds must not do
 });
 
 describe("BTS-63 race 2 — dispute path: retry after partial success must converge", () => {
-  const DISPUTE = { sourceChargeId: "ch_dp", amount: 4500, operationId: "dp_1" };
+  it("claws back all 120 legs and converges after a failure beyond the former cap", async () => {
+    const t = convexTest(schema, modules);
+    const ctx = makeCtx(t);
+    const component = proxyComponent();
+    const stripe = makeRacingStripe();
+    for (let i = 0; i < 120; i++) {
+      await seedLeg(t, {
+        stripeTransferId: `tr_large_${i}`,
+        sourceChargeId: "ch_large",
+        amount: 100,
+      });
+    }
+    const opts = {
+      sourceChargeId: "ch_large",
+      amount: 6000,
+      operationId: "dispute_large",
+    };
+    stripe.failNextCallFor("tr_large_75");
+    await expect(
+      reverseTransfers(asStripe(stripe), component, ctx, opts),
+    ).rejects.toThrow(/network error/);
+    await reverseTransfers(asStripe(stripe), component, ctx, opts);
+    // A further redelivery must not move money or conflict with earlier keys.
+    await reverseTransfers(asStripe(stripe), component, ctx, opts);
+    const rows = await t.query(api.connect.queries.listTransfersByCharge, {
+      sourceChargeId: "ch_large",
+    });
+    expect(rows).toHaveLength(120);
+    expect(rows.reduce((sum, row) => sum + (row.reversedAmount ?? 0), 0)).toBe(
+      6000,
+    );
+    for (const row of rows) {
+      expect(row.reversedAmount).toBe(50);
+      expect(stripe.total(row.stripeTransferId)).toBe(50);
+    }
+  });
+  const DISPUTE = {
+    sourceChargeId: "ch_dp",
+    amount: 4500,
+    operationId: "dp_1",
+  };
 
   async function seedDisputeLegs(t: ReturnType<typeof convexTest>) {
     await seedLeg(t, {

package/src/component/seller-case-ownership.test.ts

@@ -0,0 +1,61 @@
+import { convexTest } from "convex-test";
+import { expect, it } from "vitest";
+import { api } from "./_generated/api";
+import schema from "./schema";
+const modules = import.meta.glob("./**/*.*s");
+const payment = {
+  stripePaymentIntentId: "pi_sale",
+  userId: "customer",
+  amount: 10000,
+  currency: "usd",
+  status: "succeeded" as const,
+  destinationAccountId: "acct_store",
+  chargeType: "separate" as const,
+};
+const refund = {
+  stripeRefundId: "re_sale",
+  stripePaymentIntentId: "pi_sale",
+  amount: 1000,
+  currency: "usd",
+  status: "succeeded" as const,
+};
+const dispute = {
+  stripeDisputeId: "dp_sale",
+  stripePaymentIntentId: "pi_sale",
+  amount: 10000,
+  currency: "usd",
+  status: "needs_response" as const,
+  reason: "product_not_received",
+  isChargeRefundable: false,
+};
+it("attributes refunds and disputes to the seller instead of the purchasing customer", async () => {
+  const t = convexTest(schema, modules);
+  await t.mutation(api.connect.mutations.upsertPayment, payment);
+  await t.mutation(api.connect.mutations.upsertRefund, refund);
+  await t.mutation(api.connect.mutations.upsertDispute, dispute);
+  expect(
+    await t.query(api.connect.queries.listRefunds, { accountId: "acct_store" }),
+  ).toHaveLength(1);
+  expect(
+    await t.query(api.connect.queries.listDisputes, {
+      accountId: "acct_store",
+    }),
+  ).toHaveLength(1);
+  expect(
+    await t.query(api.connect.queries.listRefunds, { accountId: "acct_other" }),
+  ).toHaveLength(0);
+});
+it("reconciles cases delivered before the seller's settlement metadata", async () => {
+  const t = convexTest(schema, modules);
+  await t.mutation(api.connect.mutations.upsertRefund, refund);
+  await t.mutation(api.connect.mutations.upsertDispute, dispute);
+  await t.mutation(api.connect.mutations.upsertPayment, payment);
+  expect(
+    await t.query(api.connect.queries.listRefunds, { accountId: "acct_store" }),
+  ).toHaveLength(1);
+  expect(
+    await t.query(api.connect.queries.listDisputes, {
+      accountId: "acct_store",
+    }),
+  ).toHaveLength(1);
+});

package/src/component/store-subscriptions.test.ts

@@ -0,0 +1,32 @@
+import { convexTest } from "convex-test";
+import { expect, it } from "vitest";
+import { api } from "./_generated/api";
+import schema from "./schema";
+const modules = import.meta.glob("./**/*.*s");
+it("scopes seller subscriptions by catalog price for both destination and split sales", async () => {
+  const t = convexTest(schema, modules);
+  await t.run(async (ctx) => {
+    for (const [id, priceId] of [
+      ["sub_direct", "price_seller"],
+      ["sub_referred", "price_seller"],
+      ["sub_other", "price_other"],
+    ]) {
+      await ctx.db.insert("subscriptions", {
+        stripeSubscriptionId: id,
+        priceId,
+        userId: "customer",
+        status: "active",
+        cancelAtPeriodEnd: false,
+        isTrialing: false,
+        isCollectionPaused: false,
+      });
+    }
+  });
+  const rows = await t.query(api.billing.queries.listSubscriptionsByPrice, {
+    priceId: "price_seller",
+  });
+  expect(rows.map((s) => s.stripeSubscriptionId).sort()).toEqual([
+    "sub_direct",
+    "sub_referred",
+  ]);
+});

package/src/component/transfers.test.ts

@@ -2,11 +2,80 @@
 import { convexTest } from "convex-test";
 import { describe, expect, it } from "vitest";
 
+import { createUseSplitBreakdown } from "../react/hooks/useSplitBreakdown.js";
+
 import { api } from "./_generated/api.js";
 import schema from "./schema.js";
 
 const modules = import.meta.glob("./**/*.*s");
 
+describe("complete split-leg reads", () => {
+  it("returns every original leg beyond the former 50-row cap and filters audit rows before limiting", async () => {
+    const t = convexTest(schema, modules);
+    await t.mutation(api.connect.mutations.upsertTransfer, {
+      stripeTransferId: "tr_audit_first",
+      sourceChargeId: "ch_many",
+      destinationAccountId: "acct_store",
+      amount: 100,
+      currency: "usd",
+      status: "paid",
+      reinstatement: true,
+    });
+    for (let i = 0; i < 120; i++) {
+      await t.mutation(api.connect.mutations.upsertTransfer, {
+        stripeTransferId: `tr_many_${i}`,
+        sourceChargeId: "ch_many",
+        destinationAccountId: `acct_${i}`,
+        amount: 100,
+        currency: "usd",
+        status: "paid",
+        role: i % 2 === 0 ? "store" : "affiliate",
+      });
+    }
+    const rows = await t.query(api.connect.queries.listTransfersByCharge, {
+      sourceChargeId: "ch_many",
+    });
+    expect(rows).toHaveLength(120);
+    expect(rows.reduce((sum, row) => sum + row.amount, 0)).toBe(12000);
+    expect(rows.some((row) => row.reinstatement)).toBe(false);
+    const useSplitBreakdown = createUseSplitBreakdown(
+      () => rows,
+      "chargeQuery",
+    );
+    expect(
+      useSplitBreakdown({ sourceChargeId: "ch_many", saleAmount: 13000 })
+        .breakdown,
+    ).toMatchObject({
+      store: 6000,
+      affiliate: 6000,
+      recipientsTotal: 12000,
+      platform: 1000,
+    });
+    const preview = await t.query(api.connect.queries.listTransfersByCharge, {
+      sourceChargeId: "ch_many",
+      limit: 50,
+    });
+    expect(preview).toHaveLength(50);
+    expect(preview[0].stripeTransferId).toBe("tr_many_0");
+    expect(
+      await t.query(api.connect.queries.listTransfersByCharge, {
+        sourceChargeId: "ch_many",
+        limit: 0,
+      }),
+    ).toEqual([]);
+  });
+
+  it.each([-1, 1.5])("rejects invalid explicit limit %s", async (limit) => {
+    const t = convexTest(schema, modules);
+    await expect(
+      t.query(api.connect.queries.listTransfersByCharge, {
+        sourceChargeId: "ch_many",
+        limit,
+      }),
+    ).rejects.toThrow("non-negative integer");
+  });
+});
+
 describe("transfers ledger (BTS-12)", () => {
   it("upserts a transfer and reads it back by stripe id", async () => {
     const t = convexTest(schema, modules);

package/src/react/hooks/useSplitBreakdown.ts

@@ -42,7 +42,7 @@ export type UseSplitBreakdownResult = {
 };
 
 /**
- * Factory for a per-sale split-breakdown hook (BTS-36): reads the sale's
+ * Factory for a per-sale split-breakdown hook: reads the sale's
  * original split legs (`listTransfersByCharge` — reinstatement rows are
  * excluded server-side) and sums them by role, with the platform's share
  * derived from the sale amount when provided. Presentation math only — the
@@ -51,11 +51,9 @@ export type UseSplitBreakdownResult = {
  * Pass `sourceChargeId: undefined` to skip the query. The `useQuery` binding
  * must support Convex's `"skip"` sentinel.
  *
- * Note (BTS-64): the underlying `listTransfersByCharge` query is capped at 50
- * rows. Unlike the per-account earnings totals this is safe in practice — a
- * single sale has only a handful of split legs — but a sale split across more
- * than 50 recipients would undercount here; pass a higher `limit` on that query
- * if you ever do that.
+ * Bind this to a query that returns every original leg for the charge. The
+ * component's `listTransfersByCharge` returns all legs by default; applying an
+ * explicit preview limit in the app's wrapper would understate these totals.
  */
 export function createUseSplitBreakdown(
   useQuery: (queryRef: any, args: Record<string, unknown> | "skip") => any,