tapimo 0.14.0 → 0.15.1

package/src/apps/management/Billing.test.ts

@@ -5,10 +5,16 @@ import * as Runtime from '../../../test/runtime.js'
 import * as ApiKeys from '../../ApiKeys.js'
 import * as Db from '../../db/Db.js'
 import * as RequestUsage from '../../db/tables/requestUsage.js'
+import * as RoutesDeposits from '../../db/tables/routesDeposits.js'
+import * as RoutesTransfers from '../../db/tables/routesTransfers.js'
 import * as SponsoredTransactions from '../../db/tables/sponsoredTransactions.js'
 import * as StripeCustomers from '../../db/tables/stripeCustomers.js'
 import * as Store from '../../internal/Store.js'
 import * as Viem from '../../internal/Viem.js'
+import * as Deposit from '../../internal/routes/Deposit.js'
+import * as DepositAddress from '../../internal/routes/DepositAddress.js'
+import * as Transfer from '../../internal/routes/Transfer.js'
+import * as TestRoutes from '../../../test/Routes.js'
 import * as Billing from './Billing.js'
 
 const create = () => Db.postgres({ connectionString: Runtime.postgresUrl, schema: `t_${nanoid()}` })
@@ -41,18 +47,130 @@ async function finalized(
   return row
 }
 
+/** Persists one completed Routes subsidy through the route resource boundaries. */
+async function completedSubsidy(
+  db: Db.Db,
+  options: {
+    amount?: string | undefined
+    decimals?: number | undefined
+    environment?: 'production' | 'sandbox' | undefined
+    orgId?: string | undefined
+    providerAmount?: string | undefined
+    seed: string
+  },
+): Promise<RoutesDeposits.Record> {
+  const decimals = options.decimals ?? 6
+  const addressSnapshot = TestRoutes.depositAddressSnapshot({
+    address: `source-${options.seed}`,
+    destinationToken: {
+      ...TestRoutes.depositAddressSnapshot().destinationToken,
+      decimals,
+    },
+    recipient: `0x${options.seed.repeat(20)}`,
+    subsidize: options.amount !== undefined,
+  })
+  const address = await DepositAddress.create(db, {
+    deliveryStrategy: 'provider',
+    environment: options.environment ?? 'production',
+    orgId: options.orgId ?? 'org_1',
+    providerOutputToken: addressSnapshot.destinationToken,
+    snapshot: addressSnapshot,
+  })
+  const amount =
+    options.amount === undefined
+      ? undefined
+      : {
+          baseUnits: options.amount,
+          currency: 'USD',
+          decimals,
+          formatted: 'unused',
+        }
+  const row = await Deposit.create(db, {
+    providerRequestId: `request_${options.seed}`,
+    snapshot: TestRoutes.depositSnapshot(address.id, {
+      destinationToken: addressSnapshot.destinationToken,
+    }),
+    sourceTransactionHash: `0x${options.seed.repeat(32)}`,
+    ...(amount
+      ? {
+          settlementTransaction: `0x${options.seed.repeat(32)}`,
+          settlementTransactionHash: `0x${options.seed.repeat(32)}`,
+          subsidyAmount: amount,
+        }
+      : {}),
+    ...(options.providerAmount
+      ? {
+          providerSubsidy: {
+            amount: {
+              baseUnits: options.providerAmount,
+              currency: 'USD',
+              decimals: addressSnapshot.sourceToken.decimals,
+              formatted: 'unused',
+            },
+            provider: 'relay' as const,
+            token: addressSnapshot.sourceToken,
+          },
+        }
+      : {}),
+  })
+  const result = await Deposit.transition(db, {
+    expectedVersion: row.version,
+    id: row.id,
+    status: 'completed',
+    ...(amount ? { subsidyAmount: amount } : {}),
+  })
+  if (result.type !== 'applied') throw new Error('Expected completed Routes subsidy.')
+  return result.record
+}
+
+/** Persists one completed outbound Routes subsidy. */
+async function completedTransferSubsidy(db: Db.Db): Promise<RoutesTransfers.Record> {
+  const transfer = await Transfer.create(db, {
+    apiKeyId: 'key_outbound_subsidy',
+    environment: 'production',
+    orgId: 'org_1',
+    snapshot: TestRoutes.transferSnapshot({ subsidize: true }),
+  })
+  const processing = await Transfer.transition(db, {
+    expectedVersion: transfer.version,
+    id: transfer.id,
+    status: 'processing',
+  })
+  if (processing.type !== 'applied') throw new Error('Expected processing transfer.')
+  const completed = await Transfer.transition(db, {
+    expectedVersion: processing.record.version,
+    id: transfer.id,
+    status: 'completed',
+    subsidyAmount: {
+      baseUnits: '3001',
+      currency: 'USD',
+      decimals: 6,
+      formatted: '0.003001',
+    },
+    subsidyTransactionHash: `0x${'41'.repeat(32)}`,
+  })
+  if (completed.type !== 'applied') throw new Error('Expected completed transfer subsidy.')
+  return completed.record
+}
+
 /** Managed meter/price ids per kind, keyed by lookup key. */
 const priceByLookup: Record<string, string> = {
   [Billing.meters.apiRequests.lookupKey]: 'price_req',
   [Billing.meters.feePayerSpend.lookupKey]: 'price_fee',
+  [Billing.meters.routeSubsidy.lookupKey]: 'price_route',
 }
 const meterByEvent: Record<string, string> = {
   [Billing.meters.apiRequests.eventName]: 'mtr_req',
   [Billing.meters.feePayerSpend.eventName]: 'mtr_fee',
+  [Billing.meters.routeSubsidy.eventName]: 'mtr_route',
 }
 
 /** A stubbed subscription: live status plus which managed kinds it carries as items. */
-type StubSubscription = { items?: readonly Billing.MeterKind[]; status: string }
+type StubSubscription = {
+  createdAt?: number | undefined
+  items?: readonly Billing.MeterKind[] | undefined
+  status: string
+}
 
 /**
  * A Stripe stub covering the reporter/subscription surface: fixtures resolve
@@ -76,6 +194,7 @@ function stubStripe(options: {
     id: `sub_${subscriptionsCreated.length}_${Math.random().toString(36).slice(2, 8)}`,
     items: {
       data: (subscription.items ?? ['feePayerSpend']).map((kind) => ({
+        created: subscription.createdAt ?? 0,
         price: { id: priceByLookup[Billing.meters[kind].lookupKey] },
       })),
     },
@@ -120,13 +239,20 @@ function stubStripe(options: {
     subscriptionItems: {
       create: async (params: { price: string; subscription: string }) => {
         itemsCreated.push(params)
-        return {}
+        return { created: Math.floor(Date.now() / 1_000) }
       },
     },
     subscriptions: {
       create: async (params: { items: { price: string }[] }) => {
         subscriptionsCreated.push(params)
-        return {}
+        return {
+          items: {
+            data: params.items.map(({ price }) => ({
+              created: Math.floor(Date.now() / 1_000),
+              price: { id: price },
+            })),
+          },
+        }
       },
       list: async () => {
         await options.subscriptionsList?.()
@@ -160,6 +286,18 @@ describe('toBaseUnits', () => {
   })
 })
 
+describe('meters', () => {
+  test('behavior: gives Route Subsidy a separate product, meter, and price identity', () => {
+    expect(Billing.meters.routeSubsidy).toEqual({
+      displayName: 'Route Subsidy',
+      eventName: 'route_subsidy_spend',
+      lookupKey: 'route-subsidy-spend-v1',
+      unitAmountDecimal: '0.0001',
+    })
+    expect(Billing.meters.routeSubsidy.eventName).not.toBe(Billing.meters.feePayerSpend.eventName)
+  })
+})
+
 describe('status', () => {
   test('behavior: reflects the stored billing source status', async () => {
     const db = create()
@@ -199,6 +337,38 @@ describe('createReporter', () => {
     await db.close()
   })
 
+  test('behavior: a failed Routes batch does not starve sponsorship billing', async () => {
+    const db = create()
+    await db.migrate()
+    const routes = await completedSubsidy(db, {
+      amount: '50000',
+      orgId: 'org_routes',
+      seed: '36',
+    })
+    await db.kysely
+      .updateTable('routes_deposits')
+      .set({ statusUpdatedAt: '2026-01-01T00:00:00.000Z' })
+      .where('id', '=', routes.id)
+      .execute()
+    await StripeCustomers.create(db, { orgId: 'org_1', stripeCustomerId: 'cus_1' })
+    const sponsorship = await finalized(db, { feeAmount: '100000', seed: '37' })
+
+    const { meterEvents, stripe } = stubStripe({
+      subscriptions: [
+        { items: ['feePayerSpend', 'routeSubsidy', 'apiRequests'], status: 'active' },
+      ],
+    })
+    expect(await Billing.createReporter({ batchSize: 1, db, stripe }).tick()).toStrictEqual({
+      failed: 1,
+      reported: 1,
+      skipped: 0,
+    })
+    expect(meterEvents.map(({ identifier }) => identifier)).toEqual([sponsorship.id])
+    expect((await SponsoredTransactions.get(db, sponsorship.id))?.meterReportedAt).not.toBeNull()
+    expect((await RoutesDeposits.get(db, routes.id))?.subsidyMeterReportedAt).toBeNull()
+    await db.close()
+  })
+
   test('behavior: marks a meter event that Stripe already accepted', async () => {
     const db = create()
     await db.migrate()
@@ -266,6 +436,41 @@ describe('createReporter', () => {
     await db.close()
   })
 
+  test('behavior: preserves a Route item cutoff across reporting ticks', async () => {
+    const db = create()
+    await db.migrate()
+    await StripeCustomers.create(db, { orgId: 'org_1', stripeCustomerId: 'cus_1' })
+    const first = await completedSubsidy(db, { amount: '100000', seed: '39' })
+    const second = await completedSubsidy(db, { amount: '250000', seed: '40' })
+    const finalizedAt = new Date(Date.now() - 24 * 60 * 60 * 1_000).toISOString()
+    await db.kysely
+      .updateTable('routes_deposits')
+      .set({ statusUpdatedAt: finalizedAt })
+      .where('id', 'in', [first.id, second.id])
+      .execute()
+
+    const initial = stubStripe({ subscriptions: [] })
+    expect(
+      await Billing.createReporter({ batchSize: 1, db, stripe: initial.stripe }).tick(),
+    ).toStrictEqual({ failed: 0, reported: 1, skipped: 0 })
+    expect(initial.meterEvents[0]?.timestamp).toBeUndefined()
+
+    const following = stubStripe({
+      subscriptions: [
+        {
+          createdAt: Math.floor(Date.now() / 1_000),
+          items: ['feePayerSpend', 'routeSubsidy', 'apiRequests'],
+          status: 'active',
+        },
+      ],
+    })
+    expect(
+      await Billing.createReporter({ batchSize: 1, db, stripe: following.stripe }).tick(),
+    ).toStrictEqual({ failed: 0, reported: 1, skipped: 0 })
+    expect(following.meterEvents[0]?.timestamp).toBeUndefined()
+    await db.close()
+  })
+
   test('behavior: an existing subscription keeps finalization timestamps', async () => {
     const db = create()
     await db.migrate()
@@ -285,6 +490,165 @@ describe('createReporter', () => {
     expect(meterEvents[0]?.timestamp).toBe(Math.floor(finalizedAt.getTime() / 1000))
     await db.close()
   })
+
+  test('behavior: reports completed production Routes subsidies through Route Subsidy', async () => {
+    const db = create()
+    await db.migrate()
+    await StripeCustomers.create(db, { orgId: 'org_1', stripeCustomerId: 'cus_1' })
+    const sponsorship = await finalized(db, { feeAmount: '100000', seed: '31' })
+    const routes = await completedSubsidy(db, {
+      amount: '1000000000001',
+      decimals: 18,
+      providerAmount: '23838',
+      seed: '32',
+    })
+    const sandbox = await completedSubsidy(db, {
+      amount: '50000',
+      environment: 'sandbox',
+      seed: '33',
+    })
+    const transfer = await completedTransferSubsidy(db)
+
+    const { meterEvents, stripe } = stubStripe({
+      subscriptions: [
+        { items: ['feePayerSpend', 'routeSubsidy', 'apiRequests'], status: 'active' },
+      ],
+    })
+    expect(await Billing.createReporter({ db, stripe }).tick()).toStrictEqual({
+      failed: 0,
+      reported: 3,
+      skipped: 0,
+    })
+    expect(meterEvents).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          event_name: 'fee_payer_spend',
+          identifier: sponsorship.id,
+          payload: { stripe_customer_id: 'cus_1', value: '100000' },
+        }),
+        expect.objectContaining({
+          event_name: 'route_subsidy_spend',
+          identifier: routes.id,
+          payload: { stripe_customer_id: 'cus_1', value: '23840' },
+        }),
+        expect.objectContaining({
+          event_name: 'route_subsidy_spend',
+          identifier: transfer.id,
+          payload: { stripe_customer_id: 'cus_1', value: '3001' },
+        }),
+      ]),
+    )
+    expect((await RoutesDeposits.get(db, routes.id))?.subsidyMeterReportedAt).not.toBeNull()
+    expect((await RoutesDeposits.get(db, sandbox.id))?.subsidyMeterReportedAt).toBeNull()
+    expect((await RoutesTransfers.get(db, transfer.id))?.subsidyMeterReportedAt).not.toBeNull()
+    expect(await Billing.createReporter({ db, stripe }).tick()).toStrictEqual({
+      failed: 0,
+      reported: 0,
+      skipped: 0,
+    })
+    await db.close()
+  })
+
+  test('behavior: attributes old Routes backlog to its effective Stripe period', async () => {
+    const db = create()
+    await db.migrate()
+    await StripeCustomers.create(db, { orgId: 'org_1', stripeCustomerId: 'cus_1' })
+    const routes = await completedSubsidy(db, { amount: '50000', seed: '38' })
+    await db.kysely
+      .updateTable('routes_deposits')
+      .set({ statusUpdatedAt: '2025-01-15T00:00:00.000Z' })
+      .where('id', '=', routes.id)
+      .execute()
+
+    const { meterEvents, stripe } = stubStripe({
+      subscriptions: [
+        { items: ['feePayerSpend', 'routeSubsidy', 'apiRequests'], status: 'active' },
+      ],
+    })
+    expect(await Billing.createReporter({ db, stripe }).tick()).toStrictEqual({
+      failed: 0,
+      reported: 1,
+      skipped: 0,
+    })
+    expect(meterEvents[0]?.timestamp).toBeUndefined()
+    const meteredAt = (await RoutesDeposits.get(db, routes.id))?.subsidyMeterReportedAt
+    if (!meteredAt) throw new Error('Expected the effective Stripe meter-event time.')
+    expect(
+      await RoutesDeposits.subsidyUsage(db, {
+        environment: 'production',
+        from: '2025-01-01T00:00:00.000Z',
+        orgId: 'org_1',
+        to: '2025-01-31T23:59:59.999Z',
+      }),
+    ).toEqual({ amount: 0n, count: 0 })
+    expect(
+      await RoutesDeposits.subsidyUsage(db, {
+        environment: 'production',
+        from: meteredAt,
+        orgId: 'org_1',
+        to: meteredAt,
+      }),
+    ).toEqual({ amount: 50_000n, count: 1 })
+    await db.close()
+  })
+
+  test('behavior: retries a Routes subsidy after Stripe rejects its event', async () => {
+    const db = create()
+    await db.migrate()
+    await StripeCustomers.create(db, { orgId: 'org_1', stripeCustomerId: 'cus_1' })
+    const routes = await completedSubsidy(db, { amount: '50000', seed: '34' })
+    const { stripe } = stubStripe({
+      meterEvent() {
+        throw new Error('Stripe unavailable')
+      },
+      subscriptions: [
+        { items: ['feePayerSpend', 'routeSubsidy', 'apiRequests'], status: 'active' },
+      ],
+    })
+
+    expect(await Billing.createReporter({ db, stripe }).tick()).toStrictEqual({
+      failed: 1,
+      reported: 0,
+      skipped: 0,
+    })
+    expect((await RoutesDeposits.get(db, routes.id))?.subsidyMeterReportedAt).toBeNull()
+    await db.close()
+  })
+
+  test('behavior: keeps Routes spend unreported when its Stripe customer is unavailable', async () => {
+    const db = create()
+    await db.migrate()
+    const routes = await completedSubsidy(db, { amount: '50000', seed: '35' })
+    const { stripe } = stubStripe({})
+
+    expect(await Billing.createReporter({ db, stripe }).tick()).toStrictEqual({
+      failed: 1,
+      reported: 0,
+      skipped: 0,
+    })
+    expect((await RoutesDeposits.get(db, routes.id))?.subsidyMeterReportedAt).toBeNull()
+    await db.close()
+  })
+
+  test('behavior: skips provider subsidies owned by a one-off API key', async () => {
+    const db = create()
+    await db.migrate()
+    const routes = await completedSubsidy(db, {
+      orgId: 'key_one_off',
+      providerAmount: '23838',
+      seed: '36',
+    })
+    const { meterEvents, stripe } = stubStripe({})
+
+    expect(await Billing.createReporter({ db, stripe }).tick()).toStrictEqual({
+      failed: 0,
+      reported: 0,
+      skipped: 1,
+    })
+    expect(meterEvents).toHaveLength(0)
+    expect((await RoutesDeposits.get(db, routes.id))?.subsidyMeterReportedAt).not.toBeNull()
+    await db.close()
+  })
 })
 
 describe('createKeyBillingSyncer', () => {
@@ -365,31 +729,28 @@ describe('createKeyBillingSyncer', () => {
 describe('ensureSubscription', () => {
   test('behavior: adds the missing item to a live subscription', async () => {
     const { itemsCreated, stripe, subscriptionsCreated } = stubStripe({
-      subscriptions: [{ items: ['feePayerSpend'], status: 'active' }],
+      subscriptions: [{ items: ['feePayerSpend', 'apiRequests'], status: 'active' }],
     })
-    const result = await Billing.ensureSubscription(stripe, 'cus_1', [
-      'feePayerSpend',
-      'apiRequests',
-    ])
+    const result = await Billing.ensureSubscription(stripe, 'cus_1', Billing.kindsFor('production'))
     expect(result.created).toBe(false)
     expect(subscriptionsCreated).toHaveLength(0)
-    expect(itemsCreated).toEqual([{ price: 'price_req', subscription: expect.any(String) }])
-    expect(result.items.apiRequests?.created).toBe(true)
+    expect(itemsCreated).toEqual([{ price: 'price_route', subscription: expect.any(String) }])
+    expect(result.items.apiRequests?.created).toBe(false)
     expect(result.items.feePayerSpend?.created).toBe(false)
+    expect(result.items.routeSubsidy?.created).toBe(true)
   })
 
   test('behavior: creates a subscription carrying every requested item', async () => {
     const { stripe, subscriptionsCreated } = stubStripe({ subscriptions: [] })
-    const result = await Billing.ensureSubscription(stripe, 'cus_1', [
-      'feePayerSpend',
-      'apiRequests',
-    ])
+    const result = await Billing.ensureSubscription(stripe, 'cus_1', Billing.kindsFor('production'))
     expect(result.created).toBe(true)
     expect(subscriptionsCreated).toHaveLength(1)
     expect(subscriptionsCreated[0]!.items.map((item) => item.price).sort()).toEqual([
       'price_fee',
       'price_req',
+      'price_route',
     ])
+    expect(result.items.routeSubsidy?.created).toBe(true)
   })
 
   test('behavior: fails closed on multiple live managed subscriptions', async () => {