ts-procedures 7.3.0 → 8.0.0

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

@@ -1,179 +0,0 @@
-import { describe, expect, test, vi } from 'vitest'
-import { Type } from 'typebox'
-import { Procedures } from '../../../index.js'
-import { APIConfig } from '../../types.js'
-import { HonoAPIAppBuilder, defineErrorTaxonomy } from './index.js'
-
-class UseCaseError extends Error {
-  constructor(
-    readonly externalMsg: string,
-    readonly internalMsg: string
-  ) {
-    super(externalMsg)
-    this.name = 'UseCaseError'
-    Object.setPrototypeOf(this, UseCaseError.prototype)
-  }
-}
-
-describe('HonoAPIAppBuilder — error taxonomy', () => {
-  test('taxonomy serializes user error with configured status + body', async () => {
-    const errors = defineErrorTaxonomy({
-      UseCaseError: {
-        class: UseCaseError,
-        statusCode: 422,
-        toResponse: (err) => ({ name: 'UseCaseError', message: err.externalMsg }),
-      },
-    })
-
-    const API = Procedures<{}, APIConfig>()
-    API.Create(
-      'Boom',
-      {
-        path: '/boom',
-        method: 'get',
-        schema: { returnType: Type.Object({}) },
-      },
-      async () => {
-        throw new UseCaseError('public detail', 'private stack')
-      }
-    )
-
-    const app = new HonoAPIAppBuilder({ errors }).register(API, () => ({})).build()
-    const res = await app.request('/boom')
-    expect(res.status).toBe(422)
-    expect(await res.json()).toEqual({ name: 'UseCaseError', message: 'public detail' })
-  })
-
-  test('onCatch is awaited before response is sent', async () => {
-    const logged: string[] = []
-    const onCatch = vi.fn(async (err: UseCaseError) => {
-      await Promise.resolve()
-      logged.push(err.internalMsg)
-    })
-
-    const errors = defineErrorTaxonomy({
-      UseCaseError: {
-        class: UseCaseError,
-        statusCode: 422,
-        onCatch,
-      },
-    })
-
-    const API = Procedures<{}, APIConfig>()
-    API.Create(
-      'Boom',
-      { path: '/boom', method: 'get', schema: { returnType: Type.Object({}) } },
-      async () => {
-        throw new UseCaseError('ext', 'int-log')
-      }
-    )
-
-    const app = new HonoAPIAppBuilder({ errors }).register(API, () => ({})).build()
-    await app.request('/boom')
-    expect(onCatch).toHaveBeenCalledOnce()
-    expect(logged).toEqual(['int-log'])
-  })
-
-  test('unknownError catches errors the taxonomy does not match', async () => {
-    const API = Procedures<{}, APIConfig>()
-    API.Create(
-      'Boom',
-      { path: '/boom', method: 'get', schema: { returnType: Type.Object({}) } },
-      async () => {
-        throw new TypeError('ts-broke')
-      }
-    )
-
-    const app = new HonoAPIAppBuilder({
-      unknownError: {
-        statusCode: 503,
-        toResponse: () => ({ name: 'ServiceUnavailable' }),
-      },
-    })
-      .register(API, () => ({}))
-      .build()
-
-    const res = await app.request('/boom')
-    expect(res.status).toBe(503)
-    expect(await res.json()).toEqual({ name: 'ServiceUnavailable' })
-  })
-
-  test('default taxonomy catches ProcedureValidationError at 400 when user opts in', async () => {
-    const API = Procedures<{}, APIConfig>()
-    API.Create(
-      'Validate',
-      {
-        path: '/v',
-        method: 'post',
-        schema: {
-          input: { body: Type.Object({ n: Type.Number() }) },
-          returnType: Type.Object({}),
-        },
-      },
-      async () => ({})
-    )
-    // Empty user taxonomy opts into the default chain.
-    const app = new HonoAPIAppBuilder({ errors: {} }).register(API, () => ({})).build()
-    const res = await app.request('/v', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ 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/unknownError do not match', async () => {
-    const onError = vi.fn(async (_p: any, c: any) => c.json({ legacy: true }, 418))
-    const API = Procedures<{}, APIConfig>()
-    API.Create(
-      'Boom',
-      { path: '/boom', method: 'get', schema: { returnType: Type.Object({}) } },
-      async () => {
-        throw new TypeError('legacy path')
-      }
-    )
-    const app = new HonoAPIAppBuilder({ onError }).register(API, () => ({})).build()
-    const res = await app.request('/boom')
-    expect(res.status).toBe(418)
-    expect(await res.json()).toEqual({ legacy: true })
-    expect(onError).toHaveBeenCalledOnce()
-  })
-
-  test('no config → hard default unchanged ({ error: message }, 500)', async () => {
-    const API = Procedures<{}, APIConfig>()
-    API.Create(
-      'Boom',
-      { path: '/boom', method: 'get', schema: { returnType: Type.Object({}) } },
-      async () => {
-        throw new TypeError('untouched')
-      }
-    )
-    const app = new HonoAPIAppBuilder().register(API, () => ({})).build()
-    const res = await app.request('/boom')
-    expect(res.status).toBe(500)
-    // The handler's TypeError is wrapped by the core into a ProcedureError with
-    // `cause` set. The default ProcedureError entry skips wrappers, no
-    // unknownError is configured, and no onError is provided — so we hit the
-    // hard default: { error: message }.
-    expect(await res.json()).toEqual({ error: expect.stringContaining('untouched') })
-  })
-
-  test('ctx.error() is serialized by the default ProcedureError taxonomy entry when opted in', async () => {
-    const API = Procedures<{}, APIConfig>()
-    API.Create(
-      'Boom',
-      { path: '/boom', method: 'get', schema: { returnType: Type.Object({}) } },
-      async (ctx) => {
-        throw ctx.error('direct from ctx.error', { code: 'E1' })
-      }
-    )
-    const app = new HonoAPIAppBuilder({ errors: {} }).register(API, () => ({})).build()
-    const res = await app.request('/boom')
-    expect(res.status).toBe(500)
-    const body = (await res.json()) as any
-    expect(body.name).toBe('ProcedureError')
-    expect(body.procedureName).toBe('Boom')
-  })
-})