tapimo 0.6.0 → 0.7.1

package/src/db/tables/enabledBillingSources.test.ts

@@ -0,0 +1,303 @@
+import { nanoid } from 'nanoid'
+
+import * as Runtime from '../../../test/runtime.js'
+import * as Db from '../Db.js'
+import * as EarlyAccess from './earlyAccess.js'
+import * as EnabledBillingSources from './enabledBillingSources.js'
+import * as Invitations from './invitations.js'
+import * as Organizations from './organizations.js'
+import * as StripeCustomers from './stripeCustomers.js'
+import * as Users from './users.js'
+
+const create = () => Db.postgres({ connectionString: Runtime.postgresUrl, schema: `t_${nanoid()}` })
+
+async function createOwned(db: Db.Db, options: createOwned.Options) {
+  const user = await Users.upsertByAddress(db, { address: options.address })
+  if (options.email) await Users.setEmail(db, user.id, options.email)
+  const organization = await Organizations.createOwned(db, { name: options.name, userId: user.id })
+  return { organization, user }
+}
+
+declare namespace createOwned {
+  /** Inputs for an owned-organization fixture. */
+  type Options = {
+    /** User address. */
+    address: string
+    /** Optional user email. */
+    email?: string | undefined
+    /** Organization name. */
+    name: string
+  }
+}
+
+/** Redacts nondeterministic row fields. */
+function redact(record: EnabledBillingSources.Record) {
+  return { ...record, createdAt: '<timestamp>' }
+}
+
+describe('add', () => {
+  test('behavior: enables each source once per organization', async () => {
+    const db = create()
+    await db.migrate()
+    const stripe = await EnabledBillingSources.add(db, {
+      createdBy: 'admin@tempo.xyz',
+      orgId: 'org_1',
+      source: 'stripe',
+    })
+    expect(stripe && redact(stripe)).toMatchInlineSnapshot(`
+      {
+        "createdAt": "<timestamp>",
+        "createdBy": "admin@tempo.xyz",
+        "orgId": "org_1",
+        "source": "stripe",
+      }
+    `)
+    expect(
+      await EnabledBillingSources.add(db, {
+        createdBy: 'other@tempo.xyz',
+        orgId: 'org_1',
+        source: 'stripe',
+      }),
+    ).toBeUndefined()
+    expect(
+      await EnabledBillingSources.add(db, {
+        createdBy: 'admin@tempo.xyz',
+        orgId: 'org_1',
+        source: 'tempo',
+      }),
+    ).toBeDefined()
+    await db.close()
+  })
+})
+
+describe('listByOrg', () => {
+  test('behavior: lists only the organization in canonical source order', async () => {
+    const db = create()
+    await db.migrate()
+    await EnabledBillingSources.add(db, {
+      createdBy: 'admin@tempo.xyz',
+      orgId: 'org_1',
+      source: 'tempo',
+    })
+    await EnabledBillingSources.add(db, {
+      createdBy: 'admin@tempo.xyz',
+      orgId: 'org_2',
+      source: 'stripe',
+    })
+    await EnabledBillingSources.add(db, {
+      createdBy: 'admin@tempo.xyz',
+      orgId: 'org_1',
+      source: 'stripe',
+    })
+    expect((await EnabledBillingSources.listByOrg(db, 'org_1')).map(redact)).toMatchInlineSnapshot(`
+        [
+          {
+            "createdAt": "<timestamp>",
+            "createdBy": "admin@tempo.xyz",
+            "orgId": "org_1",
+            "source": "stripe",
+          },
+          {
+            "createdAt": "<timestamp>",
+            "createdBy": "admin@tempo.xyz",
+            "orgId": "org_1",
+            "source": "tempo",
+          },
+        ]
+      `)
+    await db.close()
+  })
+
+  test('behavior: new organizations start with no enabled sources', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_new', name: 'New' })
+    expect(await EnabledBillingSources.listByOrg(db, 'org_new')).toEqual([])
+    await db.close()
+  })
+})
+
+describe('remove', () => {
+  test('behavior: removes one source and reports absence', async () => {
+    const db = create()
+    await db.migrate()
+    await EnabledBillingSources.add(db, {
+      createdBy: 'admin@tempo.xyz',
+      orgId: 'org_1',
+      source: 'stripe',
+    })
+    await EnabledBillingSources.add(db, {
+      createdBy: 'admin@tempo.xyz',
+      orgId: 'org_1',
+      source: 'tempo',
+    })
+    expect(
+      redact(
+        (await EnabledBillingSources.remove(db, {
+          orgId: 'org_1',
+          source: 'stripe',
+        }))!,
+      ),
+    ).toMatchInlineSnapshot(`
+      {
+        "createdAt": "<timestamp>",
+        "createdBy": "admin@tempo.xyz",
+        "orgId": "org_1",
+        "source": "stripe",
+      }
+    `)
+    expect(
+      await EnabledBillingSources.remove(db, { orgId: 'org_1', source: 'stripe' }),
+    ).toBeUndefined()
+    expect(await EnabledBillingSources.isEnabled(db, { orgId: 'org_1', source: 'tempo' })).toBe(
+      true,
+    )
+    await db.close()
+  })
+})
+
+describe('isEnabled', () => {
+  test('behavior: checks one organization and source', async () => {
+    const db = create()
+    await db.migrate()
+    await EnabledBillingSources.add(db, {
+      createdBy: 'admin@tempo.xyz',
+      orgId: 'org_1',
+      source: 'stripe',
+    })
+    expect(await EnabledBillingSources.isEnabled(db, { orgId: 'org_1', source: 'stripe' })).toBe(
+      true,
+    )
+    expect(await EnabledBillingSources.isEnabled(db, { orgId: 'org_1', source: 'tempo' })).toBe(
+      false,
+    )
+    expect(await EnabledBillingSources.isEnabled(db, { orgId: 'org_2', source: 'stripe' })).toBe(
+      false,
+    )
+    await db.close()
+  })
+})
+
+describe('migration', () => {
+  test('behavior: catch-up backfills one Stripe source per distinct customer organization', async () => {
+    const db = create()
+    await db.migrate()
+    await StripeCustomers.create(db, { orgId: 'org_1', stripeCustomerId: 'cus_live_1' })
+    await StripeCustomers.create(db, {
+      environment: 'sandbox',
+      orgId: 'org_1',
+      stripeCustomerId: 'cus_test_1',
+    })
+    await StripeCustomers.create(db, { orgId: 'org_2', stripeCustomerId: 'cus_live_2' })
+    await db.kysely
+      .deleteFrom('migrations')
+      .where('name', '=', '0072_enabled_billing_sources_stripe_catch_up')
+      .execute()
+    await db.migrate()
+    await db.kysely
+      .deleteFrom('migrations')
+      .where('name', '=', '0072_enabled_billing_sources_stripe_catch_up')
+      .execute()
+    await db.migrate()
+
+    expect(
+      (await EnabledBillingSources.listByOrg(db, 'org_1')).map((record) => ({
+        createdBy: record.createdBy,
+        source: record.source,
+      })),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "createdBy": "migration",
+          "source": "stripe",
+        },
+      ]
+    `)
+    expect((await EnabledBillingSources.listByOrg(db, 'org_2')).map((record) => record.source))
+      .toMatchInlineSnapshot(`
+        [
+          "stripe",
+        ]
+      `)
+    await db.close()
+  })
+
+  test('behavior: backfills Stripe only for organizations owned by allowlisted users', async () => {
+    const db = create()
+    await db.migrate()
+    await EarlyAccess.add(db, { createdBy: 'admin@tempo.xyz', entry: 'exact@example.net' })
+    await EarlyAccess.add(db, { createdBy: 'admin@tempo.xyz', entry: 'example.org' })
+    const exact = await createOwned(db, {
+      address: `0x${'11'.repeat(20)}`,
+      email: ' Exact@Example.NET ',
+      name: 'Exact',
+    })
+    const domain = await createOwned(db, {
+      address: `0x${'22'.repeat(20)}`,
+      email: 'Owner@Example.ORG',
+      name: 'Domain',
+    })
+    const invited = await createOwned(db, {
+      address: `0x${'33'.repeat(20)}`,
+      email: 'Invited@Example.NET',
+      name: 'Invited',
+    })
+    const legacyInvitation = await Invitations.create(db, {
+      email: 'invited@example.net',
+      expiresAt: '2020-01-01T00:00:00.000Z',
+      invitedBy: exact.user.id,
+      orgId: exact.organization.id,
+      role: 'member',
+    })
+    await db.kysely
+      .updateTable('invitations')
+      .set({ grantsEarlyAccess: true })
+      .where('id', '=', legacyInvitation.id)
+      .execute()
+    const plain = await createOwned(db, {
+      address: `0x${'44'.repeat(20)}`,
+      email: 'plain@example.net',
+      name: 'Plain',
+    })
+    const emailLess = await createOwned(db, {
+      address: `0x${'55'.repeat(20)}`,
+      name: 'Email-less',
+    })
+
+    for (let attempt = 0; attempt < 2; attempt++) {
+      await db.kysely
+        .deleteFrom('migrations')
+        .where('name', '=', '0073_enabled_billing_sources_early_access_backfill')
+        .execute()
+      await db.migrate()
+    }
+
+    const result = await Promise.all(
+      [exact, domain, invited, plain, emailLess].map(async ({ organization }) =>
+        (await EnabledBillingSources.listByOrg(db, organization.id)).map(
+          ({ createdBy, source }) => ({ createdBy, source }),
+        ),
+      ),
+    )
+    expect(result).toMatchInlineSnapshot(`
+      [
+        [
+          {
+            "createdBy": "migration",
+            "source": "stripe",
+          },
+        ],
+        [
+          {
+            "createdBy": "migration",
+            "source": "stripe",
+          },
+        ],
+        [],
+        [],
+        [],
+      ]
+    `)
+    await db.close()
+  })
+})

package/src/db/tables/enabledBillingSources.ts

@@ -0,0 +1,118 @@
+import type { Selectable } from 'kysely'
+
+import type * as Db from '../Db.js'
+import type * as db_Schema from '../Schema.js'
+
+/** Columns of the `enabled_billing_sources` table, derived from `Schema.EnabledBillingSource`. */
+export type Table = db_Schema.EnabledBillingSource
+
+/** A stored enabled billing-source row. */
+export type Record = Selectable<Table>
+
+/** An enabled billing-source type. */
+export type Source = Record['source']
+
+/** Billing-source types in canonical display order. */
+export const sources = ['stripe', 'tempo'] as const satisfies readonly Source[]
+
+/**
+ * Enables a billing-source type for an organization.
+ *
+ * @param db - The database.
+ * @param input - The source to enable.
+ * @returns The stored row, or `undefined` when already enabled.
+ */
+export function add(db: Db.Db, input: add.Input): Promise<Record | undefined> {
+  return db.kysely
+    .insertInto('enabled_billing_sources')
+    .values({
+      createdAt: new Date().toISOString(),
+      createdBy: input.createdBy,
+      orgId: input.orgId,
+      source: input.source,
+    })
+    .onConflict((oc) => oc.columns(['orgId', 'source']).doNothing())
+    .returningAll()
+    .executeTakeFirst()
+}
+
+export declare namespace add {
+  /** Fields accepted when enabling a billing source. */
+  type Input = {
+    /** Identity enabling the source. */
+    createdBy: string
+    /** Organization id (`org_…`) the source is enabled for. */
+    orgId: string
+    /** Billing-source type to enable. */
+    source: Source
+  }
+}
+
+/**
+ * Lists an organization's enabled billing sources in canonical order.
+ *
+ * @param db - The database.
+ * @param orgId - The organization id (`org_…`).
+ * @returns The enabled sources.
+ */
+export function listByOrg(db: Db.Db, orgId: string): Promise<Record[]> {
+  return db.kysely
+    .selectFrom('enabled_billing_sources')
+    .selectAll()
+    .where('orgId', '=', orgId)
+    .orderBy('source', 'asc')
+    .execute()
+}
+
+/**
+ * Removes one enabled billing source from an organization.
+ *
+ * @param db - The database.
+ * @param input - The source to remove.
+ * @returns The removed row, or `undefined` when absent.
+ */
+export function remove(db: Db.Db, input: remove.Input): Promise<Record | undefined> {
+  return db.kysely
+    .deleteFrom('enabled_billing_sources')
+    .where('orgId', '=', input.orgId)
+    .where('source', '=', input.source)
+    .returningAll()
+    .executeTakeFirst()
+}
+
+export declare namespace remove {
+  /** Fields identifying one enabled billing source. */
+  type Input = {
+    /** Organization id (`org_…`) the source is enabled for. */
+    orgId: string
+    /** Billing-source type to remove. */
+    source: Source
+  }
+}
+
+/**
+ * Checks whether a billing-source type is enabled for an organization.
+ *
+ * @param db - The database.
+ * @param input - The source to check.
+ * @returns Whether the source is enabled.
+ */
+export async function isEnabled(db: Db.Db, input: isEnabled.Input): Promise<boolean> {
+  const record = await db.kysely
+    .selectFrom('enabled_billing_sources')
+    .select('source')
+    .where('orgId', '=', input.orgId)
+    .where('source', '=', input.source)
+    .executeTakeFirst()
+  return record !== undefined
+}
+
+export declare namespace isEnabled {
+  /** Fields identifying one enabled billing source. */
+  type Input = {
+    /** Organization id (`org_…`) the source is enabled for. */
+    orgId: string
+    /** Billing-source type to check. */
+    source: Source
+  }
+}

package/src/db/tables/invitations.ts

@@ -1,4 +1,4 @@
-import { type Selectable, sql } from 'kysely'
+import type { Selectable } from 'kysely'
 
 import * as Id from '../../internal/Id.js'
 import type * as Db from '../Db.js'
@@ -31,7 +31,8 @@ export function create(db: Db.Db, input: create.Input): Promise<Record> {
       createdAt: now,
       email: input.email.toLowerCase(),
       expiresAt: input.expiresAt,
-      grantsEarlyAccess: input.grantsEarlyAccess,
+      // Keep the legacy column inert until it can be removed safely.
+      grantsEarlyAccess: false,
       id: Id.generate('inv'),
       invitedBy: input.invitedBy,
       orgId: input.orgId,
@@ -46,8 +47,7 @@ export function create(db: Db.Db, input: create.Input): Promise<Record> {
         .doUpdateSet({
           createdAt: now,
           expiresAt: input.expiresAt,
-          // Re-invites upgrade the grant, never withdraw it (raw SQL stays snake_case).
-          grantsEarlyAccess: sql<boolean>`invitations.grants_early_access OR excluded.grants_early_access`,
+          grantsEarlyAccess: false,
           invitedBy: input.invitedBy,
           role: input.role,
         }),
@@ -63,8 +63,6 @@ export declare namespace create {
     email: string
     /** When the invitation expires (ISO 8601). */
     expiresAt: string
-    /** Whether accepting grants early access; stamped from the inviter's own access. */
-    grantsEarlyAccess: boolean
     /** User or API key id creating the invitation. */
     invitedBy: string
     /** Organization id (`org_…`) the invitation joins. */
@@ -119,26 +117,6 @@ export function listByEmail(db: Db.Db, email: string): Promise<(Record & { orgNa
     .execute()
 }
 
-/**
- * Whether any unrevoked invitation grants `email` early access. Acceptance and
- * expiry are deliberately ignored: a trusted invite grants access until revoked.
- *
- * @param db - The database.
- * @param email - The invitee email (matched lowercase).
- * @returns Whether a grant exists.
- */
-export async function hasEarlyAccessGrant(db: Db.Db, email: string): Promise<boolean> {
-  const row = await db.kysely
-    .selectFrom('invitations')
-    .select('id')
-    .where('email', '=', email.toLowerCase())
-    .where('grantsEarlyAccess', '=', true)
-    .where('revokedAt', 'is', null)
-    .limit(1)
-    .executeTakeFirst()
-  return row !== undefined
-}
-
 /**
  * Revokes a pending invitation.
  *

package/src/db/tables/organizations.test.ts

@@ -2,7 +2,10 @@ import { nanoid } from 'nanoid'
 
 import * as Runtime from '../../../test/runtime.js'
 import * as Webhooks from '../../internal/Webhooks.js'
+import * as Viem from '../../internal/Viem.js'
 import * as Db from '../Db.js'
+import * as EnabledBillingSources from './enabledBillingSources.js'
+import * as Memberships from './memberships.js'
 import * as Organizations from './organizations.js'
 import * as SponsoredTransactions from './sponsoredTransactions.js'
 import * as StripeCustomers from './stripeCustomers.js'
@@ -60,6 +63,66 @@ describe('create', () => {
   })
 })
 
+describe('createOwned', () => {
+  test('behavior: creates the organization, owner, and enabled sources atomically', async () => {
+    const db = create()
+    await db.migrate()
+    const record = await Organizations.createOwned(db, {
+      enabledBillingSources: ['stripe'],
+      name: 'Acme, Inc.',
+      userId: 'usr_owner',
+    })
+
+    expect(
+      (await Memberships.listByOrg(db, record.id)).map(({ role, userId }) => ({ role, userId })),
+    ).toMatchInlineSnapshot(`
+        [
+          {
+            "role": "owner",
+            "userId": "usr_owner",
+          },
+        ]
+      `)
+    expect(
+      (await EnabledBillingSources.listByOrg(db, record.id)).map(({ createdBy, source }) => ({
+        createdBy,
+        source,
+      })),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "createdBy": "usr_owner",
+          "source": "stripe",
+        },
+      ]
+    `)
+    await db.close()
+  })
+
+  test('behavior: rolls back all rows when initial source insertion fails', async () => {
+    const db = create()
+    await db.migrate()
+
+    await expect(
+      Organizations.createOwned(db, {
+        enabledBillingSources: ['stripe', 'stripe'],
+        name: 'Acme, Inc.',
+        userId: 'usr_owner',
+      }),
+    ).rejects.toThrow()
+    expect(await Organizations.listByUser(db, 'usr_owner')).toEqual([])
+    expect(await db.kysely.selectFrom('enabled_billing_sources').selectAll().execute()).toEqual([])
+    expect(
+      await db.kysely
+        .selectFrom('memberships')
+        .selectAll()
+        .where('userId', '=', 'usr_owner')
+        .execute(),
+    ).toEqual([])
+    await db.close()
+  })
+})
+
 describe('get', () => {
   test('behavior: returns undefined when absent', async () => {
     const db = create()
@@ -137,6 +200,11 @@ describe('deleteOrganization', () => {
       orgId: 'org_1',
       stripeCustomerId: 'cus_org_1',
     })
+    await EnabledBillingSources.add(db, {
+      createdBy: 'admin@tempo.xyz',
+      orgId: 'org_1',
+      source: 'stripe',
+    })
     await SponsoredTransactions.upsert(db, {
       apiKeyId: 'key_1',
       billable: true,
@@ -149,14 +217,137 @@ describe('deleteOrganization', () => {
       transactionHash: `0x${'aa'.repeat(32)}`,
     })
 
+    expect(await Organizations.hasUnreportedSponsorships(db, 'org_1')).toBe(true)
     await expect(Organizations.deleteOrganization(db, 'org_1')).rejects.toThrow(
       Organizations.UnreportedSponsorshipsError,
     )
     expect(await Organizations.get(db, 'org_1')).toBeDefined()
+    expect(await EnabledBillingSources.isEnabled(db, { orgId: 'org_1', source: 'stripe' })).toBe(
+      true,
+    )
     expect(await StripeCustomers.get(db, 'org_1')).toBeDefined()
     await db.close()
   })
 
+  test('behavior: deletes an org with only failed or non-mainnet sponsorships', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const failed = await SponsoredTransactions.upsert(db, {
+      apiKeyId: 'key_1',
+      billable: true,
+      chainId: Viem.chainId.mainnet,
+      environment: 'production',
+      orgId: 'org_1',
+      projectId: 'prj_1',
+      signPayload: `0x${'bb'.repeat(32)}`,
+      transaction: `0x76${'cc'.repeat(16)}`,
+      transactionHash: `0x${'aa'.repeat(32)}`,
+    })
+    await SponsoredTransactions.fail(db, failed.id, '2026-01-01T00:00:00.000Z')
+    const testnet = await SponsoredTransactions.upsert(db, {
+      apiKeyId: 'key_1',
+      billable: true,
+      chainId: Viem.chainId.testnet,
+      environment: 'production',
+      orgId: 'org_1',
+      projectId: 'prj_1',
+      signPayload: `0x${'dd'.repeat(32)}`,
+      transaction: `0x76${'ee'.repeat(16)}`,
+      transactionHash: `0x${'ff'.repeat(32)}`,
+    })
+    await SponsoredTransactions.finalize(db, testnet.id, {
+      feeAmount: '100',
+      finalizedAt: '2026-01-01T00:00:00.000Z',
+    })
+
+    expect(await Organizations.hasUnreportedSponsorships(db, 'org_1')).toBe(false)
+    expect(await Organizations.deleteOrganization(db, 'org_1')).toBe(true)
+    await db.close()
+  })
+
+  test('behavior: preserves an org with a recoverable failed fill intent', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const failed = await SponsoredTransactions.upsert(db, {
+      apiKeyId: 'key_1',
+      billable: true,
+      chainId: Viem.chainId.mainnet,
+      environment: 'production',
+      orgId: 'org_1',
+      projectId: 'prj_1',
+      signPayload: `0x${'bb'.repeat(32)}`,
+      transaction: `0x76${'cc'.repeat(16)}`,
+    })
+    await SponsoredTransactions.fail(db, failed.id, new Date().toISOString())
+
+    expect(await Organizations.hasUnreportedSponsorships(db, 'org_1')).toBe(true)
+    await expect(Organizations.deleteOrganization(db, 'org_1')).rejects.toThrow(
+      Organizations.UnreportedSponsorshipsError,
+    )
+    expect(await Organizations.get(db, 'org_1')).toBeDefined()
+    await db.close()
+  })
+
+  test('behavior: deletes an org with only expired failed fill intents', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    const failed = await SponsoredTransactions.upsert(db, {
+      apiKeyId: 'key_1',
+      billable: true,
+      chainId: Viem.chainId.mainnet,
+      environment: 'production',
+      orgId: 'org_1',
+      projectId: 'prj_1',
+      signPayload: `0x${'bb'.repeat(32)}`,
+      transaction: `0x76${'cc'.repeat(16)}`,
+    })
+    await SponsoredTransactions.fail(
+      db,
+      failed.id,
+      new Date(Date.now() - SponsoredTransactions.failedIntentRecoveryTtlMs - 1).toISOString(),
+    )
+
+    expect(await Organizations.hasUnreportedSponsorships(db, 'org_1')).toBe(false)
+    expect(await Organizations.deleteOrganization(db, 'org_1')).toBe(true)
+    await db.close()
+  })
+
+  test('behavior: deletes enabled billing sources', async () => {
+    const db = create()
+    await db.migrate()
+    await Organizations.create(db, { id: 'org_1', name: 'One' })
+    await Organizations.create(db, { id: 'org_2', name: 'Two' })
+    await EnabledBillingSources.add(db, {
+      createdBy: 'admin@tempo.xyz',
+      orgId: 'org_1',
+      source: 'stripe',
+    })
+    await EnabledBillingSources.add(db, {
+      createdBy: 'admin@tempo.xyz',
+      orgId: 'org_1',
+      source: 'tempo',
+    })
+    await EnabledBillingSources.add(db, {
+      createdBy: 'admin@tempo.xyz',
+      orgId: 'org_2',
+      source: 'stripe',
+    })
+
+    expect(await Organizations.deleteOrganization(db, 'org_1')).toBe(true)
+
+    expect(await EnabledBillingSources.listByOrg(db, 'org_1')).toEqual([])
+    expect((await EnabledBillingSources.listByOrg(db, 'org_2')).map((record) => record.source))
+      .toMatchInlineSnapshot(`
+        [
+          "stripe",
+        ]
+      `)
+    await db.close()
+  })
+
   test('behavior: deletes api-key-owned webhook subscriptions', async () => {
     const db = create()
     await db.migrate()