npm - weifuwu - Versions diffs - 0.2.2 → 0.2.3 - Mend

weifuwu 0.2.2 → 0.2.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (45) hide show

package/README.md +56 -5
package/dist/compress.d.ts +6 -0
package/dist/cookie.d.ts +12 -0
package/dist/index.d.ts +21 -0
package/dist/index.js +1420 -0
package/dist/middleware.d.ts +21 -0
package/dist/rate-limit.d.ts +8 -0
package/dist/router.d.ts +55 -0
package/dist/serve.d.ts +19 -0
package/dist/static.d.ts +7 -0
package/dist/tsx.d.ts +17 -0
package/dist/types.d.ts +9 -0
package/dist/upload.d.ts +14 -0
package/dist/validate.d.ts +9 -0
package/package.json +14 -2
package/AGENTS.md +0 -105
package/compress.ts +0 -69
package/cookie.ts +0 -58
package/index.ts +0 -21
package/middleware.ts +0 -178
package/rate-limit.ts +0 -68
package/router.ts +0 -701
package/serve.ts +0 -126
package/static.ts +0 -113
package/test/compress.test.ts +0 -106
package/test/cookie.test.ts +0 -79
package/test/fixtures/pages/about/page.tsx +0 -3
package/test/fixtures/pages/blog/[slug]/load.ts +0 -3
package/test/fixtures/pages/blog/[slug]/page.tsx +0 -3
package/test/fixtures/pages/blog/[slug]/route.ts +0 -7
package/test/fixtures/pages/blog/layout.tsx +0 -3
package/test/fixtures/pages/layout.tsx +0 -12
package/test/fixtures/pages/page.tsx +0 -3
package/test/middleware.test.ts +0 -407
package/test/rate-limit.test.ts +0 -94
package/test/static.test.ts +0 -93
package/test/tsx.test.ts +0 -285
package/test/unode.test.ts +0 -401
package/test/upload.test.ts +0 -130
package/test/validate.test.ts +0 -133
package/tsconfig.json +0 -13
package/tsx.ts +0 -374
package/types.ts +0 -23
package/upload.ts +0 -101
package/validate.ts +0 -88

package/test/tsx.test.ts DELETED Viewed

@@ -1,285 +0,0 @@
-import { describe, it, before, after } from 'node:test'
-import assert from 'node:assert/strict'
-import { tsx } from '../tsx.ts'
-import { serve, Router } from '../index.ts'
-import type { Server } from '../serve.ts'
-const fixtures = './test/fixtures/pages'
-describe('tsx()', () => {
-  describe('SSR rendering', () => {
-    it('renders root page', async () => {
-      const r = await tsx({ dir: fixtures })
-      const res = await r.handler()(
-        new Request('http://localhost/'),
-        { params: {}, query: {} },
-      )
-      assert.equal(res.status, 200)
-      const html = await res.text()
-      assert.match(html, /<!DOCTYPE html>/)
-      assert.match(html, /<h1>Home<\/h1>/)
-    })
-    it('renders nested static page', async () => {
-      const r = await tsx({ dir: fixtures })
-      const res = await r.handler()(
-        new Request('http://localhost/about'),
-        { params: {}, query: {} },
-      )
-      assert.equal(res.status, 200)
-      const html = await res.text()
-      assert.match(html, /<h1>About<\/h1>/)
-    })
-    it('renders dynamic route with params', async () => {
-      const r = await tsx({ dir: fixtures })
-      const res = await r.handler()(
-        new Request('http://localhost/blog/hello-world'),
-        { params: { slug: 'hello-world' }, query: {} },
-      )
-      assert.equal(res.status, 200)
-      const html = await res.text()
-      assert.match(html, /hello-world/)
-    })
-    it('passes query params', async () => {
-      const r = await tsx({ dir: fixtures })
-      const res = await r.handler()(
-        new Request('http://localhost/?foo=bar'),
-        { params: {}, query: { foo: 'bar' } },
-      )
-      assert.equal(res.status, 200)
-      assert.equal((await res.text()).includes('Home'), true)
-    })
-    it('returns 404 for non-existent route', async () => {
-      const r = await tsx({ dir: fixtures })
-      const res = await r.handler()(
-        new Request('http://localhost/nonexistent'),
-        { params: {}, query: {} },
-      )
-      assert.equal(res.status, 404)
-    })
-  })
-  describe('data loading (load.ts)', () => {
-    it('calls load() and passes data as props', async () => {
-      const r = await tsx({ dir: fixtures })
-      const res = await r.handler()(
-        new Request('http://localhost/blog/my-post'),
-        { params: { slug: 'my-post' }, query: {} },
-      )
-      assert.equal(res.status, 200)
-      const html = await res.text()
-      assert.match(html, /Post: my-post/)
-    })
-    it('serializes props to __WEIFUWU_PROPS', async () => {
-      const r = await tsx({ dir: fixtures })
-      const res = await r.handler()(
-        new Request('http://localhost/blog/my-post'),
-        { params: { slug: 'my-post' }, query: {} },
-      )
-      const html = await res.text()
-      assert.match(html, /__WEIFUWU_PROPS/)
-      assert.match(html, /Post: my-post/)
-    })
-  })
-  describe('layout chain', () => {
-    it('wraps page with root layout', async () => {
-      const r = await tsx({ dir: fixtures })
-      const res = await r.handler()(
-        new Request('http://localhost/'),
-        { params: {}, query: {} },
-      )
-      const html = await res.text()
-      assert.match(html, /<html>/)
-      assert.match(html, /<title>App<\/title>/)
-      assert.match(html, /__weifuwu_root/)
-    })
-    it('wraps blog pages with nested layouts', async () => {
-      const r = await tsx({ dir: fixtures })
-      const res = await r.handler()(
-        new Request('http://localhost/blog/some-post'),
-        { params: { slug: 'some-post' }, query: {} },
-      )
-      const html = await res.text()
-      assert.match(html, /blog-layout/)
-    })
-  })
-  describe('route.ts API', () => {
-    it('GET returns SSR page, not route.ts', async () => {
-      const r = await tsx({ dir: fixtures })
-      const res = await r.handler()(
-        new Request('http://localhost/blog/my-route'),
-        { params: { slug: 'my-route' }, query: {} },
-      )
-      // GET is handled by page.tsx SSR, not route.ts
-      const html = await res.text()
-      assert.match(html, /<!DOCTYPE html>/)
-      assert.match(html, /my-route/)
-    })
-    it('handles POST from route.ts', async () => {
-      const r = await tsx({ dir: fixtures })
-      const res = await r.handler()(
-        new Request('http://localhost/blog/my-route', { method: 'POST' }),
-        { params: { slug: 'my-route' }, query: {} },
-      )
-      const data = await res.json() as any
-      assert.equal(data.method, 'POST')
-      assert.equal(data.slug, 'my-route')
-    })
-  })
-  describe('hydration', () => {
-    it('injects hydration scripts', async () => {
-      const r = await tsx({ dir: fixtures })
-      const res = await r.handler()(
-        new Request('http://localhost/'),
-        { params: {}, query: {} },
-      )
-      const html = await res.text()
-      assert.match(html, /<script type="module"/)
-      assert.match(html, /__wfw\/client\//)
-    })
-    it('serves hydration bundle', async () => {
-      const r = await tsx({ dir: fixtures })
-      const res1 = await r.handler()(
-        new Request('http://localhost/'),
-        { params: {}, query: {} },
-      )
-      const html = await res1.text()
-      const match = html.match(/src="(\/__wfw\/client\/[^"]+)"/)
-      assert.ok(match)
-      const res2 = await r.handler()(
-        new Request(`http://localhost${match[1]}`),
-        { params: {}, query: {} },
-      )
-      assert.equal(res2.status, 200)
-      const js = await res2.text()
-      assert.match(js, /hydrateRoot/)
-    })
-  })
-  describe('mounting via router.use()', () => {
-    it('works as sub-router', async () => {
-      const pages = await tsx({ dir: fixtures })
-      const main = new Router()
-      main.use('/app', pages)
-      const res = await main.handler()(
-        new Request('http://localhost/app/about'),
-        { params: {}, query: {} },
-      )
-      assert.equal(res.status, 200)
-      const html = await res.text()
-      assert.match(html, /<h1>About<\/h1>/)
-    })
-    it('coexists with other Router features', async () => {
-      const pages = await tsx({ dir: fixtures })
-      const main = new Router()
-      main.use('/app', pages)
-      main.get('/api/ping', () => Response.json({ ok: true }))
-      const res1 = await main.handler()(
-        new Request('http://localhost/app/about'),
-        { params: {}, query: {} },
-      )
-      assert.equal(res1.status, 200)
-      const html = await res1.text()
-      assert.match(html, /<h1>About<\/h1>/)
-      const res2 = await main.handler()(
-        new Request('http://localhost/api/ping'),
-        { params: {}, query: {} },
-      )
-      const data = await res2.json() as any
-      assert.equal(data.ok, true)
-    })
-  })
-  describe('end-to-end via serve()', () => {
-    let server: Server
-    let url: string
-    before(async () => {
-      const pages = await tsx({ dir: fixtures })
-      server = serve(pages.handler(), { port: 0 })
-      await server.ready
-      url = `http://localhost:${server.port}`
-    })
-    after(() => server.stop())
-    it('serves page via HTTP', async () => {
-      const res = await fetch(`${url}/about`)
-      assert.equal(res.status, 200)
-      const html = await res.text()
-      assert.match(html, /<h1>About<\/h1>/)
-    })
-    it('serves hydration bundle via HTTP', async () => {
-      const res = await fetch(`${url}/`)
-      const html = await res.text()
-      const match = html.match(/src="(\/__wfw\/client\/[^"]+)"/)
-      assert.ok(match)
-      const bundleRes = await fetch(`${url}${match[1]}`)
-      assert.equal(bundleRes.status, 200)
-      const js = await bundleRes.text()
-      assert.match(js, /hydrateRoot/)
-    })
-    it('serves dynamic route and API', async () => {
-      const res = await fetch(`${url}/blog/test-article`)
-      assert.equal(res.status, 200)
-      const html = await res.text()
-      assert.match(html, /Post: test-article/)
-    })
-  })
-  describe('edge cases', () => {
-    it('non-existent directory returns empty router', async () => {
-      const r = await tsx({ dir: './test/fixtures/nonexistent' })
-      const res = await r.handler()(
-        new Request('http://localhost/'),
-        { params: {}, query: {} },
-      )
-      assert.equal(res.status, 404)
-    })
-    it('empty directory returns empty router', async () => {
-      const r = await tsx({ dir: './test/fixtures/empty' })
-      const res = await r.handler()(
-        new Request('http://localhost/'),
-        { params: {}, query: {} },
-      )
-      assert.equal(res.status, 404)
-    })
-    it('handles page.ts without tsx extension', async () => {
-      // about/ has page.tsx only, but scanPages also checks page.ts
-      const r = await tsx({ dir: fixtures })
-      const res = await r.handler()(
-        new Request('http://localhost/about'),
-        { params: {}, query: {} },
-      )
-      assert.equal(res.status, 200)
-    })
-  })
-})

package/test/unode.test.ts DELETED Viewed

@@ -1,401 +0,0 @@
-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()
-  })
-})