@wopr-network/platform-core 0.1.0

package/src/billing/stripe/checkout.ts

@@ -0,0 +1,82 @@
+import type Stripe from "stripe";
+import type { ITenantCustomerRepository, TenantCustomerRepository } from "./tenant-store.js";
+import type { CreditCheckoutOpts, VpsCheckoutOpts } from "./types.js";
+
+/**
+ * Create a Stripe Checkout session for a one-time credit purchase.
+ *
+ * Uses mode: "payment" (not "subscription") — credits are purchased
+ * as one-time payments and credited to the tenant's ledger via webhook.
+ *
+ * If the tenant already has a Stripe customer, it reuses that customer.
+ * Otherwise, Stripe creates a new customer during checkout.
+ */
+export async function createCreditCheckoutSession(
+  stripe: Stripe,
+  tenantRepo: TenantCustomerRepository,
+  opts: CreditCheckoutOpts,
+): Promise<Stripe.Checkout.Session> {
+  const existing = await tenantRepo.getByTenant(opts.tenant);
+
+  const params: Stripe.Checkout.SessionCreateParams = {
+    mode: "payment",
+    line_items: [
+      {
+        price: opts.priceId,
+        quantity: 1,
+      },
+    ],
+    success_url: opts.successUrl,
+    cancel_url: opts.cancelUrl,
+    client_reference_id: opts.tenant,
+    metadata: {
+      wopr_tenant: opts.tenant,
+      wopr_purchase_type: "credits",
+    },
+  };
+
+  // Reuse existing Stripe customer if we have one.
+  if (existing) {
+    params.customer = existing.processor_customer_id;
+  }
+
+  return stripe.checkout.sessions.create(params);
+}
+
+/**
+ * Create a Stripe Checkout session for a VPS subscription.
+ *
+ * Uses mode: "subscription" — VPS is a $15/month recurring subscription.
+ * The webhook handler processes customer.subscription.created to activate VPS status.
+ */
+export async function createVpsCheckoutSession(
+  stripe: Stripe,
+  tenantRepo: ITenantCustomerRepository,
+  opts: VpsCheckoutOpts,
+): Promise<Stripe.Checkout.Session> {
+  const existing = await tenantRepo.getByTenant(opts.tenant);
+
+  const params: Stripe.Checkout.SessionCreateParams = {
+    mode: "subscription",
+    line_items: [
+      {
+        price: opts.vpsPriceId,
+        quantity: 1,
+      },
+    ],
+    success_url: opts.successUrl,
+    cancel_url: opts.cancelUrl,
+    client_reference_id: opts.tenant,
+    metadata: {
+      wopr_tenant: opts.tenant,
+      wopr_bot_id: opts.botId,
+      wopr_purchase_type: "vps",
+    },
+  };
+
+  if (existing) {
+    params.customer = existing.processor_customer_id;
+  }
+
+  return stripe.checkout.sessions.create(params);
+}

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

@@ -0,0 +1,64 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createStripeClient, loadStripeConfig } from "./client.js";
+
+describe("loadStripeConfig", () => {
+  let origSecretKey: string | undefined;
+  let origWebhookSecret: string | undefined;
+
+  beforeEach(() => {
+    origSecretKey = process.env.STRIPE_SECRET_KEY;
+    origWebhookSecret = process.env.STRIPE_WEBHOOK_SECRET;
+  });
+
+  afterEach(() => {
+    if (origSecretKey === undefined) {
+      delete process.env.STRIPE_SECRET_KEY;
+    } else {
+      process.env.STRIPE_SECRET_KEY = origSecretKey;
+    }
+    if (origWebhookSecret === undefined) {
+      delete process.env.STRIPE_WEBHOOK_SECRET;
+    } else {
+      process.env.STRIPE_WEBHOOK_SECRET = origWebhookSecret;
+    }
+  });
+
+  it("returns null when both env vars are missing", () => {
+    delete process.env.STRIPE_SECRET_KEY;
+    delete process.env.STRIPE_WEBHOOK_SECRET;
+    expect(loadStripeConfig()).toBeNull();
+  });
+
+  it("returns null when only STRIPE_SECRET_KEY is set", () => {
+    process.env.STRIPE_SECRET_KEY = "sk_test_abc";
+    delete process.env.STRIPE_WEBHOOK_SECRET;
+    expect(loadStripeConfig()).toBeNull();
+  });
+
+  it("returns null when only STRIPE_WEBHOOK_SECRET is set", () => {
+    delete process.env.STRIPE_SECRET_KEY;
+    process.env.STRIPE_WEBHOOK_SECRET = "whsec_abc";
+    expect(loadStripeConfig()).toBeNull();
+  });
+
+  it("returns config when both env vars are present", () => {
+    process.env.STRIPE_SECRET_KEY = "sk_test_abc123";
+    process.env.STRIPE_WEBHOOK_SECRET = "whsec_def456";
+    const config = loadStripeConfig();
+    expect(config).not.toBeNull();
+    expect(config?.secretKey).toBe("sk_test_abc123");
+    expect(config?.webhookSecret).toBe("whsec_def456");
+  });
+});
+
+describe("createStripeClient", () => {
+  it("creates a Stripe client with pinned API version", () => {
+    const client = createStripeClient({ secretKey: "sk_test_abc", webhookSecret: "whsec_abc" });
+    // Stripe client stores the API version internally
+    // We verify it was created successfully
+    expect(client).toEqual(expect.any(Object));
+    expect(client.checkout).toEqual(expect.any(Object));
+    expect(client.paymentIntents).toEqual(expect.any(Object));
+    expect(client.setupIntents).toEqual(expect.any(Object));
+  });
+});

package/src/billing/stripe/client.ts

@@ -0,0 +1,39 @@
+import Stripe from "stripe";
+import type { StripeBillingConfig } from "./types.js";
+
+/**
+ * The Stripe API version to use for all requests.
+ * Pinning this ensures stability across Stripe API releases.
+ */
+const STRIPE_API_VERSION = "2024-12-18.acacia";
+
+/**
+ * Create a configured Stripe client.
+ *
+ * All Stripe config comes from env vars — no billing logic in WOPR,
+ * just a thin wrapper around the Stripe SDK.
+ */
+export function createStripeClient(config: StripeBillingConfig): Stripe {
+  return new Stripe(config.secretKey, {
+    // @ts-expect-error stripe-version-2024-12-18.acacia
+    apiVersion: STRIPE_API_VERSION,
+  });
+}
+
+/**
+ * Load Stripe billing config from environment variables.
+ * Returns null if required vars are missing.
+ */
+export function loadStripeConfig(): StripeBillingConfig | null {
+  const secretKey = process.env.STRIPE_SECRET_KEY;
+  const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET;
+
+  if (!secretKey || !webhookSecret) {
+    return null;
+  }
+
+  return {
+    secretKey,
+    webhookSecret,
+  };
+}

package/src/billing/stripe/credit-prices.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  CREDIT_PRICE_POINTS,
+  getConfiguredPriceIds,
+  getCreditAmountForPurchase,
+  loadCreditPriceMap,
+  lookupCreditPrice,
+} from "./credit-prices.js";
+
+describe("CREDIT_PRICE_POINTS", () => {
+  it("has 5 tiers", () => {
+    expect(CREDIT_PRICE_POINTS).toHaveLength(5);
+  });
+
+  it("tiers have correct bonus percentages", () => {
+    expect(CREDIT_PRICE_POINTS[0].bonusPercent).toBe(0);
+    expect(CREDIT_PRICE_POINTS[1].bonusPercent).toBe(0);
+    expect(CREDIT_PRICE_POINTS[2].bonusPercent).toBe(2);
+    expect(CREDIT_PRICE_POINTS[3].bonusPercent).toBe(5);
+    expect(CREDIT_PRICE_POINTS[4].bonusPercent).toBe(10);
+  });
+
+  it("credit amounts include bonus correctly", () => {
+    expect(CREDIT_PRICE_POINTS[0].creditCents).toBe(500);
+    expect(CREDIT_PRICE_POINTS[2].creditCents).toBe(2550);
+    expect(CREDIT_PRICE_POINTS[4].creditCents).toBe(11000);
+  });
+});
+
+describe("getCreditAmountForPurchase", () => {
+  it("returns bonus credits for matching tier", () => {
+    expect(getCreditAmountForPurchase(2500)).toBe(2550);
+    expect(getCreditAmountForPurchase(5000)).toBe(5250);
+    expect(getCreditAmountForPurchase(10000)).toBe(11000);
+  });
+
+  it("returns 1:1 for non-matching amount", () => {
+    expect(getCreditAmountForPurchase(7777)).toBe(7777);
+    expect(getCreditAmountForPurchase(1)).toBe(1);
+    expect(getCreditAmountForPurchase(99999)).toBe(99999);
+  });
+
+  it("returns exact amount for tiers without bonus", () => {
+    expect(getCreditAmountForPurchase(500)).toBe(500);
+    expect(getCreditAmountForPurchase(1000)).toBe(1000);
+  });
+});
+
+describe("loadCreditPriceMap", () => {
+  it("loads prices from environment variables", () => {
+    vi.stubEnv("STRIPE_CREDIT_PRICE_5", "price_5_test");
+    vi.stubEnv("STRIPE_CREDIT_PRICE_25", "price_25_test");
+
+    const map = loadCreditPriceMap();
+    expect(map.get("price_5_test")).toEqual(expect.objectContaining({ amountCents: 500, creditCents: 500 }));
+    expect(map.get("price_25_test")).toEqual(expect.objectContaining({ amountCents: 2500, creditCents: 2550 }));
+
+    vi.unstubAllEnvs();
+  });
+
+  it("skips unset environment variables", () => {
+    vi.stubEnv("STRIPE_CREDIT_PRICE_5", "");
+    vi.stubEnv("STRIPE_CREDIT_PRICE_10", "");
+    vi.stubEnv("STRIPE_CREDIT_PRICE_25", "");
+    vi.stubEnv("STRIPE_CREDIT_PRICE_50", "");
+    vi.stubEnv("STRIPE_CREDIT_PRICE_100", "");
+
+    const map = loadCreditPriceMap();
+    expect(map.size).toBe(0);
+
+    vi.unstubAllEnvs();
+  });
+});
+
+describe("lookupCreditPrice", () => {
+  it("returns price point for known price ID", () => {
+    const priceMap = new Map([["price_abc", CREDIT_PRICE_POINTS[2]]]);
+
+    const point = lookupCreditPrice(priceMap, "price_abc");
+    expect(point).not.toBeNull();
+    expect(point?.amountCents).toBe(2500);
+  });
+
+  it("returns null for unknown price ID", () => {
+    const priceMap = new Map();
+    expect(lookupCreditPrice(priceMap, "price_unknown")).toBeNull();
+  });
+});
+
+describe("getConfiguredPriceIds", () => {
+  it("returns configured price IDs from env", () => {
+    vi.stubEnv("STRIPE_CREDIT_PRICE_5", "price_5_id");
+    vi.stubEnv("STRIPE_CREDIT_PRICE_100", "price_100_id");
+
+    const ids = getConfiguredPriceIds();
+    expect(ids).toContain("price_5_id");
+    expect(ids).toContain("price_100_id");
+
+    vi.unstubAllEnvs();
+  });
+
+  it("returns empty array when no prices configured", () => {
+    vi.stubEnv("STRIPE_CREDIT_PRICE_5", "");
+    vi.stubEnv("STRIPE_CREDIT_PRICE_10", "");
+    vi.stubEnv("STRIPE_CREDIT_PRICE_25", "");
+    vi.stubEnv("STRIPE_CREDIT_PRICE_50", "");
+    vi.stubEnv("STRIPE_CREDIT_PRICE_100", "");
+
+    const ids = getConfiguredPriceIds();
+    expect(ids).toHaveLength(0);
+
+    vi.unstubAllEnvs();
+  });
+});

package/src/billing/stripe/credit-prices.ts

@@ -0,0 +1,113 @@
+/**
+ * WOPR Credit price points and bonus tiers.
+ *
+ * One Stripe Product ("WOPR Credits") with 5 preset Price objects.
+ * Each price maps to a dollar amount and a credit value (with optional bonus).
+ *
+ * Price IDs are loaded from environment variables so they can differ
+ * between Stripe test/live modes.
+ */
+
+/**
+ * A preset credit purchase option.
+ *
+ * IMPORTANT — naming convention (WOP-1058):
+ * - amountCents: USD cents charged to Stripe (monetary — DO NOT rename to _credits).
+ *   This value is passed to Stripe's checkout session and PaymentIntent APIs.
+ * - creditCents: USD cents worth of platform credits granted (includes bonus).
+ *   Named _cents because the platform credit unit = 1 USD cent.
+ *   Passed to Credit.fromCents() — NOT a raw Credit nanodollar value.
+ */
+export interface CreditPricePoint {
+  /** Human-readable label. */
+  label: string;
+  /** Amount charged in USD cents (Stripe monetary — DO NOT rename to _credits). */
+  amountCents: number;
+  /** Platform credits granted in USD cents (includes bonus — DO NOT rename to _credits). */
+  creditCents: number;
+  /** Bonus percentage (0 for no bonus). */
+  bonusPercent: number;
+}
+
+/**
+ * The 5 preset credit tiers.
+ *
+ * Bonus logic:
+ *   $5   -> $5.00 credit   (0% bonus)
+ *   $10  -> $10.00 credit  (0% bonus)
+ *   $25  -> $25.50 credit  (2% bonus)
+ *   $50  -> $52.50 credit  (5% bonus)
+ *   $100 -> $110.00 credit (10% bonus)
+ */
+export const CREDIT_PRICE_POINTS: readonly CreditPricePoint[] = [
+  { label: "$5", amountCents: 500, creditCents: 500, bonusPercent: 0 },
+  { label: "$10", amountCents: 1000, creditCents: 1000, bonusPercent: 0 },
+  { label: "$25", amountCents: 2500, creditCents: 2550, bonusPercent: 2 },
+  { label: "$50", amountCents: 5000, creditCents: 5250, bonusPercent: 5 },
+  { label: "$100", amountCents: 10000, creditCents: 11000, bonusPercent: 10 },
+] as const;
+
+/**
+ * Map of env var name -> index into CREDIT_PRICE_POINTS.
+ * Each env var holds the Stripe Price ID for that tier.
+ */
+const PRICE_ENV_VARS = [
+  "STRIPE_CREDIT_PRICE_5",
+  "STRIPE_CREDIT_PRICE_10",
+  "STRIPE_CREDIT_PRICE_25",
+  "STRIPE_CREDIT_PRICE_50",
+  "STRIPE_CREDIT_PRICE_100",
+] as const;
+
+/** Mapping from Stripe Price ID -> CreditPricePoint. */
+export type CreditPriceMap = ReadonlyMap<string, CreditPricePoint>;
+
+/**
+ * Load credit price mappings from environment variables.
+ *
+ * Returns a Map from Stripe Price ID -> CreditPricePoint.
+ * Only includes entries where the env var is set.
+ */
+export function loadCreditPriceMap(): CreditPriceMap {
+  const map = new Map<string, CreditPricePoint>();
+
+  for (let i = 0; i < PRICE_ENV_VARS.length; i++) {
+    const priceId = process.env[PRICE_ENV_VARS[i]];
+    if (priceId) {
+      map.set(priceId, CREDIT_PRICE_POINTS[i]);
+    }
+  }
+
+  return map;
+}
+
+/**
+ * Get the credit amount (in cents) for a given purchase amount (in cents).
+ *
+ * Uses the bonus tiers to determine the credit value.
+ * Falls back to 1:1 if no matching tier is found.
+ */
+export function getCreditAmountForPurchase(amountCents: number): number {
+  const tier = CREDIT_PRICE_POINTS.find((p) => p.amountCents === amountCents);
+  return tier ? tier.creditCents : amountCents;
+}
+
+/**
+ * Look up a CreditPricePoint by Stripe Price ID using the price map.
+ * Returns null if the price ID is not recognized.
+ */
+export function lookupCreditPrice(priceMap: CreditPriceMap, priceId: string): CreditPricePoint | null {
+  return priceMap.get(priceId) ?? null;
+}
+
+/** Get all configured Stripe Price IDs (for validation). */
+export function getConfiguredPriceIds(): string[] {
+  const ids: string[] = [];
+  for (const envVar of PRICE_ENV_VARS) {
+    const priceId = process.env[envVar];
+    if (priceId) {
+      ids.push(priceId);
+    }
+  }
+  return ids;
+}

package/src/billing/stripe/index.ts

@@ -0,0 +1,14 @@
+export { createCreditCheckoutSession, createVpsCheckoutSession } from "./checkout.js";
+export { createStripeClient, loadStripeConfig } from "./client.js";
+export type { CreditPricePoint, CreditPriceMap } from "./credit-prices.js";
+export { CREDIT_PRICE_POINTS, loadCreditPriceMap, getCreditAmountForPurchase, lookupCreditPrice, getConfiguredPriceIds } from "./credit-prices.js";
+export { detachPaymentMethod, detachAllPaymentMethods } from "./payment-methods.js";
+export type { DetachPaymentMethodOpts } from "./payment-methods.js";
+export { createPortalSession } from "./portal.js";
+export type { SetupIntentOpts } from "./setup-intent.js";
+export { createSetupIntent } from "./setup-intent.js";
+export type { StripeWebhookHandlerResult, StripePaymentProcessorDeps } from "./stripe-payment-processor.js";
+export { StripePaymentProcessor } from "./stripe-payment-processor.js";
+export type { ITenantCustomerRepository } from "./tenant-store.js";
+export { DrizzleTenantCustomerRepository, TenantCustomerRepository } from "./tenant-store.js";
+export type { TenantCustomerRow, CreditCheckoutOpts, PortalSessionOpts, VpsCheckoutOpts, StripeBillingConfig } from "./types.js";

package/src/billing/stripe/payment-methods-detach-all.test.ts

@@ -0,0 +1,53 @@
+import type Stripe from "stripe";
+import { describe, expect, it, vi } from "vitest";
+import { detachAllPaymentMethods } from "./payment-methods.js";
+import type { ITenantCustomerRepository } from "./tenant-store.js";
+
+function mockStripe(paymentMethods: Array<{ id: string }> = []) {
+  return {
+    customers: {
+      listPaymentMethods: vi.fn().mockResolvedValue({ data: paymentMethods }),
+    },
+    paymentMethods: {
+      detach: vi.fn().mockResolvedValue({}),
+    },
+  } as unknown as Stripe;
+}
+
+function mockTenantStore(customerId: string | null = "cus_123") {
+  return {
+    getByTenant: vi.fn().mockResolvedValue(customerId ? { tenant: "t1", processor_customer_id: customerId } : null),
+  } as unknown as ITenantCustomerRepository;
+}
+
+describe("detachAllPaymentMethods", () => {
+  it("detaches all payment methods for a tenant", async () => {
+    const stripe = mockStripe([{ id: "pm_1" }, { id: "pm_2" }]);
+    const tenantRepo = mockTenantStore();
+
+    const count = await detachAllPaymentMethods(stripe, tenantRepo, "t1");
+
+    expect(count).toBe(2);
+    expect(stripe.paymentMethods.detach).toHaveBeenCalledWith("pm_1");
+    expect(stripe.paymentMethods.detach).toHaveBeenCalledWith("pm_2");
+  });
+
+  it("returns 0 when tenant has no Stripe customer", async () => {
+    const stripe = mockStripe();
+    const tenantRepo = mockTenantStore(null);
+
+    const count = await detachAllPaymentMethods(stripe, tenantRepo, "t1");
+
+    expect(count).toBe(0);
+    expect(stripe.paymentMethods.detach).not.toHaveBeenCalled();
+  });
+
+  it("returns 0 when tenant has no payment methods", async () => {
+    const stripe = mockStripe([]);
+    const tenantRepo = mockTenantStore();
+
+    const count = await detachAllPaymentMethods(stripe, tenantRepo, "t1");
+
+    expect(count).toBe(0);
+  });
+});

package/src/billing/stripe/payment-methods.test.ts

@@ -0,0 +1,157 @@
+import type { PGlite } from "@electric-sql/pglite";
+import type Stripe from "stripe";
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import type { PlatformDb } from "../../db/index.js";
+import { beginTestTransaction, createTestDb, endTestTransaction, rollbackTestTransaction } from "../../test/db.js";
+import { detachAllPaymentMethods, detachPaymentMethod } from "./payment-methods.js";
+import { TenantCustomerRepository } from "./tenant-store.js";
+
+function mockStripe(
+  overrides: { paymentMethodRetrieve?: ReturnType<typeof vi.fn>; paymentMethodDetach?: ReturnType<typeof vi.fn> } = {},
+) {
+  return {
+    paymentMethods: {
+      retrieve:
+        overrides.paymentMethodRetrieve ??
+        vi.fn().mockResolvedValue({
+          id: "pm_test_123",
+          customer: "cus_abc123",
+        }),
+      detach: overrides.paymentMethodDetach ?? vi.fn().mockResolvedValue({ id: "pm_test_123" }),
+    },
+  } as unknown as Stripe;
+}
+
+// TOP OF FILE - shared across ALL describes
+let pool: PGlite;
+let db: PlatformDb;
+
+beforeAll(async () => {
+  ({ db, pool } = await createTestDb());
+  await beginTestTransaction(pool);
+});
+
+afterAll(async () => {
+  await endTestTransaction(pool);
+  await pool.close();
+});
+
+describe("detachPaymentMethod", () => {
+  let store: TenantCustomerRepository;
+
+  beforeEach(async () => {
+    await rollbackTestTransaction(pool);
+    store = new TenantCustomerRepository(db);
+  });
+
+  it("calls stripe.paymentMethods.detach with the correct ID", async () => {
+    await store.upsert({ tenant: "t-1", processorCustomerId: "cus_abc123" });
+
+    const stripe = mockStripe();
+    await detachPaymentMethod(stripe, store, {
+      tenant: "t-1",
+      paymentMethodId: "pm_test_123",
+    });
+
+    expect(stripe.paymentMethods.retrieve).toHaveBeenCalledWith("pm_test_123");
+    expect(stripe.paymentMethods.detach).toHaveBeenCalledWith("pm_test_123");
+  });
+
+  it("throws when tenant has no Stripe customer mapping", async () => {
+    const stripe = mockStripe();
+
+    await expect(
+      detachPaymentMethod(stripe, store, {
+        tenant: "t-unknown",
+        paymentMethodId: "pm_test_123",
+      }),
+    ).rejects.toThrow("No Stripe customer found for tenant: t-unknown");
+  });
+
+  it("throws when payment method belongs to a different customer (cross-tenant guard)", async () => {
+    await store.upsert({ tenant: "t-1", processorCustomerId: "cus_abc123" });
+
+    const paymentMethodRetrieve = vi.fn().mockResolvedValue({
+      id: "pm_other",
+      customer: "cus_other_customer",
+    });
+    const stripe = mockStripe({ paymentMethodRetrieve });
+
+    await expect(
+      detachPaymentMethod(stripe, store, {
+        tenant: "t-1",
+        paymentMethodId: "pm_other",
+      }),
+    ).rejects.toThrow("Payment method does not belong to this tenant");
+
+    expect(stripe.paymentMethods.detach).not.toHaveBeenCalled();
+  });
+});
+
+describe("detachAllPaymentMethods", () => {
+  let store: TenantCustomerRepository;
+
+  beforeEach(async () => {
+    await rollbackTestTransaction(pool);
+    store = new TenantCustomerRepository(db);
+  });
+
+  it("returns 0 when tenant has no Stripe customer mapping", async () => {
+    const stripe = {
+      customers: { listPaymentMethods: vi.fn() },
+      paymentMethods: { detach: vi.fn() },
+    } as unknown as Stripe;
+
+    const result = await detachAllPaymentMethods(stripe, store, "t-unknown");
+    expect(result).toBe(0);
+    expect(stripe.customers.listPaymentMethods).not.toHaveBeenCalled();
+  });
+
+  it("detaches all payment methods on a single page", async () => {
+    await store.upsert({ tenant: "t-1", processorCustomerId: "cus_abc" });
+
+    const listPaymentMethods = vi.fn().mockResolvedValue({
+      data: [{ id: "pm_1" }, { id: "pm_2" }],
+      has_more: false,
+    });
+    const detach = vi.fn().mockResolvedValue({});
+    const stripe = {
+      customers: { listPaymentMethods },
+      paymentMethods: { detach },
+    } as unknown as Stripe;
+
+    const result = await detachAllPaymentMethods(stripe, store, "t-1");
+    expect(result).toBe(2);
+    expect(detach).toHaveBeenCalledWith("pm_1");
+    expect(detach).toHaveBeenCalledWith("pm_2");
+    expect(listPaymentMethods).toHaveBeenCalledTimes(1);
+  });
+
+  it("paginates when has_more is true", async () => {
+    await store.upsert({ tenant: "t-1", processorCustomerId: "cus_abc" });
+
+    const listPaymentMethods = vi
+      .fn()
+      .mockResolvedValueOnce({
+        data: [{ id: "pm_1" }, { id: "pm_2" }],
+        has_more: true,
+      })
+      .mockResolvedValueOnce({
+        data: [{ id: "pm_3" }],
+        has_more: false,
+      });
+    const detach = vi.fn().mockResolvedValue({});
+    const stripe = {
+      customers: { listPaymentMethods },
+      paymentMethods: { detach },
+    } as unknown as Stripe;
+
+    const result = await detachAllPaymentMethods(stripe, store, "t-1");
+    expect(result).toBe(3);
+    expect(listPaymentMethods).toHaveBeenCalledTimes(2);
+    expect(listPaymentMethods).toHaveBeenNthCalledWith(2, "cus_abc", { limit: 100, starting_after: "pm_2" });
+    expect(detach).toHaveBeenCalledWith("pm_1");
+    expect(detach).toHaveBeenCalledWith("pm_2");
+    expect(detach).toHaveBeenCalledWith("pm_3");
+  });
+});