tapimo 0.4.0 → 0.4.3

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

@@ -0,0 +1,455 @@
+import type * as Analytics from '../../analytics/Analytics.js'
+import * as ApiKeys from '../../ApiKeys.js'
+import * as BillingSettings from '../../db/tables/billingSettings.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 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 * as Viem from '../../internal/Viem.js'
+
+import * as TestAdmin from '../../../test/Admin.js'
+import * as TestApp from '../../../test/App.js'
+import * as AdminOrganizations from './organizations.js'
+
+describe('GET /organizations', () => {
+  test('lists summaries newest first with member and project counts', async () => {
+    const { client, db } = TestAdmin.setup()
+    const user = await Users.upsertByAddress(db, {
+      address: `0x${'11'.repeat(20)}`,
+    })
+    await Users.setEmail(db, user.id, 'owner@acme.example')
+    const organization = await Organizations.createOwned(db, { name: 'Acme', userId: user.id })
+    await Projects.create(db, { name: 'Checkout', orgId: organization.id })
+    await Projects.create(db, { name: 'Treasury', orgId: organization.id })
+
+    const response = await client.organizations.$get({ query: {} })
+    const body = await TestApp.json(response, AdminOrganizations.schema.listOrganizations.Response)
+
+    expect(response.status).toBe(200)
+    expect(body.nextCursor).toBeNull()
+    expect(body.data).toHaveLength(1)
+    expect(body.data[0]).toMatchObject({
+      id: organization.id,
+      memberCount: 1,
+      name: 'Acme',
+      projectCount: 2,
+      userId: user.id,
+    })
+  })
+
+  test('searches organization and member identity fields case-insensitively', async () => {
+    const { client, db } = TestAdmin.setup()
+    const user = await Users.upsertByAddress(db, {
+      address: `0x${'22'.repeat(20)}`,
+    })
+    await Users.setEmail(db, user.id, 'Owner@Example.com')
+    const organization = await Organizations.createOwned(db, {
+      name: 'Merchant Operations',
+      userId: user.id,
+    })
+    await Organizations.create(db, { id: 'org_unrelated', name: 'Unrelated' })
+
+    for (const query of ['merchant', organization.id, user.id, 'owner@']) {
+      const response = await client.organizations.$get({ query: { query } })
+      const body = await TestApp.json(
+        response,
+        AdminOrganizations.schema.listOrganizations.Response,
+      )
+      expect(body.data.map(({ id }) => id)).toEqual([organization.id])
+    }
+  })
+
+  test('treats SQL wildcard characters as literal search text', async () => {
+    const { client, db } = TestAdmin.setup()
+    const organization = await Organizations.create(db, { name: 'A_B Merchant' })
+    await Organizations.create(db, { name: 'AcB Merchant' })
+
+    const response = await client.organizations.$get({ query: { query: 'a_b' } })
+    const body = await TestApp.json(response, AdminOrganizations.schema.listOrganizations.Response)
+
+    expect(body.data.map(({ id }) => id)).toEqual([organization.id])
+  })
+
+  test('orders distinct creation times newest first', async () => {
+    const { client, db } = TestAdmin.setup()
+    vi.useFakeTimers()
+    try {
+      vi.setSystemTime(new Date('2026-01-01T00:00:00.000Z'))
+      const older = await Organizations.create(db, { name: 'Older' })
+      vi.setSystemTime(new Date('2026-01-02T00:00:00.000Z'))
+      const newer = await Organizations.create(db, { name: 'Newer' })
+
+      const response = await client.organizations.$get({ query: {} })
+      const body = await TestApp.json(
+        response,
+        AdminOrganizations.schema.listOrganizations.Response,
+      )
+      expect(body.data.map(({ id }) => id)).toEqual([newer.id, older.id])
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  test('rejects broad queries shorter than three characters', async () => {
+    const { client } = TestAdmin.setup()
+    const response = await client.organizations.$get({ query: { query: 'a' } })
+    expect(response.status).toBe(400)
+  })
+
+  test('walks a stable cursor without duplicate organizations', async () => {
+    const { client, db } = TestAdmin.setup()
+    for (const id of ['org_f', 'org_e', 'org_d', 'org_c', 'org_b', 'org_a'])
+      await Organizations.create(db, { id, name: id })
+
+    const firstResponse = await client.organizations.$get({ query: { limit: '5' } })
+    const first = await TestApp.json(
+      firstResponse,
+      AdminOrganizations.schema.listOrganizations.Response,
+    )
+    expect(first.data).toHaveLength(5)
+    expect(first.nextCursor).not.toBeNull()
+
+    const secondResponse = await client.organizations.$get({
+      query: { cursor: first.nextCursor!, limit: '5' },
+    })
+    const second = await TestApp.json(
+      secondResponse,
+      AdminOrganizations.schema.listOrganizations.Response,
+    )
+    expect(second.data).toHaveLength(1)
+    expect(second.nextCursor).toBeNull()
+    expect(new Set([...first.data, ...second.data].map(({ id }) => id)).size).toBe(6)
+  })
+})
+
+describe('GET /organizations/:orgId', () => {
+  test('returns counts and billing state split by environment', async () => {
+    const { client, db } = TestAdmin.setup()
+    const user = await Users.upsertByAddress(db, {
+      address: `0x${'33'.repeat(20)}`,
+    })
+    await Users.setEmail(db, user.id, 'owner@tempo.xyz')
+    const organization = await Organizations.createOwned(db, { name: 'Tempo', userId: user.id })
+    await Projects.create(db, { name: 'API', orgId: organization.id })
+    await BillingSettings.upsert(db, {
+      environment: 'production',
+      orgId: organization.id,
+      spendLimit: '250',
+      txFeeLimit: '0.50',
+    })
+    await BillingSettings.upsert(db, {
+      environment: 'sandbox',
+      orgId: organization.id,
+      spendLimit: '1000',
+    })
+    await StripeCustomers.create(db, {
+      environment: 'production',
+      orgId: organization.id,
+      stripeCustomerId: 'cus_admin_lookup',
+    })
+    await StripeCustomers.setStatus(db, organization.id, 'active', 'production')
+
+    const response = await client.organizations[':orgId'].$get({
+      param: { orgId: organization.id },
+    })
+    const body = await TestApp.json(response, AdminOrganizations.schema.getOrganization.Response)
+
+    expect(response.status).toBe(200)
+    expect(body.memberCount).toBe(1)
+    expect(body.projectCount).toBe(1)
+    expect(body.billing.production).toMatchObject({
+      settings: { spendLimit: '250', txFeeLimit: '0.50' },
+      source: { status: 'active', stripeCustomerId: 'cus_admin_lookup' },
+    })
+    expect(body.billing.sandbox).toMatchObject({
+      settings: { spendLimit: '1000', txFeeLimit: null },
+      source: null,
+    })
+  })
+
+  test('returns empty counts and billing for a memberless organization', async () => {
+    const { client, db } = TestAdmin.setup()
+    const organization = await Organizations.create(db, { name: 'Support-created' })
+
+    const response = await client.organizations[':orgId'].$get({
+      param: { orgId: organization.id },
+    })
+    const body = await TestApp.json(response, AdminOrganizations.schema.getOrganization.Response)
+
+    expect(body).toMatchObject({
+      billing: {
+        production: { settings: null, source: null },
+        sandbox: { settings: null, source: null },
+      },
+      memberCount: 0,
+      projectCount: 0,
+    })
+  })
+
+  test('returns 404 for an unknown organization', async () => {
+    const { client } = TestAdmin.setup()
+    const response = await client.organizations[':orgId'].$get({
+      param: { orgId: 'org_missing' },
+    })
+    const body = (await response.json()) as { error: { code: string } }
+
+    expect(response.status).toBe(404)
+    expect(body.error.code).toBe('not_found')
+  })
+})
+
+describe('GET /organizations/:orgId/members', () => {
+  test('returns a bounded cursor page without duplicates', async () => {
+    const { client, db } = TestAdmin.setup()
+    const organization = await Organizations.create(db, { name: 'Members' })
+    for (let index = 0; index < 6; index++) {
+      const user = await Users.upsertByAddress(db, {
+        address: `0x${String(index + 1).padStart(40, '0')}`,
+      })
+      await Users.setEmail(db, user.id, `member-${index}@example.com`)
+      await Memberships.create(db, { orgId: organization.id, role: 'member', userId: user.id })
+    }
+
+    const firstResponse = await client.organizations[':orgId'].members.$get({
+      param: { orgId: organization.id },
+      query: { limit: '5' },
+    })
+    const first = await TestApp.json(
+      firstResponse,
+      AdminOrganizations.schema.listOrganizationMembers.Response,
+    )
+    const secondResponse = await client.organizations[':orgId'].members.$get({
+      param: { orgId: organization.id },
+      query: { cursor: first.nextCursor!, limit: '5' },
+    })
+    const second = await TestApp.json(
+      secondResponse,
+      AdminOrganizations.schema.listOrganizationMembers.Response,
+    )
+
+    expect(first.data).toHaveLength(5)
+    expect(second.data).toHaveLength(1)
+    expect(new Set([...first.data, ...second.data].map(({ userId }) => userId)).size).toBe(6)
+  })
+})
+
+describe('GET /organizations/:orgId/projects', () => {
+  test('returns a bounded cursor page without duplicates', async () => {
+    const { client, db } = TestAdmin.setup()
+    const organization = await Organizations.create(db, { name: 'Projects' })
+    for (let index = 0; index < 6; index++)
+      await Projects.create(db, { name: `Project ${index}`, orgId: organization.id })
+
+    const firstResponse = await client.organizations[':orgId'].projects.$get({
+      param: { orgId: organization.id },
+      query: { limit: '5' },
+    })
+    const first = await TestApp.json(
+      firstResponse,
+      AdminOrganizations.schema.listOrganizationProjects.Response,
+    )
+    const secondResponse = await client.organizations[':orgId'].projects.$get({
+      param: { orgId: organization.id },
+      query: { cursor: first.nextCursor!, limit: '5' },
+    })
+    const second = await TestApp.json(
+      secondResponse,
+      AdminOrganizations.schema.listOrganizationProjects.Response,
+    )
+
+    expect(first.data).toHaveLength(5)
+    expect(second.data).toHaveLength(1)
+    expect(new Set([...first.data, ...second.data].map(({ id }) => id)).size).toBe(6)
+  })
+})
+
+describe('GET /organizations/:orgId/api-keys', () => {
+  test('returns active key environment, scopes, and creator without tokens', async () => {
+    const { client, db, store } = TestAdmin.setup()
+    const organization = await Organizations.create(db, { name: 'Keys' })
+    await ApiKeys.mint(store, {
+      createdBy: 'ops@tempo.xyz',
+      environment: 'sandbox',
+      orgId: organization.id,
+      scopes: ['data:read'],
+    })
+
+    const response = await client.organizations[':orgId']['api-keys'].$get({
+      param: { orgId: organization.id },
+    })
+    const body = await TestApp.json(
+      response,
+      AdminOrganizations.schema.listOrganizationApiKeys.Response,
+    )
+
+    expect(body.data[0]).toMatchObject({
+      createdBy: 'ops@tempo.xyz',
+      environment: 'sandbox',
+      scopes: ['data:read'],
+    })
+    expect(body.data[0]).not.toHaveProperty('status')
+    expect(body.data[0]).not.toHaveProperty('token')
+  })
+})
+
+describe('GET /organizations/:orgId/usage', () => {
+  test('returns recent totals and error breakdowns from analytics', async () => {
+    const { client, db } = TestAdmin.setup({ analytics: usageAnalytics })
+    const organization = await Organizations.create(db, { name: 'Usage' })
+    const response = await client.organizations[':orgId'].usage.$get({
+      param: { orgId: organization.id },
+      query: { period: '7d' },
+    })
+    const body = await TestApp.json(
+      response,
+      AdminOrganizations.schema.getOrganizationUsage.Response,
+    )
+
+    expect(body).toMatchObject({
+      byError: [{ code: 'upstream_error', requests: 2 }],
+      byRoute: [{ averageDurationMs: 12.5, errors: 2, requests: 20, route: '/v1/tokens' }],
+      byStatus: [{ requests: 2, status: 500 }],
+      period: '7d',
+      totals: { averageDurationMs: 10.5, errors: 2, requests: 25 },
+    })
+  })
+})
+
+describe('GET /organizations/:orgId/sponsorship', () => {
+  test('returns current-period committed spend split by environment', async () => {
+    const { client, db } = TestAdmin.setup()
+    const organization = await Organizations.create(db, { name: 'Sponsorship' })
+    await SponsoredTransactions.upsert(db, {
+      apiKeyId: 'key_1',
+      billable: true,
+      chainId: Viem.chainId.mainnet,
+      environment: 'production',
+      feeMax: '1250000',
+      orgId: organization.id,
+      projectId: 'prj_1',
+      signPayload: `0x${'11'.repeat(32)}`,
+      transaction: `0x${'22'.repeat(32)}`,
+    })
+
+    const response = await client.organizations[':orgId'].sponsorship.$get({
+      param: { orgId: organization.id },
+    })
+    const body = await TestApp.json(
+      response,
+      AdminOrganizations.schema.getOrganizationSponsorship.Response,
+    )
+
+    expect(body.production).toMatchObject({
+      committedSpend: '1.25',
+      currency: 'usd',
+      period: 'month',
+    })
+    expect(body.sandbox).toMatchObject({
+      committedSpend: '0',
+      currency: 'usd',
+      period: 'month',
+    })
+  })
+})
+
+describe('GET /organizations/:orgId/webhooks', () => {
+  test('redacts destinations and returns recent delivery failures', async () => {
+    const { client, db } = TestAdmin.setup()
+    const organization = await Organizations.create(db, { name: 'Webhooks' })
+    const createdAt = new Date().toISOString()
+    await WebhookSubscriptions.insert(db, {
+      chainId: 4217,
+      createdAt,
+      destination: { type: 'url', url: 'https://hooks.example.com/private/path' },
+      eventType: 'token:transfer',
+      failureCount: 1,
+      filters: {},
+      id: 'wh_admin_visibility',
+      owner: { orgId: organization.id, type: 'api_key' },
+      secret: 'secret',
+      status: 'active',
+      updatedAt: createdAt,
+    })
+    for (let index = 0; index < 26; index++)
+      await WebhookDeliveries.insert(
+        db,
+        {
+          attempt: 1,
+          createdAt,
+          envelope: {
+            chainId: 4217,
+            createdAt,
+            data: {},
+            id: `evt_admin_visibility_${index}`,
+            subscriptionId: 'wh_admin_visibility',
+            type: 'token:transfer',
+          },
+          error: 'HTTP 500',
+          eventId: `evt_admin_visibility_${index}`,
+          id: `whd_admin_visibility_${index}`,
+          requestUrl: 'https://hooks.example.com/private/path',
+          responseStatus: 500,
+          status: 'failed',
+          subscriptionId: 'wh_admin_visibility',
+        },
+        new Date(Date.now() + 60_000).toISOString(),
+      )
+
+    const oldCreatedAt = new Date(Date.now() - 8 * 24 * 60 * 60 * 1_000).toISOString()
+    await WebhookDeliveries.insert(
+      db,
+      {
+        attempt: 1,
+        createdAt: oldCreatedAt,
+        envelope: {
+          chainId: 4217,
+          createdAt: oldCreatedAt,
+          data: {},
+          id: 'evt_admin_visibility_old',
+          subscriptionId: 'wh_admin_visibility',
+          type: 'token:transfer',
+        },
+        error: 'HTTP 500',
+        eventId: 'evt_admin_visibility_old',
+        id: 'whd_admin_visibility_old',
+        requestUrl: 'https://hooks.example.com/private/path',
+        responseStatus: 500,
+        status: 'failed',
+        subscriptionId: 'wh_admin_visibility',
+      },
+      new Date(Date.now() + 60_000).toISOString(),
+    )
+
+    const response = await client.organizations[':orgId'].webhooks.$get({
+      param: { orgId: organization.id },
+    })
+    const body = await TestApp.json(
+      response,
+      AdminOrganizations.schema.getOrganizationWebhooks.Response,
+    )
+
+    expect(body.subscriptions[0]?.destination).toBe('https://hooks.example.com/…')
+    expect(body.failureCount).toBe(26)
+    expect(body.failures).toHaveLength(25)
+    expect(body.failures[0]).toMatchObject({ error: 'HTTP 500', responseStatus: 500 })
+    expect(body.failuresTruncated).toBe(true)
+  })
+})
+
+const usageAnalytics: Analytics.Analytics = {
+  async insert() {},
+  async migrate() {},
+  async query(sql) {
+    if (sql.includes('GROUP BY error_code'))
+      return [{ code: 'upstream_error', requests: 2 }] as never[]
+    if (sql.includes('GROUP BY route'))
+      return [{ averageDurationMs: 12.5, errors: 2, requests: 20, route: '/v1/tokens' }] as never[]
+    if (sql.includes('GROUP BY status')) return [{ requests: 2, status: 500 }] as never[]
+    if (sql.includes('GROUP BY key_id') || sql.includes('GROUP BY toStartOf')) return []
+    return [{ averageDurationMs: 10.5, errors: 2, requests: 25 }] as never[]
+  },
+}