tapimo 0.5.3 → 0.7.0

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

@@ -31,6 +31,8 @@ export function create(db: Db.Db, input: create.Input): Promise<Record> {
       createdAt: now,
       email: input.email.toLowerCase(),
       expiresAt: input.expiresAt,
+      // Keep the legacy column inert until it can be removed safely.
+      grantsEarlyAccess: false,
       id: Id.generate('inv'),
       invitedBy: input.invitedBy,
       orgId: input.orgId,
@@ -45,6 +47,7 @@ export function create(db: Db.Db, input: create.Input): Promise<Record> {
         .doUpdateSet({
           createdAt: now,
           expiresAt: input.expiresAt,
+          grantsEarlyAccess: false,
           invitedBy: input.invitedBy,
           role: input.role,
         }),

package/src/db/tables/inviteLinks.ts

@@ -1,11 +1,18 @@
-import type { Selectable } from 'kysely'
+import type { JSONColumnType, Selectable } from 'kysely'
 
 import * as Id from '../../internal/Id.js'
 import type * as Db from '../Db.js'
 import type * as db_Schema from '../Schema.js'
 
 /** Columns of the `invite_links` table. */
-export type Table = db_Schema.InviteLink
+export type Table = Omit<db_Schema.InviteLink, 'allowedEmailDomains'> & {
+  /** Lowercase email domains allowed to redeem, or null for unrestricted. */
+  allowedEmailDomains: JSONColumnType<
+    db_Schema.InviteLink['allowedEmailDomains'],
+    string | null,
+    string | null
+  >
+}
 /** Columns of the `invite_link_redemptions` table. */
 export type RedemptionTable = db_Schema.InviteLinkRedemption
 /** A stored invite link. */
@@ -28,6 +35,7 @@ export function status(record: Record, now = new Date().toISOString()): Status {
 export function create(
   db: Db.Db,
   input: {
+    allowedEmailDomains: readonly string[] | null
     createdBy: string
     expiresAt: string | null
     maxUses: number | null
@@ -40,6 +48,8 @@ export function create(
   return db.kysely
     .insertInto('invite_links')
     .values({
+      allowedEmailDomains:
+        input.allowedEmailDomains === null ? null : JSON.stringify(input.allowedEmailDomains),
       createdAt: now,
       createdBy: input.createdBy,
       deletedAt: null,
@@ -155,6 +165,10 @@ export function accept(
       .executeTakeFirst()
     if (existing) return { consumed: false, link }
     if (status(link, now) !== 'active') return undefined
+    const normalizedEmail = email.trim().toLowerCase()
+    const domain = normalizedEmail.slice(normalizedEmail.lastIndexOf('@') + 1)
+    if (link.allowedEmailDomains !== null && !link.allowedEmailDomains.includes(domain))
+      throw new EmailDomainForbiddenError()
     const inserted = await trx
       .insertInto('memberships')
       .values({ createdAt: now, orgId: link.orgId, role: 'member', updatedAt: now, userId })
@@ -171,7 +185,7 @@ export function accept(
       .insertInto('invite_link_redemptions')
       .values({
         createdAt: now,
-        email: email.toLowerCase(),
+        email: normalizedEmail,
         id: Id.generate('ilr'),
         inviteLinkId: link.id,
         inviteLinkName: link.name,
@@ -185,3 +199,8 @@ export function accept(
     }
   })
 }
+
+/** The verified email domain is not allowed by the invite link. */
+export class EmailDomainForbiddenError extends Error {
+  override name = 'InviteLinks.EmailDomainForbiddenError'
+}

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

@@ -3,6 +3,8 @@ import { nanoid } from 'nanoid'
 import * as Runtime from '../../../test/runtime.js'
 import * as Webhooks from '../../internal/Webhooks.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 +62,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 +199,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,
@@ -153,10 +220,46 @@ describe('deleteOrganization', () => {
       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 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()

package/src/db/tables/organizations.ts

@@ -3,6 +3,7 @@ import { sql, type Selectable } from 'kysely'
 import * as Id from '../../internal/Id.js'
 import type * as Db from '../Db.js'
 import type * as db_Schema from '../Schema.js'
+import type * as EnabledBillingSources from './enabledBillingSources.js'
 import type * as Memberships from './memberships.js'
 
 /** Columns of the `organizations` table, derived from `Schema.Organization`. */
@@ -50,8 +51,8 @@ export declare namespace create {
 }
 
 /**
- * Inserts an organization owned by `userId` — the org row plus its `owner`
- * membership, atomically.
+ * Inserts an organization, its owner membership, and initial billing sources
+ * atomically.
  *
  * @param db - The database.
  * @param input - The organization to insert.
@@ -82,6 +83,18 @@ export function createOwned(db: Db.Db, input: createOwned.Input): Promise<Record
         userId: input.userId,
       })
       .execute()
+    if (input.enabledBillingSources?.length)
+      await trx
+        .insertInto('enabled_billing_sources')
+        .values(
+          input.enabledBillingSources.map((source) => ({
+            createdAt: now,
+            createdBy: input.userId,
+            orgId: record.id,
+            source,
+          })),
+        )
+        .execute()
     return record
   })
 }
@@ -89,6 +102,8 @@ export function createOwned(db: Db.Db, input: createOwned.Input): Promise<Record
 export declare namespace createOwned {
   /** Fields accepted when inserting a user-owned organization. */
   type Input = {
+    /** Billing sources enabled when the organization is created. */
+    enabledBillingSources?: readonly EnabledBillingSources.Source[] | undefined
     /** Human-readable organization name. */
     name: string
     /** Owning user id (`usr_…`), granted the `owner` membership. */
@@ -121,6 +136,7 @@ export function deleteOrganization(db: Db.Db, id: string): Promise<boolean> {
       .where('ownerId', '=', id)
       .execute()
     await trx.deleteFrom('billing_settings').where('orgId', '=', id).execute()
+    await trx.deleteFrom('enabled_billing_sources').where('orgId', '=', id).execute()
     await trx.deleteFrom('invitations').where('orgId', '=', id).execute()
     await trx.deleteFrom('invite_link_redemptions').where('orgId', '=', id).execute()
     await trx.deleteFrom('invite_links').where('orgId', '=', id).execute()