@mpen/routekit 0.1.0 → 0.1.2

package/src/router/response/formats/problem/problem.test.ts

@@ -1,888 +0,0 @@
-#!/usr/bin/env -S bun test
-import { describe, expect, it } from 'bun:test'
-import { HttpMethod, HttpStatus } from '@mpen/http'
-import type { LogActivity, Logger } from '@mpen/logger'
-import { expectType, type TypeEqual } from '@mpen/ts-types'
-import * as v from 'valibot'
-import { Router } from '../../../router'
-import {
-    badRequest,
-    conflict,
-    created,
-    notFound,
-    ok,
-    permissionDenied,
-    problem,
-    problemRootErrors,
-    rateLimited,
-    sessionExpired,
-    unauthenticated,
-    validationProblem,
-} from './index'
-import {
-    createValibotRouteBuilder,
-    issueFromValibotIssue,
-    issuesFromValibotIssues,
-    okSchema,
-    problemIssueSchema,
-    problemValidationErrorHandler,
-    problemSchema,
-    standardResponseSchema,
-    validationProblemFromValibotIssues,
-} from './valibot'
-import type { SuccessResponse, ProblemResponse } from './index'
-
-type TestLogger = Logger & {
-    errorCalls: unknown[][]
-}
-
-function createTestLogger(): TestLogger {
-    const errorCalls: unknown[][] = []
-    const create = (): Logger => {
-        const logger: Logger = {
-            log() {},
-            info() {},
-            warn() {},
-            error(...data: unknown[]) {
-                errorCalls.push(data)
-            },
-            table() {},
-            withContext() {
-                return logger
-            },
-            startActivity(): LogActivity {
-                return {
-                    logger,
-                    end() {},
-                }
-            },
-        }
-        return logger
-    }
-    return Object.assign(create(), { errorCalls })
-}
-
-describe(ok.name, () => {
-    it('creates a successful standard response envelope', () => {
-        const result = ok(
-            { id: 'user_123' },
-            { headers: { 'x-request-id': 'req_123' }, meta: { requestId: 'req_123' } },
-        )
-
-        expect(result.status).toBe(HttpStatus.OK)
-        expect(result.headers.get('x-request-id')).toBe('req_123')
-        expect(result.body).toEqual({
-            success: true,
-            data: { id: 'user_123' },
-            meta: { requestId: 'req_123' },
-        })
-        expectType<
-            TypeEqual<
-                typeof result.body,
-                SuccessResponse<{ readonly id: 'user_123' }, { readonly requestId: 'req_123' }>
-            >
-        >(true)
-    })
-})
-
-describe(created.name, () => {
-    it('creates a created standard response envelope', () => {
-        const result = created(
-            { id: 'user_123' },
-            { headers: { 'x-request-id': 'req_123' }, meta: { requestId: 'req_123' } },
-        )
-
-        expect(result.status).toBe(HttpStatus.CREATED)
-        expect(result.headers.get('x-request-id')).toBe('req_123')
-        expect(result.body).toEqual({
-            success: true,
-            data: { id: 'user_123' },
-            meta: { requestId: 'req_123' },
-        })
-        expectType<
-            TypeEqual<
-                typeof result.body,
-                SuccessResponse<{ readonly id: 'user_123' }, { readonly requestId: 'req_123' }>
-            >
-        >(true)
-    })
-})
-
-describe(problem.name, () => {
-    it('creates a problem response envelope', () => {
-        const result = problem({
-            code: 'not_found',
-            message: 'No user exists for the provided id.',
-            status: HttpStatus.NOT_FOUND,
-            title: 'User not found',
-            headers: { 'x-request-id': 'req_123' },
-        })
-
-        expect(result.status).toBe(HttpStatus.NOT_FOUND)
-        expect(result.headers.get('x-request-id')).toBe('req_123')
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'not_found',
-                message: 'No user exists for the provided id.',
-                title: 'User not found',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'not_found'>>>(true)
-    })
-})
-
-describe(problemRootErrors.name, () => {
-    it('installs problem response handlers for router root errors', async () => {
-        const error = new Error('boom')
-        const logger = createTestLogger()
-        const router = new Router()
-            .setLogger(logger)
-            .install(problemRootErrors())
-            .post('/json', {
-                accept: ['application/json'],
-                handler: () => ok({ accepted: true }),
-            })
-            .get('/boom', () => {
-                throw error
-            })
-
-        const cases = [
-            {
-                request: new Request('https://example.com/missing'),
-                status: HttpStatus.NOT_FOUND,
-                code: 'not_found',
-                message: 'Not found',
-            },
-            {
-                request: new Request('https://example.com/json', { method: HttpMethod.GET }),
-                status: HttpStatus.METHOD_NOT_ALLOWED,
-                code: 'method_not_allowed',
-                message: 'Method not allowed',
-            },
-            {
-                request: new Request('https://example.com/json', { method: HttpMethod.POST }),
-                status: HttpStatus.UNSUPPORTED_MEDIA_TYPE,
-                code: 'unsupported_media_type',
-                message: 'Unsupported media type',
-            },
-            {
-                request: new Request('https://example.com/boom'),
-                status: HttpStatus.INTERNAL_SERVER_ERROR,
-                code: 'internal_server_error',
-                message: 'Internal server error',
-            },
-        ] as const
-
-        for (const testCase of cases) {
-            const response = await router.fetch(testCase.request)
-
-            expect(response.status).toBe(testCase.status)
-            expect(response.headers.get('content-type')).toBe('application/json')
-            expect(await response.json()).toEqual({
-                success: false,
-                error: {
-                    code: testCase.code,
-                    message: testCase.message,
-                },
-            })
-        }
-        expect(logger.errorCalls).toHaveLength(1)
-        expect(logger.errorCalls[0]?.[1]).toBe(error)
-    })
-
-    it('lets later root handlers override installed defaults', async () => {
-        const router = new Router()
-            .install(problemRootErrors())
-            .onNotFound(() => new Response('custom missing', { status: HttpStatus.NOT_FOUND }))
-
-        const response = await router.fetch(new Request('https://example.com/missing'))
-
-        expect(response.status).toBe(HttpStatus.NOT_FOUND)
-        expect(await response.text()).toBe('custom missing')
-    })
-})
-
-describe(notFound.name, () => {
-    it('creates a not found problem response envelope with string message', () => {
-        const result = notFound('Todo not found.', {
-            headers: { 'x-request-id': 'req_123' },
-        })
-
-        expect(result.status).toBe(HttpStatus.NOT_FOUND)
-        expect(result.headers.get('x-request-id')).toBe('req_123')
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'not_found',
-                message: 'Todo not found.',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'not_found'>>>(true)
-    })
-
-    it('creates a not found problem response envelope with options object', () => {
-        const result = notFound({
-            message: 'User not found.',
-            headers: { 'x-request-id': 'req_123' },
-        })
-
-        expect(result.status).toBe(HttpStatus.NOT_FOUND)
-        expect(result.headers.get('x-request-id')).toBe('req_123')
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'not_found',
-                message: 'User not found.',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'not_found'>>>(true)
-    })
-
-    it('uses default message when none provided', () => {
-        const result = notFound()
-
-        expect(result.status).toBe(HttpStatus.NOT_FOUND)
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'not_found',
-                message: 'Not found',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'not_found'>>>(true)
-    })
-
-    it('allows overriding code and status', () => {
-        const result = notFound({
-            code: 'todo_not_found',
-            status: HttpStatus.GONE,
-            message: 'This todo has been deleted.',
-        })
-
-        expect(result.status).toBe(HttpStatus.GONE)
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'todo_not_found',
-                message: 'This todo has been deleted.',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'todo_not_found'>>>(true)
-    })
-})
-
-describe(permissionDenied.name, () => {
-    it('creates a permission denied problem response envelope with string message', () => {
-        const result = permissionDenied('You cannot access this.', {
-            headers: { 'x-request-id': 'req_123' },
-        })
-
-        expect(result.status).toBe(HttpStatus.FORBIDDEN)
-        expect(result.headers.get('x-request-id')).toBe('req_123')
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'permission_denied',
-                message: 'You cannot access this.',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'permission_denied'>>>(true)
-    })
-
-    it('creates a permission denied problem response envelope with options object', () => {
-        const result = permissionDenied({
-            message: 'Insufficient privileges.',
-            headers: { 'x-request-id': 'req_123' },
-        })
-
-        expect(result.status).toBe(HttpStatus.FORBIDDEN)
-        expect(result.headers.get('x-request-id')).toBe('req_123')
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'permission_denied',
-                message: 'Insufficient privileges.',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'permission_denied'>>>(true)
-    })
-
-    it('uses default message when none provided', () => {
-        const result = permissionDenied()
-
-        expect(result.status).toBe(HttpStatus.FORBIDDEN)
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'permission_denied',
-                message: 'Permission denied',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'permission_denied'>>>(true)
-    })
-
-    it('allows overriding code and status', () => {
-        const result = permissionDenied({
-            code: 'custom_denied',
-            status: HttpStatus.FORBIDDEN,
-            message: 'Custom permission error.',
-        })
-
-        expect(result.status).toBe(HttpStatus.FORBIDDEN)
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'custom_denied',
-                message: 'Custom permission error.',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'custom_denied'>>>(true)
-    })
-})
-
-describe(unauthenticated.name, () => {
-    it('creates an unauthenticated problem response envelope with string message', () => {
-        const result = unauthenticated('Missing token.', {
-            headers: { 'x-request-id': 'req_123' },
-        })
-
-        expect(result.status).toBe(HttpStatus.UNAUTHORIZED)
-        expect(result.headers.get('x-request-id')).toBe('req_123')
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'unauthenticated',
-                message: 'Missing token.',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'unauthenticated'>>>(true)
-    })
-
-    it('creates an unauthenticated problem response envelope with options object', () => {
-        const result = unauthenticated({
-            message: 'Invalid credentials.',
-            headers: { 'x-request-id': 'req_123' },
-        })
-
-        expect(result.status).toBe(HttpStatus.UNAUTHORIZED)
-        expect(result.headers.get('x-request-id')).toBe('req_123')
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'unauthenticated',
-                message: 'Invalid credentials.',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'unauthenticated'>>>(true)
-    })
-
-    it('uses default message when none provided', () => {
-        const result = unauthenticated()
-
-        expect(result.status).toBe(HttpStatus.UNAUTHORIZED)
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'unauthenticated',
-                message: 'Unauthenticated',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'unauthenticated'>>>(true)
-    })
-
-    it('allows overriding code and status', () => {
-        const result = unauthenticated({
-            code: 'invalid_auth',
-            status: HttpStatus.UNAUTHORIZED,
-            message: 'Auth failed.',
-        })
-
-        expect(result.status).toBe(HttpStatus.UNAUTHORIZED)
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'invalid_auth',
-                message: 'Auth failed.',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'invalid_auth'>>>(true)
-    })
-})
-
-describe(sessionExpired.name, () => {
-    it('creates a session expired problem response envelope with string message', () => {
-        const result = sessionExpired('Session has timed out.', {
-            headers: { 'x-request-id': 'req_123' },
-        })
-
-        expect(result.status).toBe(HttpStatus.UNAUTHORIZED)
-        expect(result.headers.get('x-request-id')).toBe('req_123')
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'session_expired',
-                message: 'Session has timed out.',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'session_expired'>>>(true)
-    })
-
-    it('creates a session expired problem response envelope with options object', () => {
-        const result = sessionExpired({
-            message: 'Session expired.',
-            headers: { 'x-request-id': 'req_123' },
-        })
-
-        expect(result.status).toBe(HttpStatus.UNAUTHORIZED)
-        expect(result.headers.get('x-request-id')).toBe('req_123')
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'session_expired',
-                message: 'Session expired.',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'session_expired'>>>(true)
-    })
-
-    it('uses default message when none provided', () => {
-        const result = sessionExpired()
-
-        expect(result.status).toBe(HttpStatus.UNAUTHORIZED)
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'session_expired',
-                message: 'Session expired',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'session_expired'>>>(true)
-    })
-})
-
-describe(badRequest.name, () => {
-    it('creates a bad request problem response envelope with string message', () => {
-        const result = badRequest('Invalid format.', {
-            headers: { 'x-request-id': 'req_123' },
-        })
-
-        expect(result.status).toBe(HttpStatus.BAD_REQUEST)
-        expect(result.headers.get('x-request-id')).toBe('req_123')
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'bad_request',
-                message: 'Invalid format.',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'bad_request'>>>(true)
-    })
-
-    it('creates a bad request problem response envelope with options object', () => {
-        const result = badRequest({
-            message: 'Malformed payload.',
-            headers: { 'x-request-id': 'req_123' },
-        })
-
-        expect(result.status).toBe(HttpStatus.BAD_REQUEST)
-        expect(result.headers.get('x-request-id')).toBe('req_123')
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'bad_request',
-                message: 'Malformed payload.',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'bad_request'>>>(true)
-    })
-
-    it('uses default message when none provided', () => {
-        const result = badRequest()
-
-        expect(result.status).toBe(HttpStatus.BAD_REQUEST)
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'bad_request',
-                message: 'Bad request',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'bad_request'>>>(true)
-    })
-})
-
-describe(conflict.name, () => {
-    it('creates a conflict problem response envelope with string message', () => {
-        const result = conflict('Already exists.', {
-            headers: { 'x-request-id': 'req_123' },
-        })
-
-        expect(result.status).toBe(HttpStatus.CONFLICT)
-        expect(result.headers.get('x-request-id')).toBe('req_123')
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'conflict',
-                message: 'Already exists.',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'conflict'>>>(true)
-    })
-
-    it('creates a conflict problem response envelope with options object', () => {
-        const result = conflict({
-            message: 'User already exists.',
-            headers: { 'x-request-id': 'req_123' },
-        })
-
-        expect(result.status).toBe(HttpStatus.CONFLICT)
-        expect(result.headers.get('x-request-id')).toBe('req_123')
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'conflict',
-                message: 'User already exists.',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'conflict'>>>(true)
-    })
-
-    it('uses default message when none provided', () => {
-        const result = conflict()
-
-        expect(result.status).toBe(HttpStatus.CONFLICT)
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'conflict',
-                message: 'Conflict',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'conflict'>>>(true)
-    })
-})
-
-describe(rateLimited.name, () => {
-    it('creates a rate limited problem response envelope with string message', () => {
-        const result = rateLimited('Too many requests.', {
-            headers: { 'x-request-id': 'req_123' },
-        })
-
-        expect(result.status).toBe(HttpStatus.TOO_MANY_REQUESTS)
-        expect(result.headers.get('x-request-id')).toBe('req_123')
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'rate_limited',
-                message: 'Too many requests.',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'rate_limited'>>>(true)
-    })
-
-    it('creates a rate limited problem response envelope with options object', () => {
-        const result = rateLimited({
-            message: 'Rate limit exceeded.',
-            headers: { 'x-request-id': 'req_123' },
-        })
-
-        expect(result.status).toBe(HttpStatus.TOO_MANY_REQUESTS)
-        expect(result.headers.get('x-request-id')).toBe('req_123')
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'rate_limited',
-                message: 'Rate limit exceeded.',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'rate_limited'>>>(true)
-    })
-
-    it('uses default message when none provided', () => {
-        const result = rateLimited()
-
-        expect(result.status).toBe(HttpStatus.TOO_MANY_REQUESTS)
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'rate_limited',
-                message: 'Rate limited',
-            },
-        })
-        expectType<TypeEqual<typeof result.body, ProblemResponse<'rate_limited'>>>(true)
-    })
-})
-
-describe(validationProblem.name, () => {
-    it('creates a validation problem response envelope', () => {
-        const result = validationProblem([
-            {
-                code: 'required',
-                message: 'Email is required',
-                path: ['body', 'email'],
-            },
-        ])
-
-        expect(result.status).toBe(HttpStatus.BAD_REQUEST)
-        expect(result.body).toEqual({
-            success: false,
-            error: {
-                code: 'validation_failed',
-                message: 'Validation failed',
-            },
-            issues: [
-                {
-                    code: 'required',
-                    message: 'Email is required',
-                    path: ['body', 'email'],
-                },
-            ],
-        })
-    })
-})
-
-describe(problemIssueSchema.name, () => {
-    it('builds a reusable issue schema with typed codes', () => {
-        const schema = problemIssueSchema(v.picklist(['required', 'invalid_type']))
-        const parsed = v.parse(schema, {
-            code: 'required',
-            message: 'Email is required',
-            path: ['body', 'email'],
-            expected: 'string',
-            received: 'undefined',
-        })
-
-        expect(parsed).toEqual({
-            code: 'required',
-            message: 'Email is required',
-            path: ['body', 'email'],
-            expected: 'string',
-            received: 'undefined',
-        })
-        expectType<
-            TypeEqual<
-                typeof parsed,
-                {
-                    code: 'required' | 'invalid_type'
-                    message: string
-                    path?: readonly (string | number)[] | undefined
-                    expected?: string | undefined
-                    received?: string | undefined
-                }
-            >
-        >(true)
-    })
-})
-
-describe(okSchema.name, () => {
-    it('builds a reusable success response schema', () => {
-        const schema = okSchema(v.object({ id: v.string() }), v.object({ requestId: v.string() }))
-        const parsed = v.parse(schema, {
-            success: true,
-            data: { id: 'user_123' },
-            meta: { requestId: 'req_123' },
-        })
-
-        expect(parsed).toEqual({
-            success: true,
-            data: { id: 'user_123' },
-            meta: { requestId: 'req_123' },
-        })
-        expectType<
-            TypeEqual<
-                typeof parsed,
-                {
-                    success: true
-                    data: { id: string }
-                    meta?: { requestId: string } | undefined
-                }
-            >
-        >(true)
-    })
-})
-
-describe(standardResponseSchema.name, () => {
-    it('builds a reusable standard response union schema', () => {
-        const schema = standardResponseSchema(v.object({ id: v.string() }), {
-            code: v.picklist(['not_found', 'validation_failed']),
-        })
-
-        expect(v.parse(schema, { success: true, data: { id: 'user_123' } })).toEqual({
-            success: true,
-            data: { id: 'user_123' },
-        })
-        expect(
-            v.parse(schema, {
-                success: false,
-                error: {
-                    code: 'not_found',
-                    message: 'User not found',
-                },
-            }),
-        ).toEqual({
-            success: false,
-            error: {
-                code: 'not_found',
-                message: 'User not found',
-            },
-        })
-    })
-})
-
-describe(issueFromValibotIssue.name, () => {
-    it('converts Valibot issues to standard response issues', () => {
-        const parsed = v.safeParse(v.object({ email: v.string() }), { email: 123 })
-        if (parsed.success) throw new Error('Expected parsing to fail')
-
-        const issue = issueFromValibotIssue(parsed.issues[0])
-
-        expect(issue).toMatchObject({
-            code: 'string',
-            path: ['email'],
-            expected: 'string',
-        })
-        expect(typeof issue.message).toBe('string')
-        expect(typeof issue.received).toBe('string')
-    })
-})
-
-describe(issuesFromValibotIssues.name, () => {
-    it('converts Valibot issue lists to standard response issues', () => {
-        const parsed = v.safeParse(v.object({ user: v.object({ email: v.string() }) }), {
-            user: { email: 123 },
-        })
-        if (parsed.success) throw new Error('Expected parsing to fail')
-
-        const issues = issuesFromValibotIssues(parsed.issues)
-
-        expect(issues).toHaveLength(1)
-        expect(issues[0]).toMatchObject({
-            code: 'string',
-            path: ['user', 'email'],
-            expected: 'string',
-        })
-    })
-})
-
-describe(validationProblemFromValibotIssues.name, () => {
-    it('creates validation problem responses from Valibot issues', () => {
-        const parsed = v.safeParse(v.object({ email: v.string() }), { email: 123 })
-        if (parsed.success) throw new Error('Expected parsing to fail')
-
-        const result = validationProblemFromValibotIssues(parsed.issues)
-
-        expect(result.status).toBe(HttpStatus.BAD_REQUEST)
-        expect(result.body.error.code).toBe('validation_failed')
-        expect(result.body.issues?.[0]).toMatchObject({
-            code: 'string',
-            path: ['email'],
-        })
-    })
-})
-
-describe(problemValidationErrorHandler.name, () => {
-    it('returns 422 and validation_failed:body for REQUEST_BODY component', () => {
-        const issues: [v.BaseIssue<unknown>, ...v.BaseIssue<unknown>[]] = [
-            {
-                kind: 'schema',
-                type: 'string',
-                input: 123,
-                expected: 'string',
-                received: 'number',
-                message: 'Expected a string',
-            },
-        ]
-        const result = problemValidationErrorHandler(0, issues) // ValibotValidationError.REQUEST_BODY = 0
-
-        expect(result.status).toBe(HttpStatus.UNPROCESSABLE_ENTITY)
-        expect(result.body.error.code).toBe('validation_failed:body')
-    })
-
-    it('returns 400 and validation_failed:query for QUERY_PARAMETERS component', () => {
-        const issues: [v.BaseIssue<unknown>, ...v.BaseIssue<unknown>[]] = [
-            {
-                kind: 'schema',
-                type: 'string',
-                input: 123,
-                expected: 'string',
-                received: 'number',
-                message: 'Expected a string',
-            },
-        ]
-        const result = problemValidationErrorHandler(2, issues) // ValibotValidationError.QUERY_PARAMETERS = 2
-
-        expect(result.status).toBe(HttpStatus.BAD_REQUEST)
-        expect(result.body.error.code).toBe('validation_failed:query')
-    })
-})
-
-describe(createValibotRouteBuilder.name, () => {
-    it('creates a builder that automatically includes problem error schemas for 400 and 422', () => {
-        const builder = createValibotRouteBuilder()
-        const routeOptions = builder({
-            schema: {
-                request: {
-                    body: v.object({ title: v.string() }),
-                },
-            },
-            handler: () => ({ success: true }),
-        })
-
-        const router = new Router().get('/example', routeOptions)
-        const bodySchemas = router.getRoutes()[0]!.schema!.response!.body!
-        expect(bodySchemas).toBeDefined()
-        expect(bodySchemas[400]).toBeDefined()
-        expect(bodySchemas[422]).toBeDefined()
-
-        const schema400 = bodySchemas[400] as Record<string, unknown>
-        const schema422 = bodySchemas[422] as Record<string, unknown>
-
-        // 400 schema has anyOf representing query and path validation error types
-        expect(schema400.anyOf).toBeDefined()
-        // 422 schema has body validation error type
-        const errorSchema = (schema422.properties as Record<string, unknown>)?.error as Record<
-            string,
-            unknown
-        >
-        const codeSchema = (errorSchema?.properties as Record<string, unknown>)?.code as Record<
-            string,
-            unknown
-        >
-        expect(codeSchema?.const).toBe('validation_failed:body')
-    })
-
-    it('merges overlapping custom response schemas correctly with v.union', () => {
-        const builder = createValibotRouteBuilder()
-        const routeOptions = builder({
-            schema: {
-                response: {
-                    body: {
-                        422: problemSchema({ code: v.literal('custom_business_error') }),
-                    },
-                },
-            },
-            handler: () => ({ success: true }),
-        })
-
-        const router = new Router().get('/example', routeOptions)
-        const bodySchemas = router.getRoutes()[0]!.schema!.response!.body!
-        expect(bodySchemas).toBeDefined()
-        expect(bodySchemas[422]).toBeDefined()
-        const schema422 = bodySchemas[422] as Record<string, unknown>
-        // Merged schema for 422 status code should have anyOf with both error types
-        expect(schema422.anyOf).toBeDefined()
-        const anyOf = schema422.anyOf as Record<string, unknown>[]
-        expect(anyOf).toHaveLength(2)
-        const codes = anyOf.map((s) => {
-            const err = (s.properties as Record<string, unknown>)?.error as Record<string, unknown>
-            const code = (err?.properties as Record<string, unknown>)?.code as Record<
-                string,
-                unknown
-            >
-            return code?.const
-        })
-        expect(codes).toContain('validation_failed:body')
-        expect(codes).toContain('custom_business_error')
-    })
-})