tapimo 0.14.0 → 0.15.0

package/src/admin/apps/organizations.test.ts

@@ -1,19 +1,27 @@
 import type * as Analytics from '../../analytics/Analytics.js'
 import * as ApiKeys from '../../ApiKeys.js'
+import * as InvitationsApp from '../../apps/management/routes/invitations.js'
 import * as BillingSettings from '../../db/tables/billingSettings.js'
 import * as EnabledBillingSources from '../../db/tables/enabledBillingSources.js'
 import * as Memberships from '../../db/tables/memberships.js'
 import * as Organizations from '../../db/tables/organizations.js'
 import * as Projects from '../../db/tables/projects.js'
+import * as RoutesSubsidies from '../../db/tables/routesSubsidies.js'
 import * as SponsoredTransactions from '../../db/tables/sponsoredTransactions.js'
 import * as StripeCustomers from '../../db/tables/stripeCustomers.js'
 import * as Users from '../../db/tables/users.js'
 import * as WebhookDeliveries from '../../db/tables/webhookDeliveries.js'
 import * as WebhookSubscriptions from '../../db/tables/webhookSubscriptions.js'
+import type * as Email from '../../internal/Email.js'
+import * as RateLimit from '../../internal/RateLimit.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 TestAdmin from '../../../test/Admin.js'
 import * as TestApp from '../../../test/App.js'
+import * as TestRoutes from '../../../test/Routes.js'
 import * as AdminOrganizations from './organizations.js'
 
 describe('GET /organizations', () => {
@@ -181,7 +189,6 @@ describe('GET /organizations/:orgId', () => {
       settings: { spendLimit: '1000', txFeeLimit: null },
       source: null,
     })
-    expect(body.sponsorshipSubsidy).toEqual({ durationDays: null, projectSpendLimit: null })
   })
 
   test('returns empty counts and billing for a memberless organization', async () => {
@@ -216,51 +223,198 @@ describe('GET /organizations/:orgId', () => {
   })
 })
 
-describe('PUT /organizations/:orgId/sponsorship', () => {
-  test('enables and disables a 90-day per-project policy', async () => {
+describe('GET /organizations/:orgId/subsidies', () => {
+  test('returns Routes and sponsorship policies', async () => {
+    const { client, db } = TestAdmin.setup()
+    const organization = await Organizations.create(db, { name: 'Subsidies' })
+    await RoutesSubsidies.upsertOrganization(db, {
+      frequency: 'tx',
+      maxAmount: '5',
+      orgId: organization.id,
+    })
+    await Organizations.setSponsorshipSubsidy(db, organization.id, {
+      attributionSpendLimit: '1000',
+      durationDays: 90,
+    })
+    const addressSnapshot = TestRoutes.depositAddressSnapshot({
+      address: 'source-admin-usage',
+      subsidize: true,
+    })
+    const address = await DepositAddress.create(db, {
+      deliveryStrategy: 'provider',
+      environment: 'production',
+      orgId: organization.id,
+      providerOutputToken: addressSnapshot.destinationToken,
+      snapshot: addressSnapshot,
+    })
+    const amount = { baseUnits: '250000', currency: 'USD', decimals: 6, formatted: '0.25' }
+    const deposit = await Deposit.create(db, {
+      providerRequestId: 'request_admin_usage',
+      settlementTransaction: `0x${'aa'.repeat(32)}`,
+      settlementTransactionHash: `0x${'bb'.repeat(32)}`,
+      snapshot: TestRoutes.depositSnapshot(address.id),
+      sourceTransactionHash: `0x${'cc'.repeat(32)}`,
+      subsidyAmount: amount,
+    })
+    await Deposit.transition(db, {
+      expectedVersion: deposit.version,
+      id: deposit.id,
+      status: 'completed',
+      subsidyAmount: amount,
+    })
+
+    const response = await client.organizations[':orgId'].subsidies.$get({
+      param: { orgId: organization.id },
+    })
+
+    expect(
+      await TestApp.json(response, AdminOrganizations.schema.getOrganizationSubsidies.Response),
+    ).toEqual({
+      routes: { frequency: 'tx', maxAmount: '5' },
+      routesUsage: {
+        amount: '0.25',
+        count: 1,
+        from: expect.any(String),
+        to: expect.any(String),
+      },
+      sponsorship: { attributionSpendLimit: '1000', durationDays: 90 },
+    })
+  })
+
+  test('returns disabled policies and rejects an unknown organization', async () => {
+    const { client, db } = TestAdmin.setup()
+    const organization = await Organizations.create(db, { name: 'Disabled subsidies' })
+
+    const response = await client.organizations[':orgId'].subsidies.$get({
+      param: { orgId: organization.id },
+    })
+    expect(
+      await TestApp.json(response, AdminOrganizations.schema.getOrganizationSubsidies.Response),
+    ).toEqual({
+      routes: null,
+      routesUsage: {
+        amount: '0',
+        count: 0,
+        from: expect.any(String),
+        to: expect.any(String),
+      },
+      sponsorship: { attributionSpendLimit: null, durationDays: null },
+    })
+
+    const missing = await client.organizations[':orgId'].subsidies.$get({
+      param: { orgId: 'org_missing' },
+    })
+    expect(missing.status).toBe(404)
+  })
+})
+
+describe('PUT /organizations/:orgId/subsidies/routes', () => {
+  test('enables and disables a maximum subsidy amount', async () => {
+    const { client, db } = TestAdmin.setup()
+    const organization = await Organizations.create(db, { name: 'Routes' })
+
+    const enabled = await client.organizations[':orgId'].subsidies.routes.$put({
+      json: { enabled: true, frequency: 'tx', maxAmount: '25.50' },
+      param: { orgId: organization.id },
+    })
+    expect(
+      await TestApp.json(enabled, AdminOrganizations.schema.setOrganizationRoutesSubsidy.Response),
+    ).toEqual({ frequency: 'tx', maxAmount: '25.50' })
+    expect(await RoutesSubsidies.getOrganization(db, organization.id)).toMatchObject({
+      enabled: true,
+      frequency: 'tx',
+      maxAmount: '25.50',
+    })
+
+    const disabled = await client.organizations[':orgId'].subsidies.routes.$put({
+      json: { enabled: false },
+      param: { orgId: organization.id },
+    })
+    expect(
+      await TestApp.json(disabled, AdminOrganizations.schema.setOrganizationRoutesSubsidy.Response),
+    ).toBeNull()
+    expect(await RoutesSubsidies.getOrganization(db, organization.id)).toBeUndefined()
+  })
+
+  test('rejects invalid limits and unknown organizations', async () => {
+    const { app, client } = TestAdmin.setup()
+    for (const maxAmount of ['0', '0.000000', '-1', '1.0000001']) {
+      const invalid = await app.request('/organizations/org_example/subsidies/routes', {
+        body: JSON.stringify({ enabled: true, frequency: 'tx', maxAmount }),
+        headers: { 'content-type': 'application/json' },
+        method: 'PUT',
+      })
+      expect(invalid.status).toBe(400)
+    }
+    const invalidFrequency = await app.request('/organizations/org_example/subsidies/routes', {
+      body: JSON.stringify({ enabled: true, frequency: 'day', maxAmount: '5' }),
+      headers: { 'content-type': 'application/json' },
+      method: 'PUT',
+    })
+    expect(invalidFrequency.status).toBe(400)
+
+    const missing = await client.organizations[':orgId'].subsidies.routes.$put({
+      json: { enabled: true, frequency: 'tx', maxAmount: '5' },
+      param: { orgId: 'org_missing' },
+    })
+    expect(missing.status).toBe(404)
+  })
+})
+
+describe('PUT /organizations/:orgId/subsidies/sponsorship', () => {
+  test('enables and disables a 90-day per-attribution policy', async () => {
     const { client, db } = TestAdmin.setup()
     const organization = await Organizations.create(db, { name: 'Privy' })
 
-    const enabled = await client.organizations[':orgId'].sponsorship.$put({
-      json: { enabled: true, projectSpendLimit: '1000' },
+    const enabled = await client.organizations[':orgId'].subsidies.sponsorship.$put({
+      json: { attributionSpendLimit: '1000', enabled: true },
       param: { orgId: organization.id },
     })
     expect(
-      await TestApp.json(enabled, AdminOrganizations.schema.organizationSponsorship.SetResponse),
-    ).toEqual({ durationDays: 90, projectSpendLimit: '1000' })
+      await TestApp.json(
+        enabled,
+        AdminOrganizations.schema.setOrganizationSponsorshipSubsidy.Response,
+      ),
+    ).toEqual({ attributionSpendLimit: '1000', durationDays: 90 })
 
-    const disabled = await client.organizations[':orgId'].sponsorship.$put({
+    const disabled = await client.organizations[':orgId'].subsidies.sponsorship.$put({
       json: { enabled: false },
       param: { orgId: organization.id },
     })
     expect(
-      await TestApp.json(disabled, AdminOrganizations.schema.organizationSponsorship.SetResponse),
-    ).toEqual({ durationDays: null, projectSpendLimit: null })
+      await TestApp.json(
+        disabled,
+        AdminOrganizations.schema.setOrganizationSponsorshipSubsidy.Response,
+      ),
+    ).toEqual({ attributionSpendLimit: null, durationDays: null })
   })
 
   test('enables an uncapped policy', async () => {
     const { client, db } = TestAdmin.setup()
     const organization = await Organizations.create(db, { name: 'Privy' })
-    const response = await client.organizations[':orgId'].sponsorship.$put({
+    const response = await client.organizations[':orgId'].subsidies.sponsorship.$put({
       json: { enabled: true },
       param: { orgId: organization.id },
     })
     expect(
-      await TestApp.json(response, AdminOrganizations.schema.organizationSponsorship.SetResponse),
-    ).toEqual({ durationDays: 90, projectSpendLimit: null })
+      await TestApp.json(
+        response,
+        AdminOrganizations.schema.setOrganizationSponsorshipSubsidy.Response,
+      ),
+    ).toEqual({ attributionSpendLimit: null, durationDays: 90 })
   })
 
   test('rejects invalid limits and unknown organizations', async () => {
     const { app, client } = TestAdmin.setup()
-    const invalid = await app.request('/organizations/org_example/sponsorship', {
-      body: JSON.stringify({ enabled: true, projectSpendLimit: '-1' }),
+    const invalid = await app.request('/organizations/org_example/subsidies/sponsorship', {
+      body: JSON.stringify({ attributionSpendLimit: '-1', enabled: true }),
       headers: { 'content-type': 'application/json' },
       method: 'PUT',
     })
     expect(invalid.status).toBe(400)
 
-    const missing = await client.organizations[':orgId'].sponsorship.$put({
-      json: { enabled: true, projectSpendLimit: '1000' },
+    const missing = await client.organizations[':orgId'].subsidies.sponsorship.$put({
+      json: { attributionSpendLimit: '1000', enabled: true },
       param: { orgId: 'org_missing' },
     })
     expect(missing.status).toBe(404)
@@ -374,6 +528,78 @@ describe('GET /organizations/:orgId/members', () => {
   })
 })
 
+describe('POST /organizations/:orgId/invitations', () => {
+  test('creates and emails the standard organization invitation', async () => {
+    const db = TestApp.database()
+    const sent: Email.Message[] = []
+    const admin = TestAdmin.setup({
+      db,
+      email: {
+        from: 'noreply@tempo.test',
+        send: (message) => {
+          sent.push(message)
+          return Promise.resolve()
+        },
+      },
+    })
+    const organization = await Organizations.create(db, { name: 'Members' })
+
+    const response = await admin.client.organizations[':orgId'].invitations.$post({
+      json: { email: 'new.member@example.com', role: 'admin' },
+      param: { orgId: organization.id },
+    })
+    const invitation = await TestApp.json(response, InvitationsApp.schema.Invitation)
+
+    expect(response.status).toBe(200)
+    expect(invitation).toMatchObject({
+      email: 'new.member@example.com',
+      invitedBy: 'super_admin',
+      orgId: organization.id,
+      role: 'admin',
+    })
+    expect(sent).toMatchObject([
+      {
+        subject: `You've been invited to Members on the Tempo Developer Platform`,
+        to: 'new.member@example.com',
+      },
+    ])
+  })
+
+  test('caps admin invitation email dispatch with the shared global quota', async () => {
+    const now = () => new Date('2026-01-01T00:00:00.000Z')
+    const store = Store.memory()
+    const limiter = RateLimit.memory({ now, store })
+    for (let index = 0; index < 100; index++)
+      await limiter.consume({
+        key: 'invitation-email:global',
+        limit: { limit: 100, period: 'minute' },
+      })
+
+    const sent: Email.Message[] = []
+    const admin = TestAdmin.setup({
+      email: {
+        from: 'noreply@tempo.test',
+        send: (message) => {
+          sent.push(message)
+          return Promise.resolve()
+        },
+      },
+      rateLimit: { now, store },
+    })
+    const organization = await Organizations.create(admin.db, { name: 'Members' })
+    const response = await admin.client.organizations[':orgId'].invitations.$post({
+      json: { email: 'new.member@example.com', role: 'admin' },
+      param: { orgId: organization.id },
+    })
+
+    expect({
+      scope: response.headers.get('rateLimit-scope'),
+      sent: sent.length,
+      status: response.status,
+    }).toEqual({ scope: 'invitation-email-global', sent: 0, status: 429 })
+  })
+})
+
 describe('GET /organizations/:orgId/projects', () => {
   test('returns a bounded cursor page without duplicates', async () => {
     const { client, db } = TestAdmin.setup()
@@ -457,6 +683,69 @@ describe('GET /organizations/:orgId/usage', () => {
 })
 
 describe('GET /organizations/:orgId/sponsorship', () => {
+  test('includes configured Zone charges in each environment', async () => {
+    const { client, db } = TestAdmin.setup({
+      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 organization = await Organizations.create(db, { name: 'Zone sponsorship' })
+    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, {
+        apiKeyId: 'key_1',
+        billable: true,
+        environment: 'production',
+        feeMax: '1000000',
+        orgId: organization.id,
+        projectId: 'prj_1',
+        signPayload: `0x${String(index + 10).repeat(32)}`,
+        transaction: `0x${'22'.repeat(32)}`,
+        ...input,
+      })
+      if (feeAmount)
+        await SponsoredTransactions.finalize(db, record.id, {
+          feeAmount,
+          finalizedAt: new Date().toISOString(),
+        })
+    }
+
+    const response = await client.organizations[':orgId'].sponsorship.$get({
+      param: { orgId: organization.id },
+    })
+    const body = await TestApp.json(
+      response,
+      AdminOrganizations.schema.organizationSponsorship.GetResponse,
+    )
+    expect(response.status).toBe(200)
+    expect(body.production.committedSpend).toMatchInlineSnapshot(`"0.55"`)
+    expect(body.sandbox.committedSpend).toMatchInlineSnapshot(`"0.5"`)
+  })
+
   test('returns current-period committed spend split by environment', async () => {
     const { client, db } = TestAdmin.setup()
     const organization = await Organizations.create(db, { name: 'Sponsorship' })