tapimo 0.13.0 → 0.15.0

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

@@ -1,182 +0,0 @@
-import * as TestApp from '../../../test/App.js'
-import * as FundingIdempotency from './fundingIdempotency.js'
-
-const db = TestApp.database()
-
-const now = new Date('2026-01-01T00:00:00.000Z')
-const replayTtlMs = 86_400_000
-const ttlMs = 60_000
-
-beforeEach(() => vi.useFakeTimers({ now, toFake: ['Date'] }))
-afterEach(() => vi.useRealTimers())
-
-function input(overrides: Partial<FundingIdempotency.claim.Input> = {}) {
-  return {
-    apiKeyId: 'key_test',
-    keyHash: `hash_${Math.random().toString(36).slice(2)}`,
-    requestHash: 'req_aaaa',
-    ttlMs,
-    ...overrides,
-  }
-}
-
-describe('claim', () => {
-  test('claims, blocks equivalent concurrent requests, and flags mismatches', async () => {
-    const first = input()
-    expect(await FundingIdempotency.claim(db, first)).toEqual({
-      createdAt: now.toISOString(),
-      type: 'claimed',
-    })
-    expect(await FundingIdempotency.claim(db, first)).toEqual({ type: 'pending' })
-    expect(await FundingIdempotency.claim(db, { ...first, requestHash: 'req_bbbb' })).toEqual({
-      type: 'mismatch',
-    })
-  })
-
-  test('replays the stored response after completion', async () => {
-    const claimed = input()
-    const result = await FundingIdempotency.claim(db, claimed)
-    expect(result.type).toBe('claimed')
-    if (result.type !== 'claimed') return
-    const completedAt = new Date('2026-01-01T00:00:30.000Z')
-    vi.setSystemTime(completedAt)
-    await FundingIdempotency.complete(db, {
-      apiKeyId: claimed.apiKeyId,
-      createdAt: result.createdAt,
-      keyHash: claimed.keyHash,
-      replayTtlMs,
-      response: '{"id":"ftr_test"}',
-      transferId: 'ftr_test',
-    })
-    await expect(
-      db.kysely
-        .selectFrom('funding_idempotency_requests')
-        .select('expiresAt')
-        .where('apiKeyId', '=', claimed.apiKeyId)
-        .where('keyHash', '=', claimed.keyHash)
-        .executeTakeFirstOrThrow(),
-    ).resolves.toEqual({ expiresAt: '2026-01-02T00:00:30.000Z' })
-    expect(await FundingIdempotency.claim(db, claimed)).toEqual({
-      response: '{"id":"ftr_test"}',
-      type: 'replay',
-    })
-    // A different request against the completed key still conflicts.
-    expect(await FundingIdempotency.claim(db, { ...claimed, requestHash: 'req_bbbb' })).toEqual({
-      type: 'mismatch',
-    })
-  })
-
-  test('completes non-transfer resources without a transfer id', async () => {
-    const claimed = input()
-    const result = await FundingIdempotency.claim(db, claimed)
-    expect(result.type).toBe('claimed')
-    if (result.type !== 'claimed') return
-    await FundingIdempotency.complete(db, {
-      apiKeyId: claimed.apiKeyId,
-      createdAt: result.createdAt,
-      keyHash: claimed.keyHash,
-      replayTtlMs,
-      response: '{"id":"fda_test"}',
-    })
-
-    await expect(
-      db.kysely
-        .selectFrom('funding_idempotency_requests')
-        .select('transferId')
-        .where('apiKeyId', '=', claimed.apiKeyId)
-        .where('keyHash', '=', claimed.keyHash)
-        .executeTakeFirstOrThrow(),
-    ).resolves.toEqual({ transferId: null })
-  })
-
-  test('reclaims an expired row in place', async () => {
-    const claimed = input()
-    await FundingIdempotency.claim(db, claimed)
-    const afterExpiry = new Date('2026-01-01T00:01:00.001Z')
-    vi.setSystemTime(afterExpiry)
-    expect(await FundingIdempotency.claim(db, claimed)).toEqual({
-      createdAt: afterExpiry.toISOString(),
-      type: 'claimed',
-    })
-  })
-
-  test('release frees a pending claim for retry', async () => {
-    const claimed = input()
-    const result = await FundingIdempotency.claim(db, claimed)
-    expect(result.type).toBe('claimed')
-    if (result.type !== 'claimed') return
-    await FundingIdempotency.release(db, {
-      apiKeyId: claimed.apiKeyId,
-      createdAt: result.createdAt,
-      keyHash: claimed.keyHash,
-    })
-    expect(await FundingIdempotency.claim(db, claimed)).toEqual({
-      createdAt: now.toISOString(),
-      type: 'claimed',
-    })
-  })
-
-  test('stale completion and release cannot mutate a replacement claim', async () => {
-    const claimed = input()
-    const original = await FundingIdempotency.claim(db, claimed)
-    expect(original.type).toBe('claimed')
-    if (original.type !== 'claimed') return
-
-    const afterExpiry = new Date('2026-01-01T00:01:00.001Z')
-    vi.setSystemTime(afterExpiry)
-    const replacement = await FundingIdempotency.claim(db, claimed)
-    expect(replacement.type).toBe('claimed')
-    if (replacement.type !== 'claimed') return
-
-    const identity = {
-      apiKeyId: claimed.apiKeyId,
-      createdAt: original.createdAt,
-      keyHash: claimed.keyHash,
-    }
-    expect(
-      await FundingIdempotency.complete(db, {
-        ...identity,
-        replayTtlMs,
-        response: '{"id":"ftr_stale"}',
-        transferId: 'ftr_stale',
-      }),
-    ).toBeUndefined()
-    await FundingIdempotency.release(db, identity)
-    expect(await FundingIdempotency.claim(db, claimed)).toEqual({
-      type: 'pending',
-    })
-  })
-})
-
-describe('checkpoint', () => {
-  test('resumes a provider result and completes it', async () => {
-    const claimed = input()
-    const result = await FundingIdempotency.claim(db, claimed)
-    expect(result.type).toBe('claimed')
-    if (result.type !== 'claimed') return
-    await FundingIdempotency.checkpoint(db, {
-      apiKeyId: claimed.apiKeyId,
-      createdAt: result.createdAt,
-      keyHash: claimed.keyHash,
-      replayTtlMs,
-      response: '{"requestId":"relay_request_1"}',
-    })
-
-    expect(await FundingIdempotency.claim(db, claimed)).toEqual({
-      createdAt: now.toISOString(),
-      response: '{"requestId":"relay_request_1"}',
-      type: 'resume',
-    })
-    await FundingIdempotency.complete(db, {
-      apiKeyId: claimed.apiKeyId,
-      createdAt: result.createdAt,
-      keyHash: claimed.keyHash,
-      replayTtlMs,
-      response: '{"id":"fda_test"}',
-    })
-    expect(await FundingIdempotency.claim(db, claimed)).toEqual({
-      response: '{"id":"fda_test"}',
-      type: 'replay',
-    })
-  })
-})

package/src/db/tables/fundingIdempotency.ts

@@ -1,180 +0,0 @@
-import type { Selectable } from 'kysely'
-
-import type * as Db from '../Db.js'
-import type * as db_Schema from '../Schema.js'
-
-/** Columns of the `funding_idempotency_requests` table. */
-export type Table = db_Schema.FundingIdempotencyRequest
-/** A stored idempotency claim. */
-export type Record = Selectable<Table>
-
-/**
- * Claims `(apiKeyId, keyHash)` for one creation attempt. A live claim rejects
- * mismatches, blocks pending work, resumes checkpoints, or replays completion.
- */
-export async function claim(db: Db.Db, input: claim.Input): Promise<claim.Result> {
-  const now = new Date()
-  const record: Record = {
-    apiKeyId: input.apiKeyId,
-    createdAt: now.toISOString(),
-    expiresAt: new Date(now.getTime() + input.ttlMs).toISOString(),
-    keyHash: input.keyHash,
-    requestHash: input.requestHash,
-    response: null,
-    status: 'pending',
-    transferId: null,
-  }
-  const inserted = await db.kysely
-    .insertInto('funding_idempotency_requests')
-    .values(record)
-    .onConflict((oc) => oc.columns(['apiKeyId', 'keyHash']).doNothing())
-    .returningAll()
-    .executeTakeFirst()
-  if (inserted) return { createdAt: inserted.createdAt, type: 'claimed' }
-
-  // Reclaim an expired row in place; the guard keeps two callers from both
-  // reclaiming (only one UPDATE matches the still-expired predicate).
-  const reclaimed = await db.kysely
-    .updateTable('funding_idempotency_requests')
-    .set(record)
-    .where('apiKeyId', '=', input.apiKeyId)
-    .where('keyHash', '=', input.keyHash)
-    .where('expiresAt', '<=', now.toISOString())
-    .returningAll()
-    .executeTakeFirst()
-  if (reclaimed) return { createdAt: reclaimed.createdAt, type: 'claimed' }
-
-  const existing = await db.kysely
-    .selectFrom('funding_idempotency_requests')
-    .selectAll()
-    .where('apiKeyId', '=', input.apiKeyId)
-    .where('keyHash', '=', input.keyHash)
-    .executeTakeFirst()
-  // The row vanished between the insert and the read (released claim); retry.
-  if (!existing) return claim(db, input)
-  if (existing.requestHash !== input.requestHash) return { type: 'mismatch' }
-  if (existing.status === 'pending') return { type: 'pending' }
-  if (existing.status === 'provisioned')
-    return {
-      createdAt: existing.createdAt,
-      response: existing.response ?? '',
-      type: 'resume',
-    }
-  return { response: existing.response ?? '', type: 'replay' }
-}
-
-export declare namespace claim {
-  /** Claim identity and retention. */
-  type Input = {
-    /** API key id (`key_…`) the claim is scoped to. */
-    apiKeyId: string
-    /** SHA-256 of the caller Idempotency-Key. */
-    keyHash: string
-    /** SHA-256 fingerprint of the canonical validated request. */
-    requestHash: string
-    /** Lease duration for the pending execution, in milliseconds. */
-    ttlMs: number
-  }
-
-  /** Outcome of a claim attempt. */
-  type Result =
-    | { createdAt: string; type: 'claimed' }
-    | { type: 'mismatch' }
-    | { type: 'pending' }
-    | { response: string; type: 'replay' }
-    | { createdAt: string; response: string; type: 'resume' }
-}
-
-/** Stores a provider result before committing its API resource and replay response. */
-export function checkpoint(db: Db.Db, input: checkpoint.Input): Promise<Record | undefined> {
-  const now = new Date()
-  return db.kysely
-    .updateTable('funding_idempotency_requests')
-    .set({
-      expiresAt: new Date(now.getTime() + input.replayTtlMs).toISOString(),
-      response: input.response,
-      status: 'provisioned',
-    })
-    .where('apiKeyId', '=', input.apiKeyId)
-    .where('createdAt', '=', input.createdAt)
-    .where('keyHash', '=', input.keyHash)
-    .where('status', '=', 'pending')
-    .returningAll()
-    .executeTakeFirst()
-}
-
-export declare namespace checkpoint {
-  /** Provider result and owned claim required for durable recovery. */
-  type Input = {
-    /** API key id (`key_…`) the claim is scoped to. */
-    apiKeyId: string
-    /** Creation time returned by the successful claim. */
-    createdAt: string
-    /** SHA-256 of the caller Idempotency-Key. */
-    keyHash: string
-    /** Recovery checkpoint retention in milliseconds. */
-    replayTtlMs: number
-    /** Serialized provider result required to resume resource creation. */
-    response: string
-  }
-}
-
-/** Completes an owned pending or provisioned claim with its replay response. */
-export function complete(db: Db.Db, input: complete.Input): Promise<Record | undefined> {
-  const now = new Date()
-  return db.kysely
-    .updateTable('funding_idempotency_requests')
-    .set({
-      expiresAt: new Date(now.getTime() + input.replayTtlMs).toISOString(),
-      response: input.response,
-      status: 'completed',
-      transferId: input.transferId ?? null,
-    })
-    .where('apiKeyId', '=', input.apiKeyId)
-    .where('createdAt', '=', input.createdAt)
-    .where('keyHash', '=', input.keyHash)
-    .where('status', 'in', ['pending', 'provisioned'])
-    .returningAll()
-    .executeTakeFirst()
-}
-
-export declare namespace complete {
-  /** Completion fields. */
-  type Input = {
-    /** API key id (`key_…`) the claim is scoped to. */
-    apiKeyId: string
-    /** Creation time returned by the successful claim. */
-    createdAt: string
-    /** SHA-256 of the caller Idempotency-Key. */
-    keyHash: string
-    /** Successful-response replay retention from completion, in milliseconds. */
-    replayTtlMs: number
-    /** Serialized success response replayed for the retention window. */
-    response: string
-    /** Transfer id (`ftr_…`) when the request created a funding transfer. */
-    transferId?: string | undefined
-  }
-}
-
-/** Releases a pending claim after a retryable failure. */
-export async function release(db: Db.Db, input: release.Input): Promise<void> {
-  await db.kysely
-    .deleteFrom('funding_idempotency_requests')
-    .where('apiKeyId', '=', input.apiKeyId)
-    .where('createdAt', '=', input.createdAt)
-    .where('keyHash', '=', input.keyHash)
-    .where('status', '=', 'pending')
-    .execute()
-}
-
-export declare namespace release {
-  /** Pending claim identity. */
-  type Input = {
-    /** API key id (`key_…`) the claim is scoped to. */
-    apiKeyId: string
-    /** Creation time returned by the successful claim. */
-    createdAt: string
-    /** SHA-256 of the caller Idempotency-Key. */
-    keyHash: string
-  }
-}

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

@@ -1,69 +0,0 @@
-import * as TestApp from '../../../test/App.js'
-import * as TestFunding from '../../../test/Funding.js'
-import * as Transfer from '../../internal/funding/Transfer.js'
-import * as FundingTransferTransactions from './fundingTransferTransactions.js'
-
-const db = TestApp.database()
-
-function createTransfer(id: string) {
-  return Transfer.create(db, {
-    apiKeyId: 'key_test',
-    environment: 'production',
-    id,
-    orgId: 'org_test',
-    snapshot: TestFunding.transferSnapshot(),
-  })
-}
-
-describe('insert', () => {
-  test('canonicalizes EVM hashes before enforcing source uniqueness', async () => {
-    const first = await createTransfer('ftr_evm_first')
-    const second = await createTransfer('ftr_evm_second')
-    const transactionRef = `0x${'aB'.repeat(32)}`
-
-    const inserted = await FundingTransferTransactions.insert(db, {
-      chainId: 'eip155:8453',
-      createdAt: '2026-01-01T00:00:01.000Z',
-      role: 'source',
-      transactionRef,
-      transferId: first.id,
-    })
-    expect(inserted?.transactionRef).toBe(transactionRef.toLowerCase())
-
-    await expect(
-      FundingTransferTransactions.insert(db, {
-        chainId: 'eip155:8453',
-        createdAt: '2026-01-01T00:00:02.000Z',
-        role: 'source',
-        transactionRef: transactionRef.toUpperCase(),
-        transferId: second.id,
-      }),
-    ).rejects.toMatchObject({ constraint: 'funding_transfer_transactions_source_unique' })
-  })
-
-  test('preserves case-sensitive non-EVM transaction references', async () => {
-    const first = await createTransfer('ftr_solana_first')
-    const second = await createTransfer('ftr_solana_second')
-    const transactionRef = 'A'.repeat(87)
-
-    const uppercase = await FundingTransferTransactions.insert(db, {
-      chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
-      createdAt: '2026-01-01T00:00:01.000Z',
-      role: 'source',
-      transactionRef,
-      transferId: first.id,
-    })
-    const lowercase = await FundingTransferTransactions.insert(db, {
-      chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
-      createdAt: '2026-01-01T00:00:02.000Z',
-      role: 'source',
-      transactionRef: transactionRef.toLowerCase(),
-      transferId: second.id,
-    })
-
-    expect([uppercase?.transactionRef, lowercase?.transactionRef]).toEqual([
-      transactionRef,
-      transactionRef.toLowerCase(),
-    ])
-  })
-})

package/src/db/tables/fundingTransferTransactions.ts

@@ -1,37 +0,0 @@
-import type { Selectable } from 'kysely'
-
-import type * as Db from '../Db.js'
-import type * as db_Schema from '../Schema.js'
-
-/** Columns of the `funding_transfer_transactions` table. */
-export type Table = db_Schema.FundingTransferTransaction
-/** One verified transaction reference on a transfer. */
-export type Record = Selectable<Table>
-
-/**
- * Inserts a transaction reference, lowercasing EVM hashes while preserving
- * other references. Repeats return `undefined`; conflicting source ownership throws.
- */
-export function insert(db: Db.Db, record: Record): Promise<Record | undefined> {
-  return db.kysely
-    .insertInto('funding_transfer_transactions')
-    .values({
-      ...record,
-      transactionRef: record.chainId.startsWith('eip155:')
-        ? record.transactionRef.toLowerCase()
-        : record.transactionRef,
-    })
-    .onConflict((oc) => oc.columns(['transferId', 'role', 'transactionRef']).doNothing())
-    .returningAll()
-    .executeTakeFirst()
-}
-
-/** Lists a transfer's transaction references, oldest first. */
-export function listByTransfer(db: Db.Db, transferId: string): Promise<Record[]> {
-  return db.kysely
-    .selectFrom('funding_transfer_transactions')
-    .selectAll()
-    .where('transferId', '=', transferId)
-    .orderBy('createdAt', 'asc')
-    .execute()
-}

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

@@ -1,89 +0,0 @@
-import * as Transfer from '../../internal/funding/Transfer.js'
-import * as TestApp from '../../../test/App.js'
-import * as TestFunding from '../../../test/Funding.js'
-import * as FundingTransfers from './fundingTransfers.js'
-
-const db = TestApp.database()
-
-const owner = { environment: 'production', orgId: 'org_list' } as const
-
-let counter = 0
-function seed(input: Partial<Transfer.create.Input> = {}) {
-  // Distinct create times keep ids strictly ordered for paging assertions.
-  return Transfer.create(db, {
-    apiKeyId: 'key_test',
-    environment: 'production',
-    id: Transfer.generateId(new Date(Date.UTC(2026, 0, 1, 0, 0, counter++))),
-    orgId: owner.orgId,
-    snapshot: TestFunding.transferSnapshot(),
-    ...input,
-  })
-}
-
-describe('list', () => {
-  test('pages newest-first by id with owner isolation', async () => {
-    const first = await seed()
-    const second = await seed({ projectId: 'prj_a' })
-    const third = await seed()
-    await seed({ orgId: 'org_other' })
-    await seed({ environment: 'sandbox' })
-
-    const page = await FundingTransfers.list(db, owner, { limit: 3 })
-    expect(page.map((row) => row.id)).toEqual([third.id, second.id, first.id])
-
-    const rest = await FundingTransfers.list(db, owner, { cursor: third.id, limit: 3 })
-    expect(rest.map((row) => row.id)).toEqual([second.id, first.id])
-  })
-
-  test('narrows project-attributed owners to their project', async () => {
-    const rows = await FundingTransfers.list(db, { ...owner, projectId: 'prj_a' }, { limit: 10 })
-    expect(rows.every((row) => row.projectId === 'prj_a')).toBe(true)
-    expect(rows.length).toBeGreaterThan(0)
-  })
-
-  test('filters by status', async () => {
-    const record = await seed()
-    await Transfer.transition(db, { expectedVersion: 1, id: record.id, status: 'expired' })
-    const rows = await FundingTransfers.list(db, owner, { limit: 10, status: 'expired' })
-    expect(rows.map((row) => row.id)).toEqual([record.id])
-  })
-})
-
-describe('count', () => {
-  test('shares the list filter and stops at the cap', async () => {
-    const total = await FundingTransfers.count(db, owner, { cap: 100 })
-    expect(total).toBeGreaterThanOrEqual(3)
-    expect(await FundingTransfers.count(db, owner, { cap: 2 })).toBe(3)
-    expect(await FundingTransfers.count(db, { ...owner, orgId: 'org_none' }, { cap: 100 })).toBe(0)
-  })
-})
-
-describe('getOwned', () => {
-  test('returns owned rows and hides foreign ones', async () => {
-    const record = await seed()
-    expect((await FundingTransfers.getOwned(db, owner, record.id))?.id).toBe(record.id)
-    expect(
-      await FundingTransfers.getOwned(db, { ...owner, orgId: 'org_other' }, record.id),
-    ).toBeUndefined()
-    expect(
-      await FundingTransfers.getOwned(db, { ...owner, projectId: 'prj_a' }, record.id),
-    ).toBeUndefined()
-  })
-})
-
-describe('update', () => {
-  test('applies only against the expected version', async () => {
-    const record = await seed()
-    const options = {
-      expectedVersion: 1,
-      id: record.id,
-      snapshot: record.snapshot,
-      status: 'processing',
-      statusReason: null,
-      updatedAt: '2026-01-01T00:10:00.000Z',
-      version: 2,
-    } as const
-    expect((await FundingTransfers.update(db, options))?.version).toBe(2)
-    expect(await FundingTransfers.update(db, options)).toBeUndefined()
-  })
-})