ts-procedures 7.2.0 → 8.0.0

package/src/implementations/http/hono-stream/error-taxonomy.test.ts

@@ -1,178 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-import { describe, expect, test, vi } from 'vitest'
-import { Type } from 'typebox'
-import { Procedures } from '../../../index.js'
-import { RPCConfig } from '../../types.js'
-import { HonoStreamAppBuilder, defineErrorTaxonomy } from './index.js'
-
-class AuthError extends Error {
-  constructor(readonly reason: 'unauthenticated' | 'forbidden') {
-    super(reason)
-    this.name = 'AuthError'
-    Object.setPrototypeOf(this, AuthError.prototype)
-  }
-}
-
-describe('HonoStreamAppBuilder — error taxonomy (pre-stream)', () => {
-  test('taxonomy catches errors thrown during context resolution', async () => {
-    const errors = defineErrorTaxonomy({
-      AuthError: {
-        class: AuthError,
-        statusCode: 401,
-        toResponse: (err) => ({ name: 'AuthError', reason: err.reason }),
-      },
-    })
-    const RPC = Procedures<{}, RPCConfig>()
-    RPC.CreateStream('Stream', { scope: 'test', version: 1 }, async function* () {
-      yield { msg: 'ok' }
-    })
-
-    const app = new HonoStreamAppBuilder({ errors })
-      .register(RPC, () => {
-        throw new AuthError('forbidden')
-      })
-      .build()
-
-    const res = await app.request('/test/stream/1')
-    expect(res.status).toBe(401)
-    expect(await res.json()).toEqual({ name: 'AuthError', reason: 'forbidden' })
-  })
-
-  test('default taxonomy serializes ProcedureValidationError at 400 when user opts in', async () => {
-    const RPC = Procedures<{}, RPCConfig>()
-    RPC.CreateStream(
-      'Stream',
-      {
-        scope: 'test',
-        version: 1,
-        schema: { params: Type.Object({ n: Type.Number() }) },
-      },
-      async function* () {
-        yield { ok: true }
-      }
-    )
-    const app = new HonoStreamAppBuilder({ errors: {} }).register(RPC, () => ({})).build()
-    const res = await app.request('/test/stream/1?n=not-a-number')
-    expect(res.status).toBe(400)
-    const body = (await res.json()) as any
-    expect(body.name).toBe('ProcedureValidationError')
-  })
-
-  test('onError callback runs when taxonomy does not match', async () => {
-    const onError = vi.fn(async (_p: any, c: any) => c.json({ handled: true }, 418))
-    const RPC = Procedures<{}, RPCConfig>()
-    RPC.CreateStream('Stream', { scope: 'test', version: 1 }, async function* () {
-      yield { ok: true }
-    })
-    const app = new HonoStreamAppBuilder({ onError })
-      .register(RPC, () => {
-        throw new TypeError('context failed')
-      })
-      .build()
-
-    const res = await app.request('/test/stream/1')
-    expect(res.status).toBe(418)
-    expect(onError).toHaveBeenCalledOnce()
-  })
-
-  test('unknownError is used for unmapped pre-stream errors', async () => {
-    const RPC = Procedures<{}, RPCConfig>()
-    RPC.CreateStream('Stream', { scope: 'test', version: 1 }, async function* () {
-      yield { ok: true }
-    })
-    const app = new HonoStreamAppBuilder({
-      unknownError: {
-        statusCode: 503,
-        toResponse: () => ({ name: 'ServiceUnavailable' }),
-      },
-    })
-      .register(RPC, () => {
-        throw new TypeError('infra down')
-      })
-      .build()
-
-    const res = await app.request('/test/stream/1')
-    expect(res.status).toBe(503)
-    expect(await res.json()).toEqual({ name: 'ServiceUnavailable' })
-  })
-})
-
-describe('HonoStreamAppBuilder — error taxonomy (mid-stream)', () => {
-  test('taxonomy resolves the body for a typed error thrown mid-stream (SSE)', async () => {
-    const errors = defineErrorTaxonomy({
-      AuthError: {
-        class: AuthError,
-        statusCode: 403,
-        toResponse: (err) => ({ name: 'AuthError', reason: err.reason }),
-      },
-    })
-    const RPC = Procedures<{}, RPCConfig>()
-    RPC.CreateStream('Stream', { scope: 'test', version: 1 }, async function* () {
-      yield { msg: 'first' }
-      throw new AuthError('forbidden')
-    })
-
-    const app = new HonoStreamAppBuilder({ errors })
-      .register(RPC, () => ({}))
-      .build()
-
-    const res = await app.request('/test/stream/1', { method: 'POST' })
-    expect(res.status).toBe(200) // status committed before error
-    const text = await res.text()
-    // Last event is the error event with the resolved body shape
-    expect(text).toContain('event: error')
-    expect(text).toContain('"name":"AuthError"')
-    expect(text).toContain('"reason":"forbidden"')
-  })
-
-  test('onMidStreamError still runs as fallback when taxonomy does not match', async () => {
-    const RPC = Procedures<{}, RPCConfig>()
-    RPC.CreateStream('Stream', { scope: 'test', version: 1 }, async function* () {
-      yield { msg: 'first' }
-      throw new TypeError('mid-stream boom')
-    })
-
-    const app = new HonoStreamAppBuilder({
-      errors: {
-        AuthError: {
-          class: AuthError,
-          statusCode: 403,
-          toResponse: () => ({ name: 'AuthError', reason: 'forbidden' }),
-        },
-      },
-      onMidStreamError: (_p, _c, err) => ({ data: { name: 'FallbackError', message: err.message } }),
-    })
-      .register(RPC, () => ({}))
-      .build()
-
-    const res = await app.request('/test/stream/1', { method: 'POST' })
-    const text = await res.text()
-    expect(text).toContain('"name":"FallbackError"')
-    expect(text).toContain('mid-stream boom')
-  })
-
-  test('mid-stream typed body falls through to text mode', async () => {
-    const RPC = Procedures<{}, RPCConfig>()
-    RPC.CreateStream('Stream', { scope: 'test', version: 1 }, async function* () {
-      yield { msg: 'first' }
-      throw new AuthError('forbidden')
-    })
-    const app = new HonoStreamAppBuilder({
-      defaultStreamMode: 'text',
-      errors: {
-        AuthError: {
-          class: AuthError,
-          statusCode: 403,
-          toResponse: () => ({ name: 'AuthError', reason: 'forbidden' }),
-        },
-      },
-    })
-      .register(RPC, () => ({}))
-      .build()
-
-    const res = await app.request('/test/stream/1', { method: 'POST' })
-    const text = await res.text()
-    expect(text).toContain('"name":"AuthError"')
-    expect(text).toContain('"reason":"forbidden"')
-  })
-})