tapimo 0.14.0 → 0.15.0

package/src/apps/data/routes/rpc.test.ts

@@ -8,11 +8,78 @@ import * as TestApp from '../../../../test/App.js'
 import * as Relay from '../../../../test/Relay.js'
 import * as Runtime from '../../../../test/runtime.js'
 
+type JsonSchema = {
+  $ref?: string
+  additionalProperties?: boolean | JsonSchema
+  anyOf?: readonly JsonSchema[]
+  description?: string
+  enum?: readonly string[]
+  examples?: readonly unknown[]
+  items?: JsonSchema
+  minItems?: number
+  not?: JsonSchema
+  properties?: Record<string, JsonSchema>
+  required?: readonly string[]
+}
+
+type OpenApiOperation = {
+  operationId?: string
+  parameters?: readonly {
+    example?: unknown
+    name: string
+    required?: boolean
+  }[]
+  requestBody?: {
+    content?: { 'application/json'?: { schema?: JsonSchema } }
+  }
+  responses?: Record<
+    string,
+    {
+      $ref?: string
+      content?: { 'application/json'?: { schema?: JsonSchema } }
+      description?: string
+      headers?: Record<string, JsonSchema>
+    }
+  >
+  'x-openrpc'?: string
+}
+
+type OpenApiDocument = {
+  components: { schemas: Record<string, JsonSchema> }
+  paths: {
+    '/rpc'?: { post?: OpenApiOperation }
+    '/rpc/{chain}'?: { post?: OpenApiOperation }
+  }
+}
+
+/** Resolves one component reference from the generated OpenAPI document. */
+function resolveSchema(document: OpenApiDocument, value: JsonSchema | undefined) {
+  if (!value?.$ref) return value
+  const name = value.$ref.split('/').at(-1)
+  if (!name) throw new Error(`Invalid OpenAPI component ref ${value.$ref}`)
+  return document.components.schemas[name]
+}
+
+/** Returns the exact Tempo error codes documented for one response status. */
+function errorCodes(
+  document: OpenApiDocument,
+  response:
+    | {
+        content?: { 'application/json'?: { schema?: JsonSchema } }
+      }
+    | undefined,
+) {
+  const envelope = resolveSchema(document, response?.content?.['application/json']?.schema)
+  return resolveSchema(document, envelope?.properties?.['error'])?.properties?.['code']?.enum
+}
+
 const runtime = Runtime.get()
 const zone = runtime.zone.chainId
+const zoneTokenExample =
+  '0x3844647dc3ffc87cb42fdd4112431720a60e33a8c5b42156784b8440b82e360a63c5e71109b8d22eb103650d0df75fa63af4e072400f9cf8a53eb778592c71931b00000000010000000054e53ef3000000006a8df314000000006a8df440'
 const zoneOptions = TestApp.zone({
   chainId: zone,
-  rpcUrl: runtime.zone.publicZoneUrl,
+  rpcUrl: runtime.zone.internalRpcUrl,
 })
 const zoneReader = {
   id: 'key_zone_reader',
@@ -210,7 +277,7 @@ describe('POST /rpc', () => {
       `)
       expect(entries[0]).toMatchObject({
         level: 'error',
-        route: '/rpc/:chain{(mainnet|testnet|[0-9]+)}?',
+        route: '/rpc',
         rpc: { code: -32603, errors: 1, serverErrors: 1 },
         status: 200,
       })
@@ -396,7 +463,17 @@ describe('POST /rpc', () => {
 
   test.each([
     { body: { id: 1, jsonrpc: '2.0' }, name: 'missing result' },
+    {
+      body: {
+        error: { code: -32_601, message: 'method not allowed' },
+        id: 1,
+        jsonrpc: '2.0',
+        result: null,
+      },
+      name: 'result and error',
+    },
     { body: [], name: 'empty batch' },
+    { body: null, name: 'null' },
   ])('attributes malformed JSON-RPC $name payloads to the upstream', async ({ body }) => {
     const entries: Log.Entry[] = []
     const server = await Relay.createServer(
@@ -430,12 +507,61 @@ describe('POST /rpc', () => {
     }
   })
 
-  test('accepts empty responses to JSON-RPC notifications', async () => {
+  test.each([
+    { body: 'null', status: 200 },
+    { body: '', status: 204 },
+  ])('handles empty malformed $status responses as upstream failures', async ({ body, status }) => {
     const entries: Log.Entry[] = []
     const server = await Relay.createServer(
-      RequestListener.fromFetchHandler(() => new Response(null, { status: 200 })),
+      RequestListener.fromFetchHandler(() => new Response(null, { status })),
     )
 
+    try {
+      const app = TestApp.create({
+        auth: false,
+        logger: (entry) => void entries.push(entry),
+        rpc: { url: server.url },
+      })
+      const response = await app.fetch(
+        new Request('http://tempo-api.test/rpc', {
+          body: JSON.stringify({ id: 1, jsonrpc: '2.0', method: 'eth_chainId' }),
+          method: 'POST',
+        }),
+      )
+
+      expect(response.status).toBe(status)
+      expect(await response.text()).toBe(body)
+      expect(entries[0]).toMatchObject({
+        provider: {
+          chainId: runtime.chainId,
+          failure: 'payload',
+          id: 'rpc',
+          operation: 'request',
+        },
+      })
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
+  test.each([
+    {
+      body: 'null',
+      name: 'empty',
+      response: () => new Response(null, { status: 200 }),
+      status: 200,
+    },
+    { body: 'null', name: 'null', response: () => Response.json(null), status: 200 },
+    {
+      body: '',
+      name: 'no-content',
+      response: () => new Response(null, { status: 204 }),
+      status: 204,
+    },
+  ])('accepts $name responses to JSON-RPC notifications', async ({ body, response, status }) => {
+    const entries: Log.Entry[] = []
+    const server = await Relay.createServer(RequestListener.fromFetchHandler(response))
+
     try {
       const app = TestApp.create({
         auth: false,
@@ -449,7 +575,8 @@ describe('POST /rpc', () => {
         }),
       )
 
-      expect(response.status).toBe(200)
+      expect(response.status).toBe(status)
+      expect(await response.text()).toBe(body)
       expect(entries[0]?.provider).toBeUndefined()
     } finally {
       await server.closeAsync()
@@ -525,7 +652,8 @@ describe('POST /rpc', () => {
       const app = TestApp.create({
         auth: false,
         logger: (entry) => void entries.push(entry),
-        zones: [TestApp.zone({ chainId: zone, rpcUrl: server.url })],
+        rpc: { ...TestApp.rpc, publicZoneUrl: server.url },
+        zones: [zoneOptions],
       })
       const response = await app.fetch(
         new Request(`http://tempo-api.test/rpc/${zone}`, {
@@ -741,8 +869,12 @@ describe('POST /rpc', () => {
     try {
       const app = TestApp.create({
         auth: false,
-        rpc: { auth: 'rpc:secret', url: () => 'https://internal.rpc.test' },
-        zones: [TestApp.zone({ chainId: zone, rpcUrl: `https://${zone}.rpc.test` })],
+        rpc: {
+          auth: 'rpc:secret',
+          publicZoneUrl: `https://${zone}.rpc.test`,
+          url: () => 'https://internal.rpc.test',
+        },
+        zones: [zoneOptions],
       })
 
       const response = await app.fetch(
@@ -1108,6 +1240,218 @@ describe('POST /rpc', () => {
     expect(rejectedDefault.status).toMatchInlineSnapshot(`403`)
     expect(rejectedTrailing.status).toMatchInlineSnapshot(`404`)
   })
+
+  test('uses the RPC path below the configured base path', async () => {
+    const app = TestApp.create({
+      auth: {
+        keys: [
+          {
+            environment: 'sandbox',
+            id: 'key_sandbox',
+            orgId: 'org_test',
+            scopes: ['data:read'],
+            token: 'secret_sandbox_key',
+          },
+        ],
+      },
+      defaultChainId: 4217,
+      path: '/api',
+    })
+    const response = await app.fetch(
+      new Request('http://tempo-api.test/api/rpc?chainId=42431', {
+        body: JSON.stringify({ id: 1, jsonrpc: '2.0', method: 'eth_chainId' }),
+        headers: { 'tempo-api-key': 'secret_sandbox_key' },
+        method: 'POST',
+      }),
+    )
+
+    expect(response.status).toMatchInlineSnapshot(`403`)
+  })
+
+  test('documents generator-ready JSON-RPC contracts', async () => {
+    const app = TestApp.create({ auth: false })
+    const document = (await (await app.request('/openapi.json')).json()) as OpenApiDocument
+    const root = document.paths['/rpc']?.post
+    const chain = document.paths['/rpc/{chain}']?.post
+    if (!root || !chain) throw new Error('Missing RPC OpenAPI operations')
+
+    expect({
+      chain: {
+        operationId: chain.operationId,
+        parameters: chain.parameters?.map((parameter) => ({
+          example: parameter.example,
+          name: parameter.name,
+          required: parameter.required,
+        })),
+        request: chain.requestBody?.content?.['application/json']?.schema,
+        response: chain.responses?.['200']?.content?.['application/json']?.schema,
+        xOpenrpc: chain['x-openrpc'],
+      },
+      root: {
+        operationId: root.operationId,
+        parameters: root.parameters?.map((parameter) => ({
+          example: parameter.example,
+          name: parameter.name,
+          required: parameter.required,
+        })),
+        request: root.requestBody?.content?.['application/json']?.schema,
+        response: root.responses?.['200']?.content?.['application/json']?.schema,
+        xOpenrpc: root['x-openrpc'],
+      },
+    }).toMatchObject({
+      chain: {
+        operationId: 'rpcRequestByChain',
+        parameters: [
+          { example: 'testnet', name: 'chain', required: true },
+          { example: zoneTokenExample, name: 'X-Authorization-Token', required: false },
+        ],
+        request: { $ref: '#/components/schemas/JsonRpcRequestBody' },
+        response: { $ref: '#/components/schemas/JsonRpcResponseBody' },
+        xOpenrpc: undefined,
+      },
+      root: {
+        operationId: 'rpcRequest',
+        parameters: [{ example: zoneTokenExample, name: 'X-Authorization-Token', required: false }],
+        request: { $ref: '#/components/schemas/JsonRpcRequestBody' },
+        response: { $ref: '#/components/schemas/JsonRpcResponseBody' },
+        xOpenrpc: '/openrpc.json',
+      },
+    })
+
+    expect({
+      error: document.components.schemas['JsonRpcError']?.required,
+      errorResponseAdditionalProperties:
+        document.components.schemas['JsonRpcErrorResponse']?.additionalProperties,
+      errorResponse: document.components.schemas['JsonRpcErrorResponse']?.required,
+      errorResponseProperties: Object.keys(
+        document.components.schemas['JsonRpcErrorResponse']?.properties ?? {},
+      ),
+      requestParams: document.components.schemas['JsonRpcRequest']?.properties?.['params']?.anyOf,
+      request: document.components.schemas['JsonRpcRequest']?.required,
+      requestBody: document.components.schemas['JsonRpcRequestBody']?.anyOf,
+      response: document.components.schemas['JsonRpcResponse']?.anyOf,
+      responseBody: document.components.schemas['JsonRpcResponseBody']?.anyOf,
+      successResponse: document.components.schemas['JsonRpcSuccessResponse']?.required,
+      successResponseAdditionalProperties:
+        document.components.schemas['JsonRpcSuccessResponse']?.additionalProperties,
+      successResponseProperties: Object.keys(
+        document.components.schemas['JsonRpcSuccessResponse']?.properties ?? {},
+      ),
+    }).toMatchObject({
+      error: ['code', 'message'],
+      errorResponseAdditionalProperties: false,
+      errorResponse: ['error', 'id', 'jsonrpc'],
+      errorResponseProperties: ['error', 'id', 'jsonrpc'],
+      requestParams: [{ type: 'array' }, { type: 'object' }],
+      request: ['jsonrpc', 'method'],
+      requestBody: [
+        { $ref: '#/components/schemas/JsonRpcRequest' },
+        {
+          items: { $ref: '#/components/schemas/JsonRpcRequest' },
+          minItems: 1,
+          type: 'array',
+        },
+      ],
+      response: [
+        { $ref: '#/components/schemas/JsonRpcSuccessResponse' },
+        { $ref: '#/components/schemas/JsonRpcErrorResponse' },
+      ],
+      responseBody: [
+        { type: 'null' },
+        { $ref: '#/components/schemas/JsonRpcResponse' },
+        {
+          items: { $ref: '#/components/schemas/JsonRpcResponse' },
+          minItems: 1,
+          type: 'array',
+        },
+      ],
+      successResponse: ['id', 'jsonrpc', 'result'],
+      successResponseAdditionalProperties: false,
+      successResponseProperties: ['id', 'jsonrpc', 'result'],
+    })
+
+    expect({
+      204: root.responses?.['204']?.description,
+      '204Headers': Object.keys(root.responses?.['204']?.headers ?? {}),
+      400: errorCodes(document, root.responses?.['400']),
+      401: errorCodes(document, root.responses?.['401']),
+      403: errorCodes(document, root.responses?.['403']),
+      413: errorCodes(document, root.responses?.['413']),
+      429: root.responses?.['429']?.$ref,
+      500: root.responses?.['500']?.$ref,
+      502: errorCodes(document, root.responses?.['502']),
+      504: root.responses?.['504']?.$ref,
+      default: root.responses?.['default']?.description,
+    }).toEqual({
+      204: 'Notification accepted with no response body.',
+      '204Headers': [
+        'RateLimit-Limit',
+        'RateLimit-Remaining',
+        'RateLimit-Reset',
+        'RateLimit-Scope',
+        'tempo-request-id',
+      ],
+      400: ['api_key_malformed', 'chain_id_invalid', 'chain_id_unsupported'],
+      401: ['api_key_invalid', 'api_key_missing', 'unauthorized'],
+      403: ['api_key_forbidden', 'api_key_ip_forbidden', 'forbidden'],
+      413: ['payload_too_large'],
+      429: '#/components/responses/RateLimited',
+      500: '#/components/responses/InternalError',
+      502: ['upstream_error'],
+      504: '#/components/responses/RequestTimeout',
+      default:
+        'An upstream HTTP response passed through unchanged, including its status, headers, content type, and body.',
+    })
+
+    expect({
+      204: chain.responses?.['204']?.description,
+      '204Headers': Object.keys(chain.responses?.['204']?.headers ?? {}),
+      400: errorCodes(document, chain.responses?.['400']),
+      401: errorCodes(document, chain.responses?.['401']),
+      403: errorCodes(document, chain.responses?.['403']),
+      413: errorCodes(document, chain.responses?.['413']),
+      429: chain.responses?.['429']?.$ref,
+      500: chain.responses?.['500']?.$ref,
+      502: errorCodes(document, chain.responses?.['502']),
+      504: chain.responses?.['504']?.$ref,
+      default: chain.responses?.['default']?.description,
+    }).toEqual({
+      204: 'Notification accepted with no response body.',
+      '204Headers': [
+        'RateLimit-Limit',
+        'RateLimit-Remaining',
+        'RateLimit-Reset',
+        'RateLimit-Scope',
+        'tempo-request-id',
+      ],
+      400: ['api_key_malformed', 'chain_id_invalid', 'chain_id_unsupported'],
+      401: ['api_key_invalid', 'api_key_missing', 'unauthorized'],
+      403: ['api_key_forbidden', 'api_key_ip_forbidden', 'forbidden'],
+      413: ['payload_too_large'],
+      429: '#/components/responses/RateLimited',
+      500: '#/components/responses/InternalError',
+      502: ['upstream_error'],
+      504: '#/components/responses/RequestTimeout',
+      default:
+        'An upstream HTTP response passed through unchanged, including its status, headers, content type, and body.',
+    })
+
+    for (const name of [
+      'JsonRpcError',
+      'JsonRpcErrorResponse',
+      'JsonRpcId',
+      'JsonRpcRequest',
+      'JsonRpcRequestBody',
+      'JsonRpcResponse',
+      'JsonRpcResponseBody',
+      'JsonRpcSuccessResponse',
+    ]) {
+      const component = document.components.schemas[name]
+      expect(component?.description, name).toBeTruthy()
+      for (const [field, value] of Object.entries(component?.properties ?? {}))
+        if (!value.$ref && !value.not) expect(value.examples, `${name}.${field}`).toBeTruthy()
+    }
+  })
 })
 
 describe('POST /rpc/relay', () => {