tapimo 0.14.0 → 0.15.0

package/src/apps/management/routes/billing.test.ts

@@ -1,4 +1,7 @@
+import { sql } from 'kysely'
 import { nanoid } from 'nanoid'
+import * as http from 'node:http'
+import * as https from 'node:https'
 import Stripe from 'stripe'
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
 
@@ -65,6 +68,7 @@ function createApp(
     billing?: App.Billing | undefined
     db?: TestApp.create.Options['db']
     kv?: { store: ReturnType<typeof TestApp.kvStore> }
+    zones?: TestApp.create.Options['zones'] | undefined
   } = {},
 ) {
   // prettier-ignore
@@ -74,6 +78,7 @@ function createApp(
     db: options.db ?? TestApp.database(),
     ...(options.kv ? { kv: options.kv } : {}),
     session: { wallet: { origin } },
+    zones: options.zones,
   })
 }
 
@@ -859,9 +864,95 @@ describe('environment scoping', () => {
     expect(((await prod.json()) as { spend: { amount: string } }).spend.amount).toBe('0.1')
     expect(((await sbx.json()) as { spend: { amount: string } }).spend.amount).toBe('0.25')
   })
+
+  test('behavior: includes configured Zone charges in each environment', async () => {
+    const db = TestApp.database()
+    const zones = [
+      TestApp.zone({
+        chainId: 8001,
+        rpcUrl: 'https://zone.example',
+        sourceChainId: Viem.chainId.mainnet,
+      }),
+      TestApp.zone({
+        chainId: 8002,
+        rpcUrl: 'https://zone.example',
+        sourceChainId: Viem.chainId.mainnet,
+      }),
+      TestApp.zone({ chainId: 8003, rpcUrl: 'https://zone.example' }),
+    ]
+    const app = createApp({ billing: billingWithSandbox(), db, zones })
+    const { cookie, orgId } = await seeded(app)
+    for (const [index, row] of [
+      { chainId: Viem.chainId.mainnet, feeAmount: '100000' },
+      { chainId: 8001, feeAmount: '200000' },
+      { chainId: 8002, feeMax: '250000' },
+      { chainId: 8003, feeMax: '900000' },
+      { billable: false, chainId: 8001, feeMax: '900000' },
+      { chainId: 8004, feeMax: '900000' },
+      {
+        billable: false,
+        chainId: Viem.chainId.testnet,
+        environment: 'sandbox' as const,
+        feeMax: '150000',
+      },
+      { billable: false, chainId: 8003, environment: 'sandbox' as const, feeAmount: '350000' },
+    ].entries()) {
+      const { feeAmount, ...input } = row
+      const record = await SponsoredTransactions.upsert(db, {
+        ...sponsorship(orgId),
+        ...input,
+        signPayload: `0x${String(index + 10).repeat(32)}`,
+      })
+      if (feeAmount)
+        await SponsoredTransactions.finalize(db, record.id, {
+          feeAmount,
+          finalizedAt: new Date().toISOString(),
+        })
+    }
+
+    const production = await app.request(`/v1/orgs/${orgId}/billing`, { headers: { cookie } })
+    const sandbox = await app.request(`/v1/orgs/${orgId}/billing?environment=sandbox`, {
+      headers: { cookie },
+    })
+    expect(production.status).toBe(200)
+    expect(sandbox.status).toBe(200)
+    expect((await production.json()).spend).toMatchInlineSnapshot(`
+      {
+        "amount": "0.55",
+        "currency": "usd",
+        "period": "month",
+      }
+    `)
+    expect((await sandbox.json()).spend).toMatchInlineSnapshot(`
+      {
+        "amount": "0.5",
+        "currency": "usd",
+        "period": "month",
+      }
+    `)
+  })
 })
 
 describe('POST /stripe/webhook', () => {
+  test.each(['invoice.finalized', 'invoice.overdue', 'invoice.updated'] as const)(
+    'behavior: %s reports refresh failures without clearing delinquency',
+    async (type) => {
+      const db = TestApp.database()
+      const app = createApp({ db })
+      await StripeCustomers.create(db, { orgId: 'org_1', stripeCustomerId: 'cus_invoice' })
+      await StripeCustomers.setStatus(db, 'org_1', 'past_due')
+      const payload = JSON.stringify({
+        data: { object: { customer: 'cus_invoice', id: 'in_invoice', object: 'invoice' } },
+        id: 'evt_invoice',
+        object: 'event',
+        type,
+      })
+      const response = await deliver(app, payload, sign(payload))
+      expect(response.status).toBe(502)
+      expect((await StripeCustomers.get(db, 'org_1'))?.status).toBe('past_due')
+    },
+  )
+
   /** Signs with the app's configured secret unless a test overrides it. */
   function sign(payload: string, secret = webhookSecret) {
     return TestStripe.sign({ payload, secret })
@@ -981,6 +1072,112 @@ function sandboxBillingBoth(): App.Billing {
 // CI always sets it.
 
 describe.runIf(TestStripe.secretKey)('stripe sandbox (direct)', () => {
+  test.each(['webhook', 'delete'] as const)(
+    'a delayed active refresh cannot overwrite card removal through %s',
+    async (path) => {
+      const db = TestApp.databaseFactory()()
+      const barrier = await subscriptionBarrier()
+      onTestFinished(async () => {
+        barrier.release()
+        await barrier.close()
+      })
+      const app = createApp({ billing: { stripe: { client: barrier.client, webhookSecret } }, db })
+      const { cookie, orgId } = await seeded(app)
+      const stripe = TestStripe.client()
+      const customer = await stripe.customers.create({ metadata: { orgId } })
+      TestStripe.track(customer.id)
+      await StripeCustomers.create(db, { orgId, stripeCustomerId: customer.id })
+      const attached = await TestStripe.attachCard(customer.id)
+      const payload = JSON.stringify({
+        data: { object: { id: customer.id, object: 'customer' } },
+        id: 'evt_concurrent_refresh',
+        object: 'event',
+        type: 'customer.updated',
+      })
+      const active = Promise.resolve(
+        app.request('/stripe/webhook', {
+          body: payload,
+          headers: { 'stripe-signature': TestStripe.sign({ payload, secret: webhookSecret }) },
+          method: 'POST',
+        }),
+      )
+      let removal: Promise<Response> | undefined
+      try {
+        // Pause a real Stripe response after status derivation, while the
+        // active webhook is still provisioning its subscription.
+        await Promise.race([
+          barrier.paused,
+          active.then(() => {
+            throw new Error('refresh finished before subscription provisioning')
+          }),
+        ])
+        expect(await core_Billing.status(db, orgId)).toBe('none')
+        if (path === 'webhook') await stripe.paymentMethods.detach(attached.paymentMethod)
+        const detached = JSON.stringify({
+          data: {
+            object: { customer: null, id: attached.paymentMethod, object: 'payment_method' },
+            previous_attributes: { customer: customer.id },
+          },
+          id: 'evt_concurrent_detach',
+          object: 'event',
+          type: 'payment_method.detached',
+        })
+        removal =
+          path === 'webhook'
+            ? Promise.resolve(
+                app.request('/stripe/webhook', {
+                  body: detached,
+                  headers: {
+                    'stripe-signature': TestStripe.sign({
+                      payload: detached,
+                      secret: webhookSecret,
+                    }),
+                  },
+                  method: 'POST',
+                }),
+              )
+            : Promise.resolve(
+                app.request(`/v1/orgs/${orgId}/billing/payment-methods/${attached.paymentMethod}`, {
+                  headers: { cookie },
+                  method: 'DELETE',
+                }),
+              )
+        let completed = false
+        void removal.then(() => {
+          completed = true
+        })
+        // With serialization the removal waits for the row lock. Without it,
+        // removal completes first and the delayed refresh restores stale active.
+        await expect
+          .poll(
+            async () => {
+              const { rows } = await sql<{ blocked: boolean }>`
+                SELECT EXISTS (
+                  SELECT 1 FROM pg_locks JOIN pg_stat_activity USING (pid)
+                  WHERE relation = 'stripe_customers'::regclass AND wait_event_type = 'Lock'
+                ) AS blocked
+              `.execute(db.kysely)
+              return completed || rows[0]!.blocked
+            },
+            { timeout: 20_000 },
+          )
+          .toBe(true)
+      } finally {
+        barrier.release()
+        await Promise.allSettled([active, removal])
+      }
+      expect((await active).status).toBe(200)
+      expect((await removal)?.status).toBe(200)
+      expect(await core_Billing.status(db, orgId)).toBe('none')
+      expect(
+        (await stripe.customers.listPaymentMethods(customer.id, { type: 'card' })).data,
+      ).toHaveLength(0)
+      const subscriptions = await stripe.subscriptions.list({ customer: customer.id })
+      expect(subscriptions.data).toHaveLength(1)
+      expect(subscriptions.data[0]!.items.data).toHaveLength(3)
+    },
+  )
+
   test('checkout provisions distinct customers per environment', { timeout: 30_000 }, async () => {
     const db = TestApp.database()
     const app = createApp({ billing: sandboxBillingBoth(), db })
@@ -1171,6 +1368,163 @@ describe.runIf(TestStripe.secretKey)('stripe sandbox (direct)', () => {
     const { url } = (await response.json()) as { url: string }
     expect(url).toMatch(/^https:\/\/billing\.stripe\.com\//)
   })
+
+  test('paused unattempted automatic invoices prevent replacement subscriptions', async () => {
+    const db = TestApp.database()
+    const stripe = TestStripe.client()
+    const app = createApp({ billing: sandboxBilling(), db })
+    const customer = await stripe.customers.create({ metadata: { orgId: 'org_1' } })
+    TestStripe.track(customer.id)
+    await StripeCustomers.create(db, { orgId: 'org_1', stripeCustomerId: customer.id })
+    await TestStripe.completeCheckout(app, { customer: customer.id, webhookSecret })
+    const subscriptions = await stripe.subscriptions.list({ customer: customer.id })
+    expect(subscriptions.data).toHaveLength(1)
+    const subscription = subscriptions.data[0]!.id
+    const draft = await stripe.invoices.create({
+      auto_advance: true,
+      customer: customer.id,
+      subscription,
+    })
+    await stripe.invoiceItems.create({
+      amount: 500,
+      currency: 'usd',
+      customer: customer.id,
+      invoice: draft.id,
+    })
+    const invoice = await stripe.invoices.finalizeInvoice(draft.id, { auto_advance: true })
+    expect(invoice).toMatchObject({
+      amount_remaining: 500,
+      attempted: false,
+      auto_advance: true,
+      collection_method: 'charge_automatically',
+      due_date: null,
+      status: 'open',
+    })
+    await deliverEvent(
+      app,
+      await eventFor(stripe, {
+        customerId: customer.id,
+        objectId: invoice.id,
+        type: 'invoice.finalized',
+      }),
+    )
+    expect((await StripeCustomers.get(db, 'org_1'))?.status).toBe('active')
+
+    await stripe.invoices.update(invoice.id, { auto_advance: false })
+    await deliverEvent(
+      app,
+      await eventFor(stripe, {
+        customerId: customer.id,
+        objectId: invoice.id,
+        type: 'invoice.updated',
+      }),
+    )
+    expect((await StripeCustomers.get(db, 'org_1'))?.status).toBe('past_due')
+
+    await stripe.invoices.update(invoice.id, { auto_advance: true })
+    await deliverEvent(
+      app,
+      await eventFor(stripe, {
+        customerId: customer.id,
+        objectId: invoice.id,
+        type: 'invoice.updated',
+      }),
+    )
+    expect((await StripeCustomers.get(db, 'org_1'))?.status).toBe('active')
+
+    await stripe.invoices.update(invoice.id, { auto_advance: false })
+    await stripe.subscriptions.cancel(subscription)
+    await deliverEvent(
+      app,
+      await eventFor(stripe, {
+        customerId: customer.id,
+        objectId: subscription,
+        type: 'customer.subscription.deleted',
+      }),
+    )
+    expect((await StripeCustomers.get(db, 'org_1'))?.status).toBe('past_due')
+    expect((await stripe.subscriptions.list({ customer: customer.id })).data).toHaveLength(0)
+
+    await stripe.invoices.voidInvoice(invoice.id)
+    await deliverEvent(
+      app,
+      await eventFor(stripe, {
+        customerId: customer.id,
+        objectId: invoice.id,
+        type: 'invoice.voided',
+      }),
+    )
+    expect((await StripeCustomers.get(db, 'org_1'))?.status).toBe('active')
+  })
+
+  test('invoice updates refresh overdue billing and voiding restores eligibility', async () => {
+    const db = TestApp.database()
+    const stripe = TestStripe.client()
+    const app = createApp({ billing: sandboxBilling(), db })
+    const customer = await stripe.customers.create({
+      email: 'billing-1144@example.com',
+      metadata: { orgId: 'org_1' },
+    })
+    TestStripe.track(customer.id)
+    await StripeCustomers.create(db, { orgId: 'org_1', stripeCustomerId: customer.id })
+    await TestStripe.completeCheckout(app, {
+      customer: customer.id,
+      webhookSecret,
+    })
+
+    const draft = await stripe.invoices.create({
+      auto_advance: false,
+      collection_method: 'send_invoice',
+      customer: customer.id,
+      days_until_due: 30,
+    })
+    await stripe.invoiceItems.create({
+      amount: 500,
+      currency: 'usd',
+      customer: customer.id,
+      invoice: draft.id,
+    })
+    const invoice = await stripe.invoices.finalizeInvoice(draft.id)
+    expect(invoice.amount_remaining).toBe(500)
+    expect(invoice.attempted).toBe(false)
+    const event = await eventFor(stripe, {
+      customerId: customer.id,
+      objectId: invoice.id,
+      type: 'invoice.updated',
+    })
+    await deliverEvent(app, event)
+    expect((await StripeCustomers.get(db, 'org_1'))?.status).toBe('active')
+
+    vi.useFakeTimers({ toFake: ['Date'] })
+    try {
+      vi.setSystemTime((invoice.due_date! + 1) * 1_000)
+      await deliverEvent(app, event)
+      expect((await StripeCustomers.get(db, 'org_1'))?.status).toBe('past_due')
+    } finally {
+      vi.useRealTimers()
+    }
+
+    await stripe.invoices.markUncollectible(invoice.id)
+    await deliverEvent(
+      app,
+      await eventFor(stripe, {
+        customerId: customer.id,
+        objectId: invoice.id,
+        type: 'invoice.marked_uncollectible',
+      }),
+    )
+    expect((await StripeCustomers.get(db, 'org_1'))?.status).toBe('past_due')
+    await stripe.invoices.voidInvoice(invoice.id)
+    await deliverEvent(
+      app,
+      await eventFor(stripe, {
+        customerId: customer.id,
+        objectId: invoice.id,
+        type: 'invoice.voided',
+      }),
+    )
+    expect((await StripeCustomers.get(db, 'org_1'))?.status).toBe('active')
+  })
 })
 
 describe.runIf(TestStripe.secretKey)('stripe sandbox (live delivery)', () => {
@@ -1335,10 +1689,10 @@ describe.runIf(TestStripe.secretKey)('stripe sandbox (metering)', () => {
     expect(line?.amount).toBe(35)
   })
 
-  test(
-    'a failed metered invoice parks the org past_due; payment restores active',
+  test.each(['past_due', 'canceled'] as const)(
+    'a failed metered invoice blocks a %s subscription until payment',
     { timeout: 600_000 },
-    async () => {
+    async (status) => {
       // prettier-ignore
       const db = TestApp.database()
       const stripe = TestStripe.client()
@@ -1365,7 +1719,11 @@ describe.runIf(TestStripe.secretKey)('stripe sandbox (metering)', () => {
           invoice_settings: { default_payment_method: intent.payment_method as string },
         })
         await StripeCustomers.setStatus(db, 'org_1', 'active')
-        await core_Billing.ensureSubscription(stripe, customer.id)
+        await core_Billing.ensureSubscription(
+          stripe,
+          customer.id,
+          core_Billing.kindsFor('production'),
+        )
 
         // $5 of finalized usage so the invoice is worth charging.
         const row = await SponsoredTransactions.upsert(db, { ...meterable('org_1'), signPayload: `0x${'61'.repeat(32)}` }) // prettier-ignore
@@ -1377,15 +1735,64 @@ describe.runIf(TestStripe.secretKey)('stripe sandbox (metering)', () => {
         await stripe.testHelpers.testClocks.advance(clock.id, {
           frozen_time: Math.floor(Date.now() / 1000) + 32 * 24 * 60 * 60,
         })
-        const failed = await eventFor(stripe, 'invoice.payment_failed', customer.id)
+        // Failure events can arrive before the clock permits subscription or invoice updates.
+        await until(async () => (await stripe.testHelpers.testClocks.retrieve(clock.id)).status === 'ready', 240_000) // prettier-ignore
+        const failed = await eventFor(stripe, {
+          customerId: customer.id,
+          type: 'invoice.payment_failed',
+        })
         await deliverEvent(app, failed)
         expect((await StripeCustomers.get(db, 'org_1'))?.status).toBe('past_due')
 
+        const invoice = (failed.data.object as { id: string }).id
+        if (status === 'canceled') {
+          const subscriptions = await stripe.subscriptions.list({ customer: customer.id })
+          expect(subscriptions.data).toHaveLength(1)
+          await stripe.subscriptions.cancel(subscriptions.data[0]!.id)
+          const canceled = await eventFor(stripe, {
+            customerId: customer.id,
+            objectId: subscriptions.data[0]!.id,
+            type: 'customer.subscription.deleted',
+          })
+          await deliverEvent(app, canceled)
+          expect((await StripeCustomers.get(db, 'org_1'))?.status).toBe('past_due')
+          expect((await stripe.subscriptions.list({ customer: customer.id })).data).toHaveLength(0)
+
+          // Test-clock cancellation does not reliably pause collection. Exercise that state explicitly.
+          await stripe.invoices.update(invoice, { auto_advance: false })
+          await deliverEvent(app, canceled)
+          expect((await StripeCustomers.get(db, 'org_1'))?.status).toBe('past_due')
+
+          // Paying a different invoice must not erase the original debt.
+          const unrelated = await stripe.invoices.create({
+            auto_advance: false,
+            customer: customer.id,
+          })
+          await stripe.invoices.finalizeInvoice(unrelated.id)
+          await deliverEvent(
+            app,
+            await eventFor(stripe, {
+              customerId: customer.id,
+              objectId: unrelated.id,
+              type: 'invoice.paid',
+            }),
+          )
+          const refreshed = await stripe.customers.retrieve(customer.id)
+          expect(!refreshed.deleted && refreshed.delinquent).toBe(false)
+          expect((await StripeCustomers.get(db, 'org_1'))?.status).toBe('past_due')
+
+          await deliverEvent(app, canceled)
+          expect((await StripeCustomers.get(db, 'org_1'))?.status).toBe('past_due')
+        }
+
         // Pay the open invoice with a working card; `invoice.paid` re-derives.
         const paying = await TestStripe.attachCard(customer.id)
-        const invoice = (failed.data.object as { id: string }).id
         await stripe.invoices.pay(invoice, { payment_method: paying.paymentMethod })
-        const paid = await eventFor(stripe, 'invoice.paid', customer.id)
+        const paid = await eventFor(stripe, {
+          customerId: customer.id,
+          objectId: invoice,
+          type: 'invoice.paid',
+        })
         await deliverEvent(app, paid)
         expect((await StripeCustomers.get(db, 'org_1'))?.status).toBe('active')
       } finally {
@@ -1411,17 +1818,16 @@ function meterable(orgId: string) {
 }
 
 /** Polls the recorded event stream until one matches the customer. */
-async function eventFor(
-  stripe: Stripe,
-  type: 'invoice.paid' | 'invoice.payment_failed',
-  customerId: string,
-  timeout = 240_000,
-) {
-  const deadline = Date.now() + timeout
+async function eventFor(stripe: Stripe, options: eventFor.Options) {
+  const { customerId, objectId, type } = options
+  const deadline = Date.now() + 240_000
   while (Date.now() < deadline) {
     const events = await stripe.events.list({ limit: 100, type })
     const match = events.data.find(
-      (event) => (event.data.object as { customer?: string }).customer === customerId,
+      (event) =>
+        (event.data.object as { customer?: string }).customer === customerId &&
+        (objectId === undefined ||
+          ('id' in event.data.object && event.data.object.id === objectId)),
     )
     if (match) return match
     await new Promise((resolve) => setTimeout(resolve, 5_000))
@@ -1429,6 +1835,18 @@ async function eventFor(
   throw new Error(`no ${type} event recorded for ${customerId}`)
 }
 
+declare namespace eventFor {
+  /** Identifies a recorded Stripe event for the test customer. */
+  type Options = {
+    /** Customer whose event is delivered. */
+    customerId: string
+    /** Resource whose event is required, excluding unrelated invoices. */
+    objectId?: string | undefined
+    /** Stripe event type to await. */
+    type: Stripe.Event['type']
+  }
+}
+
 /** Delivers a recorded event to the app, signed with the suite's webhook secret. */
 async function deliverEvent(app: ReturnType<typeof createApp>, event: Stripe.Event) {
   const payload = JSON.stringify(event)
@@ -1439,3 +1857,47 @@ async function deliverEvent(app: ReturnType<typeof createApp>, event: Stripe.Eve
   })
   if (response.status !== 200) throw new Error(`webhook delivery returned ${response.status}`)
 }
+
+/** Forwards real Stripe traffic unchanged, pausing the subscription lookup during activation. */
+async function subscriptionBarrier() {
+  const paused = Promise.withResolvers<void>()
+  const release = Promise.withResolvers<void>()
+  const server = http.createServer((request, response) => {
+    const url = new URL(request.url!, 'https://api.stripe.com')
+    const upstream = https.request(
+      url,
+      {
+        headers: { ...request.headers, host: 'api.stripe.com' },
+        method: request.method,
+      },
+      async (result) => {
+        if (url.pathname === '/v1/subscriptions' && url.searchParams.get('status') === 'all') {
+          paused.resolve()
+          await release.promise
+        }
+        response.writeHead(result.statusCode!, result.headers)
+        result.pipe(response)
+      },
+    )
+    upstream.on('error', (error) => response.destroy(error))
+    request.pipe(upstream)
+  })
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve))
+  const address = server.address()
+  if (!address || typeof address === 'string') throw new Error('missing Stripe proxy port')
+  return {
+    client: new Stripe(TestStripe.secretKey!, {
+      host: '127.0.0.1',
+      maxNetworkRetries: 0,
+      port: address.port,
+      protocol: 'http',
+      timeout: 30_000,
+    }),
+    close: () =>
+      new Promise<void>((resolve, reject) =>
+        server.close((error) => (error ? reject(error) : resolve())),
+      ),
+    paused: paused.promise,
+    release: release.resolve,
+  }
+}