@mpen/routekit 0.1.0 → 0.1.1

package/src/router/routes/valibot.test.ts

@@ -1,286 +0,0 @@
-#!/usr/bin/env -S bun test
-import { describe, expect, it } from 'bun:test'
-import { HttpMethod, HttpStatus } from '@mpen/http'
-import { expectType, type TypeEqual } from '@mpen/ts-types'
-import * as v from 'valibot'
-import { Router } from '../router'
-import { response as routekitResponse } from '../response'
-import { ok } from '../response/formats/status'
-import {
-    createValibotRouteBuilder,
-    defineValibotMiddleware,
-    valibotSchemaMiddleware,
-} from './valibot'
-import type { DeclaredMiddleware } from '../middleware/define'
-import type { ContextMiddleware } from '../types'
-
-function typeTest(callback: () => void) {
-    void callback
-}
-
-describe(defineValibotMiddleware.name, () => {
-    it('validates originated terminal responses and contributes their metadata', async () => {
-        const requireAuth = defineValibotMiddleware({
-            responses: {
-                [HttpStatus.UNAUTHORIZED]: v.object({
-                    code: v.literal('unauthorized'),
-                }),
-            },
-            run: (_ctx, { respond }) =>
-                respond(
-                    routekitResponse({ code: 'unauthorized' }, { status: HttpStatus.UNAUTHORIZED }),
-                ),
-        })
-        const router = new Router().use(requireAuth)
-        router.get('/private', () => new Response('hidden'))
-
-        const response = await router.fetch(new Request('https://example.com/private'))
-
-        expect(response.status).toBe(HttpStatus.UNAUTHORIZED)
-        expect(await response.json()).toEqual({ code: 'unauthorized' })
-        expect(
-            router.getRoutes()[0]?.schema?.response?.body?.[HttpStatus.UNAUTHORIZED],
-        ).toBeDefined()
-    })
-
-    it('rejects an invalid locally originated body at runtime', async () => {
-        const invalid = defineValibotMiddleware({
-            responses: {
-                [HttpStatus.UNAUTHORIZED]: v.object({ code: v.literal('unauthorized') }),
-            },
-            run: (_ctx, { respond }) =>
-                respond(
-                    routekitResponse(
-                        { code: 'invalid' },
-                        { status: HttpStatus.UNAUTHORIZED },
-                    ) as never,
-                ),
-        })
-        const router = new Router().use(invalid)
-        router.get('/private', () => new Response('hidden'))
-
-        const response = await router.fetch(new Request('https://example.com/private'))
-
-        expect(response.status).toBe(HttpStatus.INTERNAL_SERVER_ERROR)
-    })
-
-    it('types respond by each declared status and inferred body', () => {
-        const middleware = defineValibotMiddleware({
-            responses: {
-                [HttpStatus.UNAUTHORIZED]: v.object({ code: v.literal('unauthorized') }),
-            },
-            run: (_ctx, { respond }) => {
-                respond(
-                    routekitResponse({ code: 'unauthorized' }, { status: HttpStatus.UNAUTHORIZED }),
-                )
-                respond(
-                    // @ts-expect-error The declared 401 body requires code "unauthorized".
-                    routekitResponse({ code: 'different' }, { status: HttpStatus.UNAUTHORIZED }),
-                )
-                respond(
-                    // @ts-expect-error The middleware does not declare 403.
-                    routekitResponse({ code: 'unauthorized' }, { status: HttpStatus.FORBIDDEN }),
-                )
-            },
-        })
-
-        expect(middleware).toBeDefined()
-    })
-
-    it('infers responses after middleware context types are fixed', () => {
-        const middleware: DeclaredMiddleware<{ auth: string }, { services: string }> =
-            defineValibotMiddleware({
-                responses: {
-                    [HttpStatus.UNAUTHORIZED]: v.object({ code: v.literal('unauthorized') }),
-                },
-                run: (ctx, { respond }) => {
-                    expectType<TypeEqual<typeof ctx.auth, string>>(true)
-                    expectType<TypeEqual<typeof ctx.services, string>>(true)
-                    respond(
-                        routekitResponse(
-                            { code: 'unauthorized' },
-                            { status: HttpStatus.UNAUTHORIZED },
-                        ),
-                    )
-                    respond(
-                        // @ts-expect-error Contextual typing still permits inferred response bodies.
-                        routekitResponse(
-                            { code: 'different' },
-                            { status: HttpStatus.UNAUTHORIZED },
-                        ),
-                    )
-                },
-            })
-
-        expect(middleware).toBeDefined()
-    })
-})
-
-describe(valibotSchemaMiddleware.name, () => {
-    it('parses downstream context, declares schemas, and validates responses', async () => {
-        const boundary = valibotSchemaMiddleware({
-            schema: {
-                request: {
-                    path: v.object({
-                        id: v.pipe(v.string(), v.transform(Number), v.integer()),
-                    }),
-                },
-                response: {
-                    body: {
-                        [HttpStatus.OK]: v.object({ id: v.number() }),
-                    },
-                },
-            },
-            validateResponse: true,
-        })
-        const router = new Router()
-        router.get('/items/:id', {
-            middleware: boundary,
-            handler: ({ path }) => {
-                expectType<{ id: number }>(path)
-                return ok({ id: path.id })
-            },
-        })
-
-        const response = await router.fetch(new Request('https://example.com/items/4'))
-        const invalid = await router.fetch(new Request('https://example.com/items/nope'))
-
-        expect(await response.json()).toEqual({ id: 4 })
-        expect(invalid.status).toBe(HttpStatus.BAD_REQUEST)
-        expect(router.getRoutes()[0]?.schema?.request?.path).toBeDefined()
-        expect(router.getRoutes()[0]?.schema?.response?.body?.[HttpStatus.OK]).toBeDefined()
-    })
-
-    it('validates a custom declared request-validation response', async () => {
-        const boundary = valibotSchemaMiddleware({
-            schema: {
-                request: { path: v.object({ id: v.pipe(v.string(), v.uuid()) }) },
-            },
-            validationResponses: {
-                [HttpStatus.UNPROCESSABLE_ENTITY]: v.object({ invalid: v.literal(true) }),
-            },
-            onRequestValidationError: () =>
-                routekitResponse({ invalid: true }, { status: HttpStatus.UNPROCESSABLE_ENTITY }),
-        })
-        const router = new Router()
-        router.get('/items/:id', { middleware: boundary, handler: () => new Response('ok') })
-
-        const response = await router.fetch(new Request('https://example.com/items/nope'))
-
-        expect(response.status).toBe(HttpStatus.UNPROCESSABLE_ENTITY)
-        expect(await response.json()).toEqual({ invalid: true })
-    })
-
-    it('requires custom request-validation callbacks to match declared responses', () => {
-        typeTest(() => {
-            valibotSchemaMiddleware({
-                onRequestValidationError: () =>
-                    // @ts-expect-error Custom validation responses require response schema declarations.
-                    routekitResponse('bad input', { status: HttpStatus.BAD_REQUEST }),
-            })
-
-            valibotSchemaMiddleware({
-                validationResponses: {
-                    [HttpStatus.BAD_REQUEST]: v.object({ invalid: v.literal(true) }),
-                },
-                onRequestValidationError: () =>
-                    // @ts-expect-error The declared response requires invalid: true.
-                    routekitResponse({ invalid: false }, { status: HttpStatus.BAD_REQUEST }),
-            })
-        })
-    })
-})
-
-describe(createValibotRouteBuilder.name, () => {
-    it('attaches one merged boundary and inherits declared middleware responses', async () => {
-        const auth = defineValibotMiddleware({
-            responses: {
-                [HttpStatus.UNAUTHORIZED]: v.object({ code: v.literal('unauthorized') }),
-            },
-            async run(_ctx, { next, forward }) {
-                return forward(await next())
-            },
-        })
-        const route = createValibotRouteBuilder({ middleware: [auth] })
-        const router = new Router()
-        router.get(
-            '/todo/:id',
-            route({
-                schema: {
-                    request: { path: v.object({ id: v.string() }) },
-                    response: { body: { [HttpStatus.OK]: v.object({ id: v.string() }) } },
-                },
-                handler: ({ path }) => ok({ id: path.id }),
-            }),
-        )
-
-        const response = await router.fetch(new Request('https://example.com/todo/one'))
-        const schemas = router.getRoutes()[0]?.schema?.response?.body
-
-        expect(await response.json()).toEqual({ id: 'one' })
-        expect(schemas?.[HttpStatus.UNAUTHORIZED]).toBeDefined()
-        expect(schemas?.[HttpStatus.OK]).toBeDefined()
-    })
-
-    it('requires declared custom validation responses and allows response overrides', async () => {
-        const route = createValibotRouteBuilder({
-            validateResponse: false,
-            validationResponses: {
-                [HttpStatus.UNPROCESSABLE_ENTITY]: v.string(),
-            },
-            onRequestValidationError: () =>
-                routekitResponse('bad input', { status: HttpStatus.UNPROCESSABLE_ENTITY }),
-        })
-        const router = new Router()
-        router.get(
-            '/items/:id',
-            route({
-                schema: {
-                    request: { path: v.object({ id: v.pipe(v.string(), v.uuid()) }) },
-                },
-                handler: () => new Response('ok'),
-            }),
-        )
-
-        const response = await router.fetch(new Request('https://example.com/items/not-a-uuid'))
-
-        expect(response.status).toBe(HttpStatus.UNPROCESSABLE_ENTITY)
-        expect(await response.json()).toBe('bad input')
-    })
-
-    it('builds full routes and preserves path/context typing', () => {
-        interface ServicesContext {
-            service: string
-        }
-        const inject: ContextMiddleware<ServicesContext> = (ctx) => {
-            ctx.service = 'svc'
-        }
-        const route = createValibotRouteBuilder({ middleware: [inject] })
-
-        typeTest(() => {
-            const options = route({
-                schema: { request: { path: v.object({ id: v.string() }) } },
-                handler: ({ path, service }) => {
-                    expectType<TypeEqual<typeof path, { id: string }>>(true)
-                    expectType<string>(service)
-                    return ok({ id: path.id })
-                },
-            })
-            void options
-
-            const fullRoute = route({
-                path: '/typed/:id',
-                method: HttpMethod.GET,
-                schema: { request: { path: v.object({ id: v.string() }) } },
-                handler: ({ path }) => ok({ id: path.id }),
-            })
-            void fullRoute
-
-            // @ts-expect-error A builder custom validation callback must declare its responses.
-            createValibotRouteBuilder({
-                onRequestValidationError: () =>
-                    routekitResponse('bad input', { status: HttpStatus.BAD_REQUEST }),
-            })
-        })
-    })
-})

package/src/router/routes/zod/index.ts

@@ -1,18 +0,0 @@
-export {
-    createZodRouteBuilder,
-    defineZodMiddleware,
-    zodSchemaMiddleware,
-    ValidationError,
-} from './zod'
-export type {
-    DefineZodMiddlewareOptions,
-    ValidationErrorHandler,
-    ZodRouteBuilder,
-    ZodHandlerContext,
-    ZodHandlerParams,
-    ZodRouteHelperDefaults,
-    ZodRouteHandler,
-    ZodRouteSchemaInput,
-    ZodValidationErrorBody,
-    ZodSchemaMiddlewareOptions,
-} from './zod'