@fantastic.dev/better-stripe 0.4.0 → 0.5.0

package/src/client/billing/checkout.test.ts

@@ -80,6 +80,9 @@ function makeCtx(queryResult?: unknown) {
 
 function makeStripe() {
   return {
+    prices: {
+      retrieve: vi.fn().mockRejectedValue({ code: "resource_missing" }),
+    },
     checkout: {
       sessions: {
         create: vi.fn(),
@@ -283,7 +286,9 @@ describe("createCheckoutSession", () => {
     });
 
     const createArg = stripe.checkout.sessions.create.mock.calls[0][0];
-    expect(createArg.line_items).toEqual([{ price: "price_seat", quantity: 5 }]);
+    expect(createArg.line_items).toEqual([
+      { price: "price_seat", quantity: 5 },
+    ]);
   });
 
   it("sets customer_account when accountId is provided", async () => {
@@ -679,8 +684,16 @@ describe("createCheckoutSession — N-recipient split (BTS-21)", () => {
     stripe.checkout.sessions.create.mockResolvedValue(sessionResponse());
     const ctx = makeCtx();
     const split = [
-      { destinationAccountId: "acct_store", role: "store" as const, percent: 80 },
-      { destinationAccountId: "acct_aff", role: "affiliate" as const, percent: 5 },
+      {
+        destinationAccountId: "acct_store",
+        role: "store" as const,
+        percent: 80,
+      },
+      {
+        destinationAccountId: "acct_aff",
+        role: "affiliate" as const,
+        percent: 5,
+      },
     ];
 
     await createCheckoutSession(asStripe(stripe), makeComponent(), ctx, {
@@ -695,8 +708,12 @@ describe("createCheckoutSession — N-recipient split (BTS-21)", () => {
 
     const createArg = stripe.checkout.sessions.create.mock.calls[0][0];
     expect(createArg.payment_intent_data.transfer_data).toBeUndefined();
-    expect(createArg.payment_intent_data.metadata.bsChargeType).toBe("separate");
-    expect(JSON.parse(createArg.payment_intent_data.metadata.bsSplit)).toHaveLength(2);
+    expect(createArg.payment_intent_data.metadata.bsChargeType).toBe(
+      "separate",
+    );
+    expect(
+      JSON.parse(createArg.payment_intent_data.metadata.bsSplit),
+    ).toHaveLength(2);
 
     const [, upsertArgs] = ctx.runMutation.mock.calls[0];
     expect(upsertArgs.chargeType).toBe("separate");
@@ -725,7 +742,9 @@ describe("createCheckoutSession — N-recipient split (BTS-21)", () => {
     expect(createArg.subscription_data.transfer_data).toBeUndefined();
     expect(createArg.subscription_data.application_fee_percent).toBeUndefined();
     expect(createArg.subscription_data.metadata.bsChargeType).toBe("separate");
-    expect(JSON.parse(createArg.subscription_data.metadata.bsSplit)).toHaveLength(2);
+    expect(
+      JSON.parse(createArg.subscription_data.metadata.bsSplit),
+    ).toHaveLength(2);
 
     const [, upsertArgs] = ctx.runMutation.mock.calls[0];
     expect(upsertArgs.chargeType).toBe("separate");
@@ -743,7 +762,9 @@ describe("createCheckoutSession — N-recipient split (BTS-21)", () => {
       mode: "subscription",
       returnUrl: "https://app.test/return",
       accountId: "acct_buyer",
-      split: [{ destinationAccountId: "acct_store", role: "store", percent: 90 }],
+      split: [
+        { destinationAccountId: "acct_store", role: "store", percent: 90 },
+      ],
       feeConfig: { percent: 10 },
     });
 
@@ -775,7 +796,9 @@ describe("createCheckoutSession — N-recipient split (BTS-21)", () => {
 
     const createArg = stripe.checkout.sessions.create.mock.calls[0][0];
     expect(createArg.payment_intent_data.transfer_data).toBeUndefined();
-    expect(createArg.payment_intent_data.metadata.bsChargeType).toBe("separate");
+    expect(createArg.payment_intent_data.metadata.bsChargeType).toBe(
+      "separate",
+    );
   });
 
   it("rejects split/destination/fee in setup mode", async () => {
@@ -789,7 +812,9 @@ describe("createCheckoutSession — N-recipient split (BTS-21)", () => {
         mode: "setup",
         returnUrl: "https://app.test/return",
         accountId: "acct_buyer",
-        split: [{ destinationAccountId: "acct_store", role: "store", amount: 100 }],
+        split: [
+          { destinationAccountId: "acct_store", role: "store", amount: 100 },
+        ],
       }),
     ).rejects.toThrow(/setup/i);
     expect(stripe.checkout.sessions.create).not.toHaveBeenCalled();
@@ -809,7 +834,8 @@ describe("createCheckoutSession — N-recipient split (BTS-21)", () => {
       // A non-split caller trying to forge webhook instructions.
       metadata: {
         bsChargeType: "separate",
-        bsSplit: '[{"destinationAccountId":"acct_evil","role":"store","amount":9999}]',
+        bsSplit:
+          '[{"destinationAccountId":"acct_evil","role":"store","amount":9999}]',
         plan: "pro",
       },
     });
@@ -881,6 +907,25 @@ describe("createCheckoutSession — price-on-platform validation (BTS-15)", () =
     });
   });
 
+  it("allows a platform price tagged to a store in the component catalog", async () => {
+    const stripe = makeStripe();
+    stripe.prices.retrieve.mockResolvedValue({ id: "price_1" });
+    stripe.checkout.sessions.create.mockResolvedValue(sessionResponse());
+    const ctx = routedCtx({
+      "products/queries/getPriceByStripeId": { stripeProductId: "prod_1" },
+      "products/queries/getProductByStripeId": { accountId: "acct_store" },
+    });
+    await createCheckoutSession(asStripe(stripe), makeComponent(), ctx, {
+      userId: "buyer_1",
+      stripePriceId: "price_1",
+      mode: "payment",
+      returnUrl: "https://app.test/return",
+      destinationAccountId: "acct_store",
+    });
+    expect(stripe.prices.retrieve).toHaveBeenCalledWith("price_1");
+    expect(stripe.checkout.sessions.create).toHaveBeenCalled();
+  });
+
   it("allows a destination charge for a platform-owned price", async () => {
     const stripe = makeStripe();
     stripe.checkout.sessions.create.mockResolvedValue(sessionResponse());
@@ -1005,7 +1050,10 @@ describe("getCheckoutSessionByStripeId", () => {
 
 describe("listCheckoutSessionsByUser", () => {
   it("forwards userId and optional status filter and returns the rows", async () => {
-    const ctx = makeCtx([{ stripeSessionId: "cs_a" }, { stripeSessionId: "cs_b" }]);
+    const ctx = makeCtx([
+      { stripeSessionId: "cs_a" },
+      { stripeSessionId: "cs_b" },
+    ]);
     const result = await listCheckoutSessionsByUser(makeComponent(), ctx, {
       userId: "user_1",
       status: "complete",
@@ -1157,9 +1205,9 @@ describe("createCheckoutSession — per-store statement descriptor (BTS-32)", ()
     });
 
     const createArg = stripe.checkout.sessions.create.mock.calls[0][0];
-    expect(
-      "statement_descriptor_suffix" in createArg.payment_intent_data,
-    ).toBe(false);
+    expect("statement_descriptor_suffix" in createArg.payment_intent_data).toBe(
+      false,
+    );
   });
 
   it("subscription mode: stashes bsStatementDescriptor for the invoice.created processor without clobbering fee markers", async () => {

package/src/client/billing/checkout.ts

@@ -58,12 +58,13 @@ function deriveFeeRow(params: CheckoutSessionCreateParams): {
 }
 
 /**
- * Destination charges require the price to live on the PLATFORM account, not a
- * connected account. Best-effort guard: if the price is in the component catalog
- * and its product belongs to a connected account, throw a clear error before
- * hitting Stripe. A price absent from the catalog is left to Stripe to validate.
+ * Destination and separate charges use platform prices. Catalog accountId is a
+ * store attribution tag, not Stripe ownership (createProduct uses the platform).
+ * For tagged products, verify the price in the platform Stripe context before
+ * rejecting it. Untagged/unknown catalog entries are validated by Checkout.
  */
 async function assertPlatformPrice(
+  stripe: Stripe,
   component: Component,
   ctx: RunCtx,
   stripePriceId: string,
@@ -80,10 +81,23 @@ async function assertPlatformPrice(
   )) as { accountId?: string } | null;
 
   if (product?.accountId) {
-    throwStripeError(
-      "INVALID_CONFIGURATION",
-      `Price ${stripePriceId} belongs to connected account ${product.accountId}; destination charges require a platform-owned price.`,
-    );
+    try {
+      await stripe.prices.retrieve(stripePriceId);
+    } catch (error) {
+      // Only absence on the platform means the ownership check failed.
+      // Auth/network/rate-limit failures must not be misreported as ownership.
+      if (
+        !error ||
+        typeof error !== "object" ||
+        !("code" in error) ||
+        error.code !== "resource_missing"
+      )
+        throw error;
+      throwStripeError(
+        "INVALID_CONFIGURATION",
+        `Price ${stripePriceId} is unavailable on the platform account; destination charges require a platform-owned price.`,
+      );
+    }
   }
 }
 
@@ -171,7 +185,9 @@ export async function createCheckoutSession(
     ? {
         bsChargeType: "separate",
         bsSplit: JSON.stringify(opts.split),
-        ...(opts.feeConfig ? { bsFeeConfig: JSON.stringify(opts.feeConfig) } : {}),
+        ...(opts.feeConfig
+          ? { bsFeeConfig: JSON.stringify(opts.feeConfig) }
+          : {}),
       }
     : {};
 
@@ -314,7 +330,7 @@ export async function createCheckoutSession(
     (isSeparate || feeRow.chargeType === "destination") &&
     typeof finalPriceId === "string"
   ) {
-    await assertPlatformPrice(component, ctx, finalPriceId);
+    await assertPlatformPrice(stripe, component, ctx, finalPriceId);
   }
 
   const session = await stripe.checkout.sessions.create(finalSessionParams);

package/src/client/billing/subscriptionRouting.ts

@@ -0,0 +1,25 @@
+import type Stripe from "stripe";
+
+import { validateSplit } from "../core/fees.js";
+import type { SplitRecipient } from "../../component/lib/fees.js";
+
+/** Recover routing from Stripe for both webhook delivery and explicit syncs. */
+export function subscriptionRouting(subscription: Stripe.Subscription) {
+  const destination = subscription.transfer_data?.destination;
+  if (destination) {
+    return {
+      chargeType: "destination" as const,
+      destinationAccountId:
+        typeof destination === "string" ? destination : destination.id,
+      applicationFeePercent: subscription.application_fee_percent ?? undefined,
+    };
+  }
+  if (subscription.metadata?.bsChargeType === "separate") {
+    const split = JSON.parse(
+      subscription.metadata.bsSplit ?? "null",
+    ) as SplitRecipient[];
+    validateSplit(split);
+    return { chargeType: "separate" as const, splitRecipients: split };
+  }
+  return {};
+}

package/src/client/billing/subscriptions.test.ts

@@ -110,7 +110,9 @@ describe("getSubscription", () => {
     expect(refPath(ctx.runQuery.mock.calls[0])).toBe(
       "betterStripe/billing/queries/getSubscription",
     );
-    expect(ctx.runQuery.mock.calls[0][1]).toEqual({ subscriptionId: "internal_1" });
+    expect(ctx.runQuery.mock.calls[0][1]).toEqual({
+      subscriptionId: "internal_1",
+    });
   });
 
   it("returns null when the row is missing", async () => {
@@ -492,6 +494,10 @@ describe("syncAllSubscriptions", () => {
         {
           id: "sub_1",
           customer: { id: "cus_1" },
+          customer_account: "acct_buyer",
+          transfer_data: { destination: { id: "acct_store" } },
+          application_fee_percent: 10,
+          pause_collection: { behavior: "void" },
           status: "trialing",
           cancel_at_period_end: false,
           canceled_at: null,
@@ -527,7 +533,10 @@ describe("syncAllSubscriptions", () => {
     );
     expect(ctx.runMutation.mock.calls[0][1]).toEqual({
       stripeSubscriptionId: "sub_1",
-      accountId: "cus_1",
+      accountId: "acct_buyer",
+      chargeType: "destination",
+      destinationAccountId: "acct_store",
+      applicationFeePercent: 10,
       userId: "user_1",
       orgId: "org_1",
       status: "trialing",
@@ -536,6 +545,7 @@ describe("syncAllSubscriptions", () => {
       currentPeriodStart: "2021-01-01T00:00:00.000Z",
       currentPeriodEnd: "2021-02-01T00:00:00.000Z",
       cancelAtPeriodEnd: false,
+      isCollectionPaused: true,
       canceledAt: undefined,
       isTrialing: true,
       trialStart: "2021-01-01T00:00:00.000Z",
@@ -557,7 +567,9 @@ describe("syncAllSubscriptions", () => {
           trial_start: null,
           trial_end: null,
           metadata: { user_id: "user_2", org_id: "org_2" },
-          items: { data: [{ id: "si_2", price: { id: "price_2" }, quantity: 1 }] },
+          items: {
+            data: [{ id: "si_2", price: { id: "price_2" }, quantity: 1 }],
+          },
         },
       ]),
     );
@@ -719,13 +731,18 @@ describe("createSubscription (BTS-17)", () => {
     stripe.subscriptions.create.mockResolvedValue(createdSub());
     const ctx = makeCtx();
 
-    const result = await createSubscription(asStripe(stripe), makeComponent(), ctx, {
-      userId: "buyer_1",
-      customerAccount: "acct_buyer",
-      stripePriceId: "price_1",
-      destinationAccountId: "acct_store",
-      feeConfig: { percent: 10 },
-    });
+    const result = await createSubscription(
+      asStripe(stripe),
+      makeComponent(),
+      ctx,
+      {
+        userId: "buyer_1",
+        customerAccount: "acct_buyer",
+        stripePriceId: "price_1",
+        destinationAccountId: "acct_store",
+        feeConfig: { percent: 10 },
+      },
+    );
 
     const createArg = stripe.subscriptions.create.mock.calls[0][0];
     expect(createArg.customer_account).toBe("acct_buyer");
@@ -744,7 +761,26 @@ describe("createSubscription (BTS-17)", () => {
       destinationAccountId: "acct_store",
       applicationFeePercent: 10,
     });
-    expect(result).toEqual({ stripeSubscriptionId: "sub_new", status: "active" });
+    expect(result).toEqual({
+      stripeSubscriptionId: "sub_new",
+      status: "active",
+    });
+  });
+
+  it("rejects an unknown Stripe status before writing the ledger", async () => {
+    const stripe = makeStripe();
+    stripe.subscriptions.create.mockResolvedValue(
+      createdSub({ status: "future_status" }),
+    );
+    const ctx = makeCtx();
+    await expect(
+      createSubscription(asStripe(stripe), makeComponent(), ctx, {
+        userId: "buyer_1",
+        customerAccount: "acct_buyer",
+        stripePriceId: "price_1",
+      }),
+    ).rejects.toThrow("Unsupported subscription status: future_status");
+    expect(ctx.runMutation).not.toHaveBeenCalled();
   });
 
   it("flags percent+fixed fees for per-invoice computation", async () => {
@@ -841,7 +877,9 @@ describe("createSubscription (BTS-17)", () => {
       userId: "buyer_1",
       customerAccount: "acct_buyer",
       stripePriceId: "price_1",
-      split: [{ destinationAccountId: "acct_store", role: "store", percent: 90 }],
+      split: [
+        { destinationAccountId: "acct_store", role: "store", percent: 90 },
+      ],
       feeConfig: { percent: 10 },
     });
 
@@ -882,13 +920,15 @@ describe("createSubscription (BTS-17)", () => {
 
 describe("groupSubscriptionsByStore (BTS-19)", () => {
   it("groups a buyer's subscriptions by store, preserving first-seen order", () => {
-    const subs: { stripeSubscriptionId: string; destinationAccountId?: string }[] =
-      [
-        { stripeSubscriptionId: "s1", destinationAccountId: "store_a" },
-        { stripeSubscriptionId: "s2", destinationAccountId: "store_b" },
-        { stripeSubscriptionId: "s3", destinationAccountId: "store_a" },
-        { stripeSubscriptionId: "s4" }, // no store → platform-direct
-      ];
+    const subs: {
+      stripeSubscriptionId: string;
+      destinationAccountId?: string;
+    }[] = [
+      { stripeSubscriptionId: "s1", destinationAccountId: "store_a" },
+      { stripeSubscriptionId: "s2", destinationAccountId: "store_b" },
+      { stripeSubscriptionId: "s3", destinationAccountId: "store_a" },
+      { stripeSubscriptionId: "s4" }, // no store → platform-direct
+    ];
 
     const grouped = groupSubscriptionsByStore(subs);
 
@@ -897,15 +937,15 @@ describe("groupSubscriptionsByStore (BTS-19)", () => {
       "store_b",
       null,
     ]);
-    expect(
-      grouped[0].subscriptions.map((s) => s.stripeSubscriptionId),
-    ).toEqual(["s1", "s3"]);
-    expect(grouped[1].subscriptions.map((s) => s.stripeSubscriptionId)).toEqual([
-      "s2",
-    ]);
-    expect(grouped[2].subscriptions.map((s) => s.stripeSubscriptionId)).toEqual([
-      "s4",
-    ]);
+    expect(grouped[0].subscriptions.map((s) => s.stripeSubscriptionId)).toEqual(
+      ["s1", "s3"],
+    );
+    expect(grouped[1].subscriptions.map((s) => s.stripeSubscriptionId)).toEqual(
+      ["s2"],
+    );
+    expect(grouped[2].subscriptions.map((s) => s.stripeSubscriptionId)).toEqual(
+      ["s4"],
+    );
   });
 
   it("returns an empty array for no subscriptions", () => {
@@ -985,3 +1025,25 @@ describe("createSubscription — per-store statement descriptor (BTS-32)", () =>
     expect(ctx.runQuery).not.toHaveBeenCalled();
   });
 });
+
+it("passes an explicit attached payment method to Stripe for the first invoice", async () => {
+  const stripe = makeStripe();
+  stripe.subscriptions.create.mockResolvedValue({
+    id: "sub_card",
+    status: "active",
+    items: { data: [] },
+  });
+  await createSubscription(asStripe(stripe), makeComponent(), makeCtx(), {
+    userId: "user",
+    customerAccount: "acct_buyer",
+    stripePriceId: "price_monthly",
+    defaultPaymentMethod: "pm_attached",
+  });
+  expect(stripe.subscriptions.create).toHaveBeenCalledWith(
+    expect.objectContaining({
+      customer_account: "acct_buyer",
+      default_payment_method: "pm_attached",
+    }),
+    undefined,
+  );
+});

package/src/client/billing/subscriptions.ts

@@ -1,3 +1,5 @@
+import { subscriptionRouting } from "./subscriptionRouting.js";
+import { resolveOwnerAccount } from "../utils/owner.js";
 import type Stripe from "stripe";
 
 import type { SubscriptionStatus } from "../../component/billing/validators.js";
@@ -10,7 +12,10 @@ import {
   stripReservedMetadata,
 } from "../helpers.js";
 import { throwStripeError } from "../errors.js";
-import type { PlatformFeeConfig, StripeComponentSubscription } from "../types.js";
+import type {
+  PlatformFeeConfig,
+  StripeComponentSubscription,
+} from "../types.js";
 import { componentRef } from "../webhooks/helpers.js";
 
 // =============================================================================
@@ -23,7 +28,10 @@ import { componentRef } from "../webhooks/helpers.js";
  * the Convex action/mutation boundary instead of propagating as a raw `Error`.
  * This is the Plan 006 convention; see `src/client/errors.ts`.
  */
-async function callStripe<T>(message: string, fn: () => Promise<T>): Promise<T> {
+async function callStripe<T>(
+  message: string,
+  fn: () => Promise<T>,
+): Promise<T> {
   try {
     return await fn();
   } catch (err) {
@@ -53,6 +61,8 @@ export async function createSubscription(
     split?: SplitRecipient[];
     feeConfig?: PlatformFeeConfig;
     trialDays?: number;
+    /** Attached payment method to use for this subscription. */
+    defaultPaymentMethod?: string;
     /** Platform-default statement-descriptor suffix (BTS-32); see checkout.ts. */
     defaultStatementDescriptorSuffix?: string;
     metadata?: Record<string, string>;
@@ -105,6 +115,9 @@ export async function createSubscription(
 
   const params: Stripe.SubscriptionCreateParams = {
     customer_account: opts.customerAccount,
+    ...(opts.defaultPaymentMethod
+      ? { default_payment_method: opts.defaultPaymentMethod }
+      : {}),
     items: [{ price: opts.stripePriceId }],
     metadata,
   };
@@ -125,7 +138,9 @@ export async function createSubscription(
       ...metadata,
       bsChargeType: "separate",
       bsSplit: JSON.stringify(opts.split),
-      ...(opts.feeConfig ? { bsFeeConfig: JSON.stringify(opts.feeConfig) } : {}),
+      ...(opts.feeConfig
+        ? { bsFeeConfig: JSON.stringify(opts.feeConfig) }
+        : {}),
     };
     feeRow.chargeType = "separate";
     feeRow.splitRecipients = opts.split;
@@ -162,6 +177,25 @@ export async function createSubscription(
     stripe.subscriptions.create(params, requestOpts),
   );
 
+  // Stripe 23 permits future status strings; our ledger accepts only these
+  // known statuses. Reject an unknown value before attempting to persist it.
+  const isKnownStatus = (value: string): value is SubscriptionStatus =>
+    value === "active" ||
+    value === "canceled" ||
+    value === "incomplete" ||
+    value === "incomplete_expired" ||
+    value === "past_due" ||
+    value === "paused" ||
+    value === "trialing" ||
+    value === "unpaid";
+  const status = sub.status;
+  if (!isKnownStatus(status)) {
+    throwStripeError(
+      "STRIPE_API_ERROR",
+      `Unsupported subscription status: ${status}`,
+    );
+  }
+
   const firstItem = sub.items?.data?.[0];
   await runMutationOrThrow(
     ctx,
@@ -171,10 +205,12 @@ export async function createSubscription(
       accountId: opts.customerAccount,
       userId: opts.userId,
       orgId: opts.orgId,
-      status: sub.status,
+      status,
       priceId: firstItem?.price?.id ?? opts.stripePriceId,
       quantity: firstItem?.quantity ?? undefined,
-      currentPeriodStart: epochToIso(firstItem?.current_period_start ?? undefined),
+      currentPeriodStart: epochToIso(
+        firstItem?.current_period_start ?? undefined,
+      ),
       currentPeriodEnd: epochToIso(firstItem?.current_period_end ?? undefined),
       cancelAtPeriodEnd: sub.cancel_at_period_end,
       canceledAt: epochToIso(sub.canceled_at),
@@ -186,7 +222,7 @@ export async function createSubscription(
     },
   );
 
-  return { stripeSubscriptionId: sub.id, status: sub.status };
+  return { stripeSubscriptionId: sub.id, status };
 }
 
 export async function getSubscription(
@@ -255,7 +291,8 @@ export async function updateSubscriptionQuantity(
     stripe.subscriptions.retrieve(opts.stripeSubscriptionId),
   );
   const itemId = sub.items?.data?.[0]?.id;
-  if (!itemId) throwStripeError("SUBSCRIPTION_UPDATE_FAILED", "Subscription has no items");
+  if (!itemId)
+    throwStripeError("SUBSCRIPTION_UPDATE_FAILED", "Subscription has no items");
   await callStripe("Failed to update subscription quantity", () =>
     stripe.subscriptionItems.update(itemId, { quantity: opts.quantity }),
   );
@@ -263,8 +300,8 @@ export async function updateSubscriptionQuantity(
 }
 
 /**
- * Pause collection on a subscription. Sets `pause_collection` (Stripe transitions
- * the subscription to `status: "paused"`); the component DB is updated when the
+ * Pause collection on a subscription. Sets `pause_collection` without changing
+ * the subscription status; the component DB is updated when the
  * resulting `customer.subscription.updated` webhook arrives.
  */
 export async function pauseSubscription(
@@ -288,10 +325,8 @@ export async function pauseSubscription(
 }
 
 /**
- * Resume a paused subscription by clearing `pause_collection`. There is no
- * dedicated Stripe resume endpoint — passing the empty-string sentinel
- * (`Emptyable<PauseCollection>`) clears the field and Stripe returns the
- * subscription to its prior active status.
+ * Resume payment collection by clearing `pause_collection`. The empty-string
+ * sentinel clears the field without changing the subscription status.
  */
 export async function resumeSubscription(
   stripe: Stripe,
@@ -326,7 +361,8 @@ export async function updateSubscriptionPrice(
     stripe.subscriptions.retrieve(opts.stripeSubscriptionId),
   );
   const itemId = sub.items?.data?.[0]?.id;
-  if (!itemId) throwStripeError("SUBSCRIPTION_UPDATE_FAILED", "Subscription has no items");
+  if (!itemId)
+    throwStripeError("SUBSCRIPTION_UPDATE_FAILED", "Subscription has no items");
   await callStripe("Failed to update subscription price", () =>
     stripe.subscriptions.update(opts.stripeSubscriptionId, {
       items: [{ id: itemId, price: opts.stripePriceId }],
@@ -546,10 +582,8 @@ export async function syncAllSubscriptions(
         componentRef(component, "billing/mutations/upsertSubscription"),
         {
           stripeSubscriptionId: sub.id,
-          accountId:
-            typeof sub.customer === "string"
-              ? sub.customer
-              : (sub.customer?.id ?? ""),
+          ...subscriptionRouting(sub),
+          accountId: resolveOwnerAccount(sub) ?? "",
           userId,
           orgId,
           status: sub.status,
@@ -558,6 +592,7 @@ export async function syncAllSubscriptions(
           currentPeriodStart: epochToIso(periodStart),
           currentPeriodEnd: epochToIso(periodEnd),
           cancelAtPeriodEnd: sub.cancel_at_period_end,
+          isCollectionPaused: !!sub.pause_collection,
           canceledAt: epochToIso(sub.canceled_at),
           isTrialing: sub.status === "trialing",
           trialStart: epochToIso(sub.trial_start),

package/src/client/constants.ts

@@ -12,4 +12,4 @@ import type { StripeApiVersion } from "./stripe-types.js";
  * component (it pins every Stripe client it creates), so it warrants a
  * component release and changelog entry.
  */
-export const STRIPE_API_VERSION: StripeApiVersion = "2026-05-27.dahlia";
+export const STRIPE_API_VERSION: StripeApiVersion = "2026-09-30.endive";