tapimo 0.11.0 → 0.13.0

package/src/App.test.ts

@@ -40,6 +40,37 @@ describe('create', () => {
     expect(await store.get('status')).toMatchInlineSnapshot(`"ready"`)
   })
 
+  test('keeps cache persistence alive via waitUntil', async () => {
+    const pending = Promise.withResolvers<void>()
+    const waited: Promise<unknown>[] = []
+    const store = Store.from({
+      ...Store.memory(),
+      put: () => pending.promise,
+      type: 'cache',
+    })
+    const app = TestApp.create({ auth: false, cache: { store } })
+    app.get('/cache', async (c) =>
+      c.json(
+        await Store.memoize(async () => ({ value: 'fresh' }), {
+          key: 'app:cache',
+          store: c.get('store'),
+          ttl: 60_000,
+        }),
+      ),
+    )
+    const executionCtx = {
+      passThroughOnException: () => {},
+      waitUntil: (promise: Promise<unknown>) => void waited.push(promise),
+    }
+
+    const response = await app.request('/cache', undefined, undefined, executionCtx as never)
+
+    expect(response.status).toBe(200)
+    expect(waited).toHaveLength(1)
+    pending.resolve()
+    await Promise.all(waited)
+  })
+
   test('leaves routes public without auth middleware', async () => {
     const app = TestApp.create({ auth: false })
     const response = await app.request('/v1/tokens/not-an-address')
@@ -47,6 +78,57 @@ describe('create', () => {
     expect(response.status).toMatchInlineSnapshot(`400`)
   })
 
+  test('bounds a stalled request with a 504 envelope', async () => {
+    vi.useFakeTimers()
+    try {
+      const app = TestApp.create({ auth: false })
+      app.get('/hang', () => new Promise<never>(() => {}))
+
+      const pending = app.request('/hang')
+      await vi.advanceTimersByTimeAsync(60_000)
+      const response = await pending
+      const { requestId, ...body } = (await response.json()) as Record<string, unknown>
+
+      expect(response.status).toMatchInlineSnapshot(`504`)
+      expect(requestId).toBeTypeOf('string')
+      expect(body).toMatchInlineSnapshot(`
+        {
+          "error": {
+            "code": "request_timeout",
+            "message": "Request timed out",
+          },
+        }
+      `)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  test('exempts mutations and paid requests from the deadline', async () => {
+    vi.useFakeTimers()
+    try {
+      const app = TestApp.create({ auth: false })
+      const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
+      app.post('/slow', async (c) => {
+        await wait(90_000)
+        return c.json({ ok: true }, 200)
+      })
+      app.get('/slow-paid', async (c) => {
+        await wait(90_000)
+        return c.json({ ok: true }, 200)
+      })
+
+      const post = app.request('/slow', { method: 'POST' })
+      const paid = app.request('/slow-paid', { headers: { authorization: 'Payment credential' } })
+      await vi.advanceTimersByTimeAsync(90_000)
+
+      expect((await post).status).toMatchInlineSnapshot(`200`)
+      expect((await paid).status).toMatchInlineSnapshot(`200`)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
   test('serves public health check', async () => {
     const app = TestApp.create({ path: 'api/' })
     const response = await app.request('/api/health')
@@ -147,6 +229,54 @@ describe('create', () => {
     `)
   })
 
+  test('preserves named error schemas across generated documents', async () => {
+    const first = await (await TestApp.create().request('/openapi.json')).json()
+    const second = await (await TestApp.create().request('/openapi.json')).json()
+
+    expect(
+      [first, second].map((spec) => ({
+        forbidden: spec.components.schemas.ForbiddenError.type,
+        internal: spec.components.schemas.InternalError.type,
+      })),
+    ).toEqual([
+      { forbidden: 'object', internal: 'object' },
+      { forbidden: 'object', internal: 'object' },
+    ])
+  })
+
+  test('keeps standard and custom error component names distinct', async () => {
+    const spec = await (await TestApp.create().request('/openapi.json')).json()
+    const billing =
+      spec.paths['/v1/orgs/{orgId}/billing/stripe/checkout'].post.responses[501].content[
+        'application/json'
+      ].schema.$ref
+    const funding =
+      spec.paths['/v1/funding/transfers/vault'].post.responses[501].content['application/json']
+        .schema.$ref
+    const billingName = billing.split('/').at(-1)
+    const fundingName = funding.split('/').at(-1)
+
+    expect({
+      billing: {
+        codes: spec.components.schemas[billingName].properties.error.properties.code.enum,
+        ref: billing,
+      },
+      funding: {
+        codes: spec.components.schemas[fundingName].properties.error.properties.code.enum,
+        ref: funding,
+      },
+    }).toEqual({
+      billing: {
+        codes: ['billing_unconfigured'],
+        ref: '#/components/schemas/NotImplementedError',
+      },
+      funding: {
+        codes: ['not_implemented'],
+        ref: '#/components/schemas/NotImplemented501Error',
+      },
+    })
+  })
+
   test('authenticates a minted store-backed key and rejects after revoke', async () => {
     const store = Store.memory()
     const { record, token } = await ApiKeys.mint(store, {
@@ -453,6 +583,24 @@ describe('create', () => {
     `)
   })
 
+  test('passes the original request error to the configured logger', async () => {
+    const cause = new Error('boom')
+    let logged: Error | undefined
+    const app = TestApp.create({
+      logger: (_entry, error) => {
+        logged = error
+      },
+    })
+    app.get('/boom', () => {
+      throw cause
+    })
+
+    const response = await app.request('/boom')
+
+    expect(response.status).toBe(500)
+    expect(logged).toBe(cause)
+  })
+
   test('logs the selected chain for anonymous edge-cache hits', async () => {
     const entries: Log.Entry[] = []
     const app = TestApp.create({

package/src/App.ts

@@ -5,6 +5,7 @@ import { compress as hono_compress } from 'hono/compress'
 import { cors as hono_cors } from 'hono/cors'
 import { HTTPException } from 'hono/http-exception'
 import { requestId, type RequestIdVariables } from 'hono/request-id'
+import { timeout as hono_timeout } from 'hono/timeout'
 import { generateSpecs } from 'hono-openapi'
 import type { Chain } from 'viem'
 
@@ -91,6 +92,8 @@ export type Environment = {
       tidx: Tidx.getClient.Tidx | undefined
       /** Verified-token feature configuration (refresh window), or undefined when the feature is disabled. Token rows live in `db`. */
       verifiedTokens: { refreshMs?: number | undefined } | undefined
+      /** Zone chain ids inferred from the current API key, or undefined for single-chain requests. */
+      zoneChainIds: readonly Viem.ChainId[] | undefined
       /** Zone chains keyed by chain id; empty when none are configured. */
       zones: ReadonlyMap<number, Chain>
       /** Webhook feature configuration, or undefined when webhooks are disabled. Rows live in `db`. */
@@ -181,6 +184,10 @@ export declare namespace GetAsset {
 /** Top-level OpenAPI `info.description`, rendered above the reference. */
 const infoDescription = 'REST API for reading and interacting with Tempo'
 
+// Comfortably above the slowest legitimate time-to-response observed in
+// production (~40s tidx reads), far below the 17-100 minute stalls it bounds.
+const requestTimeoutMs = 60_000
+
 /** Creates the Tempo API Hono app. */
 export function create<const path extends string = '/'>(options: create.Options<path>) {
   const { path = '/' as path } = options
@@ -270,8 +277,8 @@ export function create<const path extends string = '/'>(options: create.Options<
     base.use(
       '*',
       Log.middleware<Environment>({
-        emit: async (entry) => {
-          await log?.(entry)
+        emit: async (entry, cause) => {
+          await log?.(entry, cause)
           recordRequest?.(entry)
           // Return the analytics promise so `Log.middleware` extends the
           // response with `waitUntil`; otherwise the async sink's `queue.send`
@@ -282,6 +289,30 @@ export function create<const path extends string = '/'>(options: create.Options<
       }),
     )
 
+  // Bounds time-to-response only; streaming bodies are unaffected. Without a
+  // deadline, a request stalled on an unbounded upstream wait pins its
+  // invocation (and isolate memory) until the client disconnects.
+  const deadline = hono_timeout(
+    requestTimeoutMs,
+    (c) =>
+      new HTTPException(504, {
+        res: Response.error(c, {
+          code: 'request_timeout',
+          message: 'Request timed out',
+          status: 504,
+        }),
+      }),
+  )
+  // Safe methods only: the expired handler is abandoned, not aborted, so a
+  // mutation could still commit after the 504. Paid requests are also exempt:
+  // MPP consumes payment before the handler, and the Payment-Receipt attaches
+  // only when the handler returns through the payment wrapper.
+  base.use('*', (c, next) => {
+    if (c.req.method !== 'GET' && c.req.method !== 'HEAD') return next()
+    if (Auth.hasPaymentCredential(c)) return next()
+    return deadline(c, next)
+  })
+
   // Normalize the `db` option: the plain form is `{ source }` with no cached
   // side; `cached` falls back to `source` so consumers never branch.
   const db = 'source' in options.db ? options.db : { source: options.db }
@@ -329,7 +360,7 @@ export function create<const path extends string = '/'>(options: create.Options<
     c.set('providers', providers)
     c.set('rpc', options.rpc)
     c.set('scopeCatalog', scopeCatalog)
-    c.set('store', store)
+    c.set('store', Store.withRequest(store, c.req, { waitUntil: getWaitUntil(c) }))
     c.set('supportedChainIds', supportedChainIds)
     c.set('zones', zones)
     await next()
@@ -481,7 +512,7 @@ export function create<const path extends string = '/'>(options: create.Options<
       documentation: {
         components: {
           headers: OpenApi.headerComponents,
-          responses: OpenApi.responseComponents,
+          responses: OpenApi.responseComponents(),
           securitySchemes: {
             apiKey: {
               description:
@@ -893,6 +924,16 @@ namespace ResponseBody {
   }
 }
 
+function getWaitUntil(c: { executionCtx?: { waitUntil(promise: Promise<unknown>): void } }) {
+  // `c.executionCtx` throws in runtimes without one, so cache persistence falls back to an awaited write.
+  try {
+    const context = c.executionCtx
+    return context ? context.waitUntil.bind(context) : undefined
+  } catch {
+    return undefined
+  }
+}
+
 namespace NodeServer {
   type GetRequestListener = (typeof import('@hono/node-server'))['getRequestListener']
   export type Fetch = Parameters<GetRequestListener>[0]

package/src/Assets.test.ts

@@ -0,0 +1,18 @@
+import * as Assets from './Assets.js'
+
+describe('url', () => {
+  test('builds hosted and base-path asset URLs', () => {
+    const options = {
+      chainId: 4217,
+      origin: 'https://api.tempo.xyz',
+      path: '/icons/0x20c000000000000000000000b9537d11c60e8b50',
+    } as const
+
+    expect(Assets.url(options)).toBe(
+      'https://api.tempo.xyz/assets/4217/icons/0x20c000000000000000000000b9537d11c60e8b50',
+    )
+    expect(Assets.url({ ...options, basePath: '/api/' })).toBe(
+      'https://api.tempo.xyz/api/assets/4217/icons/0x20c000000000000000000000b9537d11c60e8b50',
+    )
+  })
+})

package/src/Assets.ts

@@ -24,6 +24,28 @@ export type Assets = {
   put?: ((key: string, asset: Asset) => Promise<void>) | undefined
 }
 
+/** Builds the public URL for an asset key using the same path shape as the data API. */
+export function url(options: url.Options) {
+  const basePath = options.basePath?.replace(/^\/+|\/+$/g, '')
+  const path = options.path.replace(/^\/+/, '')
+  const pathname = [basePath, 'assets', String(options.chainId), path].filter(Boolean).join('/')
+  return new URL(`/${pathname}`, options.origin).toString()
+}
+
+export declare namespace url {
+  /** Inputs for building one public asset URL. */
+  type Options = {
+    /** Optional API base path mounted before `/assets`. */
+    basePath?: string | undefined
+    /** Chain that owns the asset. */
+    chainId: number
+    /** API origin that serves the asset. */
+    origin: string
+    /** Asset-store path below the chain id. */
+    path: string
+  }
+}
+
 /** Backs {@link Assets} with a Cloudflare R2 bucket. */
 export function cloudflareR2(bucket: cloudflareR2.Bucket): Assets {
   return {