@mpen/routekit 0.1.0 → 0.1.1

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

@@ -1,280 +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 { z } from 'zod'
-import { Router } from '../router'
-import { response as routekitResponse } from '../response'
-import { ok } from '../response/formats/status'
-import { createZodRouteBuilder, defineZodMiddleware, zodSchemaMiddleware } from './zod'
-import type { DeclaredMiddleware } from '../middleware/define'
-import type { ContextMiddleware } from '../types'
-
-function typeTest(callback: () => void) {
-    void callback
-}
-
-describe(defineZodMiddleware.name, () => {
-    it('validates originated terminal responses and contributes their metadata', async () => {
-        const requireAuth = defineZodMiddleware({
-            responses: {
-                [HttpStatus.UNAUTHORIZED]: z.object({
-                    code: z.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 = defineZodMiddleware({
-            responses: {
-                [HttpStatus.UNAUTHORIZED]: z.object({ code: z.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 = defineZodMiddleware({
-            responses: {
-                [HttpStatus.UNAUTHORIZED]: z.object({ code: z.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 }> =
-            defineZodMiddleware({
-                responses: {
-                    [HttpStatus.UNAUTHORIZED]: z.object({ code: z.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(zodSchemaMiddleware.name, () => {
-    it('parses downstream context, declares schemas, and validates responses', async () => {
-        const boundary = zodSchemaMiddleware({
-            schema: {
-                request: {
-                    path: z.object({ id: z.coerce.number().int() }),
-                },
-                response: {
-                    body: {
-                        [HttpStatus.OK]: z.object({ id: z.number().int() }),
-                    },
-                },
-            },
-            validateResponse: true,
-        })
-        const router = new Router()
-        router.get('/items/:id', {
-            middleware: boundary,
-            handler: ({ params }) => {
-                expectType<{ id: number }>(params.path)
-                return ok({ id: params.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 = zodSchemaMiddleware({
-            schema: {
-                request: { path: z.object({ id: z.string().uuid() }) },
-            },
-            validationResponses: {
-                [HttpStatus.UNPROCESSABLE_ENTITY]: z.object({ invalid: z.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(() => {
-            zodSchemaMiddleware({
-                onRequestValidationError: () =>
-                    // @ts-expect-error Custom validation responses require response schema declarations.
-                    routekitResponse('bad input', { status: HttpStatus.BAD_REQUEST }),
-            })
-
-            zodSchemaMiddleware({
-                validationResponses: {
-                    [HttpStatus.BAD_REQUEST]: z.object({ invalid: z.literal(true) }),
-                },
-                onRequestValidationError: () =>
-                    // @ts-expect-error The declared response requires invalid: true.
-                    routekitResponse({ invalid: false }, { status: HttpStatus.BAD_REQUEST }),
-            })
-        })
-    })
-})
-
-describe(createZodRouteBuilder.name, () => {
-    it('attaches one merged boundary and inherits declared middleware responses', async () => {
-        const auth = defineZodMiddleware({
-            responses: {
-                [HttpStatus.UNAUTHORIZED]: z.object({ code: z.literal('unauthorized') }),
-            },
-            async run(_ctx, { next, forward }) {
-                return forward(await next())
-            },
-        })
-        const route = createZodRouteBuilder({ middleware: [auth] })
-        const router = new Router()
-        router.get(
-            '/todo/:id',
-            route({
-                schema: {
-                    request: { path: z.object({ id: z.string() }) },
-                    response: { body: { [HttpStatus.OK]: z.object({ id: z.string() }) } },
-                },
-                handler: ({ params }) => ok({ id: params.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 = createZodRouteBuilder({
-            validateResponse: false,
-            validationResponses: {
-                [HttpStatus.UNPROCESSABLE_ENTITY]: z.string(),
-            },
-            onRequestValidationError: () =>
-                routekitResponse('bad input', { status: HttpStatus.UNPROCESSABLE_ENTITY }),
-        })
-        const router = new Router()
-        router.get(
-            '/items/:id',
-            route({
-                schema: {
-                    request: { path: z.object({ id: z.string().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 = createZodRouteBuilder({ middleware: [inject] })
-
-        typeTest(() => {
-            const options = route({
-                schema: { request: { path: z.object({ id: z.string() }) } },
-                handler: ({ params, service }) => {
-                    expectType<TypeEqual<typeof params.path, { id: string }>>(true)
-                    expectType<string>(service)
-                    return ok({ id: params.path.id })
-                },
-            })
-            void options
-
-            const fullRoute = route({
-                path: '/typed/:id',
-                method: HttpMethod.GET,
-                schema: { request: { path: z.object({ id: z.string() }) } },
-                handler: ({ params }) => ok({ id: params.path.id }),
-            })
-            void fullRoute
-
-            // @ts-expect-error A builder custom validation callback must declare its responses.
-            createZodRouteBuilder({
-                onRequestValidationError: () =>
-                    routekitResponse('bad input', { status: HttpStatus.BAD_REQUEST }),
-            })
-        })
-    })
-})

package/src/router/server-interface.ts

@@ -1,31 +0,0 @@
-// export type UniversalFetchResult = Response | Promise<Response>
-//
-// export interface UniversalExecutionContext {
-//     waitUntil(promise: Promise<any>): void
-//     passThroughOnException?(): void
-// }
-//
-// export type DenoServer = {
-//     fetch(request: Request): UniversalFetchResult
-// }
-//
-// export type BunServer = {
-//     // eslint-disable-next-line @typescript-eslint/consistent-type-imports
-//     fetch(request: Request, server: import('bun').Server<unknown>): UniversalFetchResult
-// }
-//
-// export type CloudflareWorkerServer<Env = unknown, Ctx = UniversalExecutionContext> = {
-//     fetch(request: Request, env: Env, ctx: Ctx): UniversalFetchResult
-// }
-//
-// export type ValTownRequestHandler = (request: Request) => UniversalFetchResult
-//
-// export type UniversalServerInterface<Env = unknown, Ctx = UniversalExecutionContext> =
-//     | DenoServer
-//     | BunServer
-//     | CloudflareWorkerServer<Env, Ctx>
-//     | ValTownRequestHandler
-
-export interface SimpleServerInterface {
-    fetch(request: Request): Promise<Response>
-}