weifuwu 0.1.0

package/test/unode.test.ts

@@ -0,0 +1,401 @@
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import { WebSocket } from 'ws'
+import { serve, Router, type Handler, type Server } from '../index.ts'
+
+async function createTestServer(handler: Handler): Promise<{ server: Server; url: string }> {
+  const server = serve(handler, { port: 0 })
+  await server.ready
+  return { server, url: `http://localhost:${server.port}` }
+}
+
+// ── serve ────────────────────────────────────────────────────────────────────
+
+describe('serve', () => {
+  it('handles GET request', async () => {
+    const { server, url } = await createTestServer(() => new Response('hello'))
+    const res = await fetch(url)
+    assert.equal(res.status, 200)
+    assert.equal(await res.text(), 'hello')
+    server.stop()
+  })
+
+  it('handles POST with body echo', async () => {
+    const { server, url } = await createTestServer(async (req) => {
+      const body = await req.text()
+      return new Response(body, { status: 201 })
+    })
+    const res = await fetch(url, { method: 'POST', body: 'test data' })
+    assert.equal(res.status, 201)
+    assert.equal(await res.text(), 'test data')
+    server.stop()
+  })
+
+  it('passes response headers through', async () => {
+    const { server, url } = await createTestServer(() =>
+      new Response('ok', { headers: { 'x-custom': 'value', 'content-type': 'text/plain' } }),
+    )
+    const res = await fetch(url)
+    assert.equal(res.headers.get('x-custom'), 'value')
+    assert.equal(res.headers.get('content-type'), 'text/plain')
+    server.stop()
+  })
+
+  it('provides ctx.query from URL', async () => {
+    const { server, url } = await createTestServer((req, ctx) =>
+      Response.json(ctx.query),
+    )
+    const res = await fetch(`${url}?foo=bar&baz=qux`)
+    const data = await res.json() as Record<string, string>
+    assert.equal(data.foo, 'bar')
+    assert.equal(data.baz, 'qux')
+    server.stop()
+  })
+
+  it('returns 500 on handler error', async () => {
+    const { server, url } = await createTestServer(() => {
+      throw new Error('boom')
+    })
+    const res = await fetch(url)
+    assert.equal(res.status, 500)
+    assert.match(await res.text(), /Internal Server Error/)
+    server.stop()
+  })
+
+  it('server.stop() closes the server', async () => {
+    const server = serve(() => new Response('ok'), { port: 0 })
+    await server.ready
+    const port = server.port
+    server.stop()
+    await assert.rejects(() => fetch(`http://localhost:${port}`))
+  })
+
+  it('AbortSignal prevents server from starting', async () => {
+    const ac = new AbortController()
+    ac.abort()
+    const server = serve(() => new Response('ok'), { port: 0, signal: ac.signal })
+    await server.ready
+    assert.equal(server.port, 0)
+    server.stop()
+  })
+})
+
+// ── Router ────────────────────────────────────────────────────────────────────
+
+describe('Router', () => {
+  it('matches GET route', async () => {
+    const r = new Router().get('/hello', () => new Response('world'))
+    const res = await r.handler()(new Request('http://localhost/hello'), { params: {}, query: {} })
+    assert.equal(res.status, 200)
+    assert.equal(await res.text(), 'world')
+  })
+
+  it('matches POST route', async () => {
+    const r = new Router().post('/data', async (req) => {
+      const body = await req.text()
+      return new Response(body, { status: 201 })
+    })
+    const res = await r.handler()(new Request('http://localhost/data', { method: 'POST', body: 'hello' }), { params: {}, query: {} })
+    assert.equal(res.status, 201)
+    assert.equal(await res.text(), 'hello')
+  })
+
+  it('provides ctx.params', async () => {
+    const r = new Router().get('/users/:id', (req, ctx) =>
+      Response.json({ id: ctx.params.id }),
+    )
+    const res = await r.handler()(new Request('http://localhost/users/42'), { params: {}, query: {} })
+    const data = await res.json() as Record<string, string>
+    assert.equal(data.id, '42')
+  })
+
+  it('multiple params', async () => {
+    const r = new Router().get('/:a/:b', (req, ctx) =>
+      Response.json({ a: ctx.params.a, b: ctx.params.b }),
+    )
+    const res = await r.handler()(new Request('http://localhost/foo/bar'), { params: {}, query: {} })
+    const data = await res.json() as Record<string, string>
+    assert.equal(data.a, 'foo')
+    assert.equal(data.b, 'bar')
+  })
+
+  it('static route wins over param route', async () => {
+    const r = new Router()
+      .get('/users/me', () => new Response('me'))
+      .get('/users/:id', (req, ctx) => new Response(ctx.params.id))
+    const res1 = await r.handler()(new Request('http://localhost/users/me'), { params: {}, query: {} })
+    assert.equal(await res1.text(), 'me')
+    const res2 = await r.handler()(new Request('http://localhost/users/42'), { params: {}, query: {} })
+    assert.equal(await res2.text(), '42')
+  })
+
+  it('wildcard matches remaining path', async () => {
+    const r = new Router().all('/api/*', (req, ctx) =>
+      Response.json({ wildcard: ctx.params['*'] }),
+    )
+    const res = await r.handler()(new Request('http://localhost/api/foo/bar'), { params: {}, query: {} })
+    const data = await res.json() as Record<string, string>
+    assert.equal(data.wildcard, 'foo/bar')
+  })
+
+  it('returns 404 for unmatched route', async () => {
+    const r = new Router().get('/exists', () => new Response('ok'))
+    const res = await r.handler()(new Request('http://localhost/nonexistent'), { params: {}, query: {} })
+    assert.equal(res.status, 404)
+  })
+
+  it('all() matches any method', async () => {
+    const r = new Router().all('/any', () => new Response('ok'))
+    for (const method of ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS']) {
+      const res = await r.handler()(new Request('http://localhost/any', { method }), { params: {}, query: {} })
+      assert.equal(res.status, 200)
+    }
+  })
+
+  it('sub-router mounting', async () => {
+    const sub = new Router().get('/nested', () => new Response('sub'))
+    const main = new Router().use('/api', sub)
+    const res = await main.handler()(new Request('http://localhost/api/nested'), { params: {}, query: {} })
+    assert.equal(await res.text(), 'sub')
+  })
+
+  it('sub-router preserves params', async () => {
+    const sub = new Router().get('/:userId', (req, ctx) =>
+      Response.json({ userId: ctx.params.userId }),
+    )
+    const main = new Router().use('/orgs/:orgId', sub)
+    const res = await main.handler()(new Request('http://localhost/orgs/acme/john'), { params: {}, query: {} })
+    const data = await res.json() as Record<string, string>
+    assert.equal(data.userId, 'john')
+  })
+
+  it('middleware order: global → path → route', async () => {
+    const order: number[] = []
+    const r = new Router()
+      .use((_req, _ctx, next) => { order.push(1); return next(_req, _ctx) })
+      .use('/scoped', (_req, _ctx, next) => { order.push(2); return next(_req, _ctx) })
+      .get('/scoped/route',
+        (_req, _ctx, next) => { order.push(3); return next(_req, _ctx) },
+        () => { order.push(4); return Response.json(order) },
+      )
+    await r.handler()(new Request('http://localhost/scoped/route'), { params: {}, query: {} })
+    assert.deepEqual(order, [1, 2, 3, 4])
+  })
+
+  it('middleware short-circuits', async () => {
+    const r = new Router()
+      .use(() => new Response('blocked', { status: 403 }))
+      .get('/blocked', () => new Response('should not reach'))
+    const res = await r.handler()(new Request('http://localhost/blocked'), { params: {}, query: {} })
+    assert.equal(res.status, 403)
+    assert.equal(await res.text(), 'blocked')
+  })
+
+  it('middleware modifies response after next', async () => {
+    const r = new Router()
+      .use(async (_req, _ctx, next) => {
+        const res = await next(_req, _ctx)
+        const body = await res.json() as Record<string, unknown>
+        body.modified = true
+        return Response.json(body)
+      })
+      .get('/modify', () => Response.json({ original: true }))
+    const res = await r.handler()(new Request('http://localhost/modify'), { params: {}, query: {} })
+    const data = await res.json() as Record<string, unknown>
+    assert.equal(data.original, true)
+    assert.equal(data.modified, true)
+  })
+
+  it('onError catches handler exceptions', async () => {
+    const r = new Router()
+      .onError((err) => Response.json({ error: err.message }, { status: 500 }))
+      .get('/crash', () => { throw new Error('oops') })
+    const res = await r.handler()(new Request('http://localhost/crash'), { params: {}, query: {} })
+    assert.equal(res.status, 500)
+    const data = await res.json() as Record<string, string>
+    assert.equal(data.error, 'oops')
+  })
+
+  it('root path / matches', async () => {
+    const r = new Router().get('/', () => new Response('root'))
+    const res = await r.handler()(new Request('http://localhost/'), { params: {}, query: {} })
+    assert.equal(await res.text(), 'root')
+  })
+
+  it('same param name on same path position works', async () => {
+    const r = new Router()
+      .get('/:id', () => new Response('a'))
+      .get('/:id/profile', () => new Response('b'))
+    assert.equal(await (await r.handler()(new Request('http://localhost/foo'), { params: {}, query: {} })).text(), 'a')
+    assert.equal(await (await r.handler()(new Request('http://localhost/foo/profile'), { params: {}, query: {} })).text(), 'b')
+  })
+
+  it('different param names on same path position throw', () => {
+    const r = new Router()
+    r.get('/:id', () => new Response('ok'))
+    assert.throws(() => r.get('/:slug', () => new Response('ng')), /Param name conflict/)
+  })
+
+  it('multiple methods on same path', async () => {
+    const r = new Router()
+      .get('/resource', () => Response.json({ method: 'GET' }))
+      .post('/resource', () => Response.json({ method: 'POST' }))
+      .put('/resource', () => Response.json({ method: 'PUT' }))
+      .delete('/resource', () => Response.json({ method: 'DELETE' }))
+
+    const h = r.handler()
+    const tests = ['GET', 'POST', 'PUT', 'DELETE'] as const
+    for (const method of tests) {
+      const res = await h(new Request('http://localhost/resource', { method }), { params: {}, query: {} })
+      const data = await res.json() as Record<string, string>
+      assert.equal(data.method, method)
+    }
+  })
+
+  it('concurrent requests do not interfere', async () => {
+    const r = new Router().get('/echo/:val', (req, ctx) =>
+      Response.json({ val: ctx.params.val }),
+    )
+    const h = r.handler()
+    const results = await Promise.all(
+      Array.from({ length: 50 }, (_, i) =>
+        Promise.resolve(h(new Request(`http://localhost/echo/${i}`), { params: {}, query: {} })).then(r => r.json()) as Promise<Record<string, string>>,
+      ),
+    )
+    results.forEach((data, i) => {
+      assert.equal(data.val, String(i))
+    })
+  })
+})
+
+// ── Router.ws ────────────────────────────────────────────────────────────────
+
+describe('Router.ws', () => {
+  it('echos messages', async () => {
+    const router = new Router()
+      .ws('/echo', { message(ws, _ctx, data) { ws.send(`echo: ${data}`) } })
+
+    const server = serve(router.handler(), {
+      port: 0,
+      websocket: router.websocketHandler(),
+    })
+    await server.ready
+
+    const ws = new WebSocket(`ws://localhost:${server.port}/echo`)
+    const msg = await new Promise<string>((resolve, reject) => {
+      ws.on('open', () => ws.send('hello'))
+      ws.on('message', (data) => resolve(data.toString()))
+      ws.on('error', reject)
+      setTimeout(() => reject(new Error('timeout')), 3000)
+    })
+    assert.equal(msg, 'echo: hello')
+    ws.close()
+    server.stop()
+  })
+
+  it('passes params from URL', async () => {
+    const router = new Router()
+      .ws('/chat/:room', { open(ws, ctx) { ws.send(ctx.params.room!) } })
+
+    const server = serve(router.handler(), {
+      port: 0,
+      websocket: router.websocketHandler(),
+    })
+    await server.ready
+
+    const ws = new WebSocket(`ws://localhost:${server.port}/chat/lobby`)
+    const msg = await new Promise<string>((resolve, reject) => {
+      ws.on('message', (data) => resolve(data.toString()))
+      ws.on('error', reject)
+      setTimeout(() => reject(new Error('timeout')), 3000)
+    })
+    assert.equal(msg, 'lobby')
+    ws.close()
+    server.stop()
+  })
+
+  it('middleware can reject upgrade', async () => {
+    const router = new Router()
+      .ws('/secure',
+        (req, _ctx, next) => {
+          const auth = req.headers.get('Authorization')
+          if (!auth) return Response.json({ error: 'Unauthorized' }, { status: 401 })
+          return next(req, _ctx)
+        },
+        { open(ws) { ws.send('authorized') } },
+      )
+
+    const server = serve(router.handler(), {
+      port: 0,
+      websocket: router.websocketHandler(),
+    })
+    await server.ready
+
+    // Should be rejected (no auth header from Node.js built-in WebSocket)
+    const ws = new WebSocket(`ws://localhost:${server.port}/secure`)
+    const error = await new Promise<string | null>((resolve) => {
+      ws.on('error', () => resolve('error'))
+      ws.on('open', () => resolve(null))
+      ws.on('unexpected-response', () => resolve('unexpected-response'))
+      setTimeout(() => resolve('timeout'), 3000)
+    })
+    // Without auth, the middleware returns 401 and upgrade is rejected
+    assert.ok(error === 'unexpected-response' || error === 'error', `Expected rejection, got: ${error}`)
+    server.stop()
+  })
+})
+
+// ── Router.graphql ────────────────────────────────────────────────────────────
+
+describe('Router.graphql', () => {
+  it('handles GET query', async () => {
+    const r = new Router()
+      .graphql('/graphql', {
+        schema: `type Query { hello: String }`,
+        resolvers: { Query: { hello: () => 'world' } },
+      })
+
+    const { server, url } = await createTestServer(r.handler())
+    const res = await fetch(`${url}/graphql?query={hello}`)
+    assert.equal(res.status, 200)
+    const data = await res.json() as Record<string, unknown>
+    assert.deepEqual(data, { data: { hello: 'world' } })
+    server.stop()
+  })
+
+  it('handles POST query', async () => {
+    const r = new Router()
+      .graphql('/graphql', {
+        schema: `type Query { hello: String }`,
+        resolvers: { Query: { hello: () => 'world' } },
+      })
+
+    const { server, url } = await createTestServer(r.handler())
+    const res = await fetch(`${url}/graphql`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ query: '{ hello }' }),
+    })
+    assert.equal(res.status, 200)
+    const data = await res.json() as Record<string, unknown>
+    assert.deepEqual(data, { data: { hello: 'world' } })
+    server.stop()
+  })
+
+  it('returns GraphiQL HTML on GET without query', async () => {
+    const r = new Router()
+      .graphql('/graphql', {
+        schema: `type Query { hello: String }`,
+        resolvers: { Query: { hello: () => 'world' } },
+        graphiql: true,
+      })
+
+    const { server, url } = await createTestServer(r.handler())
+    const res = await fetch(`${url}/graphql`)
+    assert.equal(res.status, 200)
+    const text = await res.text()
+    assert.ok(text.includes('GraphiQL'))
+    assert.ok(text.includes('graphiql'))
+    server.stop()
+  })
+})

package/test/upload.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFile, rm, mkdir } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import { tmpdir } from 'node:os'
+import { Router } from '../router.ts'
+import { upload } from '../upload.ts'
+
+function createFormData(fields?: Record<string, string>, files?: Record<string, { name: string; data: string; type?: string }>): [Request, string] {
+  const boundary = '----boundary123'
+  const parts: string[] = []
+
+  for (const [key, value] of Object.entries(fields ?? {})) {
+    parts.push(`--${boundary}`)
+    parts.push(`Content-Disposition: form-data; name="${key}"`)
+    parts.push('')
+    parts.push(value)
+  }
+
+  for (const [key, file] of Object.entries(files ?? {})) {
+    parts.push(`--${boundary}`)
+    parts.push(`Content-Disposition: form-data; name="${key}"; filename="${file.name}"`)
+    if (file.type) parts.push(`Content-Type: ${file.type}`)
+    parts.push('')
+    parts.push(file.data)
+  }
+
+  parts.push(`--${boundary}--`)
+  const body = parts.join('\r\n')
+
+  const req = new Request('http://localhost/upload', {
+    method: 'POST',
+    headers: { 'Content-Type': `multipart/form-data; boundary=${boundary}` },
+    body,
+  })
+
+  return [req, boundary]
+}
+
+describe('upload', () => {
+  it('parses fields from multipart form', async () => {
+    const r = new Router()
+      .post('/upload', upload(), (req, ctx) => Response.json(ctx.parsed?.fields))
+
+    const [req] = createFormData({ title: 'hello', desc: 'world' })
+    const res = await r.handler()(req, { params: {}, query: {} })
+    assert.equal(res.status, 200)
+    const data = await res.json() as Record<string, string>
+    assert.deepEqual(data, { title: 'hello', desc: 'world' })
+  })
+
+  it('parses files in memory', async () => {
+    const r = new Router()
+      .post('/upload', upload(), (req, ctx) => {
+        const files = ctx.parsed?.files as Record<string, unknown>
+        return Response.json(files)
+      })
+
+    const [req] = createFormData({}, {
+      avatar: { name: 'photo.png', data: 'fakeimagedata', type: 'image/png' },
+    })
+    const res = await r.handler()(req, { params: {}, query: {} })
+    assert.equal(res.status, 200)
+    const data = await res.json() as Record<string, any>
+    const file = data.avatar
+    assert.equal(file.name, 'photo.png')
+    assert.equal(file.type, 'image/png')
+    assert.ok(file.size)
+    assert.ok(file.buffer)
+  })
+
+  it('saves files to disk when dir is set', async () => {
+    const uploadDir = resolve(tmpdir(), 'weifuwu-upload-test')
+    await mkdir(uploadDir, { recursive: true })
+
+    const r = new Router()
+      .post('/upload', upload({ dir: uploadDir }), (req, ctx) => {
+        const files = ctx.parsed?.files as Record<string, any>
+        return Response.json(files)
+      })
+
+    const [req] = createFormData({}, {
+      doc: { name: 'test.txt', data: 'file content' },
+    })
+    const res = await r.handler()(req, { params: {}, query: {} })
+    const data = await res.json() as Record<string, any>
+    assert.ok(data.doc.path)
+    const saved = await readFile(data.doc.path, 'utf-8')
+    assert.equal(saved, 'file content')
+    await rm(uploadDir, { recursive: true, force: true })
+  })
+
+  it('rejects oversized files', async () => {
+    const r = new Router()
+      .post('/upload', upload({ maxFileSize: 5 }), () => new Response('ok'))
+
+    const [req] = createFormData({}, {
+      big: { name: 'big.txt', data: 'too large content' },
+    })
+    const res = await r.handler()(req, { params: {}, query: {} })
+    assert.equal(res.status, 413)
+  })
+
+  it('rejects disallowed file types', async () => {
+    const r = new Router()
+      .post('/upload', upload({ allowedTypes: ['image/png'] }), () => new Response('ok'))
+
+    const [req] = createFormData({}, {
+      bad: { name: 'script.exe', data: 'evil', type: 'application/x-msdownload' },
+    })
+    const res = await r.handler()(req, { params: {}, query: {} })
+    assert.equal(res.status, 415)
+  })
+
+  it('passes through non-multipart requests', async () => {
+    let reached = false
+    const r = new Router()
+      .post('/upload', upload(), (req, ctx, next) => {
+        reached = true
+        return next(req, ctx)
+      }, () => new Response('ok'))
+
+    const res = await r.handler()(
+      new Request('http://localhost/upload', { method: 'POST', body: 'plain text' }),
+      { params: {}, query: {} },
+    )
+    assert.equal(res.status, 200)
+    assert.equal(reached, true)
+  })
+})

package/test/validate.test.ts

@@ -0,0 +1,133 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { z } from 'zod'
+import { Router } from '../router.ts'
+import { validate } from '../validate.ts'
+
+describe('validate', () => {
+  it('validates body with Zod schema', async () => {
+    const r = new Router()
+      .post('/users',
+        validate({ body: z.object({ name: z.string(), age: z.number() }) }),
+        async (req, ctx) => Response.json(ctx.parsed?.body),
+      )
+
+    const res = await r.handler()(
+      new Request('http://localhost/users', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: 'Alice', age: 30 }),
+      }),
+      { params: {}, query: {} },
+    )
+    assert.equal(res.status, 200)
+    const data = await res.json() as Record<string, unknown>
+    assert.deepEqual(data, { name: 'Alice', age: 30 })
+  })
+
+  it('rejects invalid body with 400', async () => {
+    const r = new Router()
+      .post('/users',
+        validate({ body: z.object({ name: z.string().min(1) }) }),
+        () => new Response('ok'),
+      )
+
+    const res = await r.handler()(
+      new Request('http://localhost/users', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: '' }),
+      }),
+      { params: {}, query: {} },
+    )
+    assert.equal(res.status, 400)
+    const data = await res.json() as Record<string, unknown>
+    assert.ok((data as any).issues)
+  })
+
+  it('validates query params', async () => {
+    const r = new Router()
+      .get('/search',
+        validate({ query: z.object({ q: z.string(), page: z.coerce.number().optional() }) }),
+        (req, ctx) => Response.json(ctx.parsed?.query),
+      )
+
+    const res = await r.handler()(
+      new Request('http://localhost/search?q=hello&page=2'),
+      { params: {}, query: { q: 'hello', page: '2' } },
+    )
+    assert.equal(res.status, 200)
+    const data = await res.json() as Record<string, unknown>
+    assert.deepEqual(data, { q: 'hello', page: 2 })
+  })
+
+  it('validates params', async () => {
+    const r = new Router()
+      .get('/:id',
+        validate({ params: z.object({ id: z.string().length(24) }) }),
+        (req, ctx) => Response.json(ctx.parsed?.params),
+      )
+
+    const res = await r.handler()(
+      new Request('http://localhost/507f1f77bcf86cd799439011'),
+      { params: { id: '507f1f77bcf86cd799439011' }, query: {} },
+    )
+    assert.equal(res.status, 200)
+    const data = await res.json() as Record<string, unknown>
+    assert.deepEqual(data, { id: '507f1f77bcf86cd799439011' })
+  })
+
+  it('rejects invalid params with 400', async () => {
+    const r = new Router()
+      .get('/:id',
+        validate({ params: z.object({ id: z.string().length(24) }) }),
+        () => new Response('ok'),
+      )
+
+    const res = await r.handler()(
+      new Request('http://localhost/bad-id'),
+      { params: { id: 'bad-id' }, query: {} },
+    )
+    assert.equal(res.status, 400)
+  })
+
+  it('validates both body and query simultaneously', async () => {
+    const r = new Router()
+      .post('/data',
+        validate({
+          body: z.object({ value: z.number() }),
+          query: z.object({ token: z.string() }),
+        }),
+        (req, ctx) => Response.json(ctx.parsed),
+      )
+
+    const res = await r.handler()(
+      new Request('http://localhost/data?token=abc', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ value: 42 }),
+      }),
+      { params: {}, query: { token: 'abc' } },
+    )
+    assert.equal(res.status, 200)
+    const data = await res.json() as Record<string, unknown>
+    assert.deepEqual(data, { body: { value: 42 }, query: { token: 'abc' } })
+  })
+
+  it('passes through when no schemas provided', async () => {
+    const r = new Router()
+      .post('/data',
+        validate({}),
+        () => new Response('ok'),
+      )
+
+    const res = await r.handler()(
+      new Request('http://localhost/data', {
+        method: 'POST',
+        body: JSON.stringify({ x: 1 }),
+      }),
+      { params: {}, query: {} },
+    )
+    assert.equal(res.status, 200)
+  })
+})

package/types.ts

@@ -0,0 +1,23 @@
+export interface Context {
+  params: Record<string, string>
+  query: Record<string, string>
+  user?: unknown
+  parsed?: Record<string, unknown>
+}
+
+export type Handler = (
+  req: Request,
+  ctx: Context,
+) => Response | Promise<Response>
+
+export type Middleware = (
+  req: Request,
+  ctx: Context,
+  next: Handler,
+) => Response | Promise<Response>
+
+export type ErrorHandler = (
+  error: Error,
+  req: Request,
+  ctx: Context,
+) => Response