weifuwu 0.2.2 → 0.2.4

package/serve.ts

@@ -1,126 +0,0 @@
-import http, { type IncomingMessage, type ServerResponse } from 'node:http'
-import type { Duplex } from 'node:stream'
-import type { Handler } from './types.ts'
-
-export interface ServeOptions {
-  port?: number
-  hostname?: string
-  signal?: AbortSignal
-  websocket?: (req: IncomingMessage, socket: Duplex, head: Buffer) => void
-}
-
-export interface Server {
-  stop: () => void
-  readonly port: number
-  readonly hostname: string
-  ready: Promise<void>
-}
-
-export async function readBody(req: IncomingMessage): Promise<Buffer> {
-  const chunks: Buffer[] = []
-  for await (const chunk of req) {
-    chunks.push(chunk as Buffer)
-  }
-  return Buffer.concat(chunks)
-}
-
-export function createRequest(req: IncomingMessage, body: Buffer): [Request, Record<string, string>] {
-  const url = new URL(req.url ?? '/', 'http://localhost')
-  const query = Object.fromEntries(url.searchParams)
-
-  const headers: Record<string, string> = {}
-  for (const [key, value] of Object.entries(req.headers)) {
-    if (value !== undefined) {
-      headers[key] = Array.isArray(value) ? value.join(', ') : value
-    }
-  }
-
-  const request = new Request(url.href, {
-    method: req.method?.toUpperCase() ?? 'GET',
-    headers,
-    body: (req.method !== 'GET' && req.method !== 'HEAD' && body.length > 0)
-      ? body as BodyInit
-      : null,
-  })
-
-  return [request, query]
-}
-
-export async function sendResponse(res: ServerResponse, response: Response): Promise<void> {
-  const headers: Record<string, string | string[]> = {}
-  response.headers.forEach((value, key) => {
-    headers[key] = value
-  })
-
-  res.writeHead(response.status, response.statusText, headers)
-
-  if (response.body) {
-    const reader = response.body.getReader()
-    try {
-      while (true) {
-        const { done, value } = await reader.read()
-        if (done) break
-        res.write(value)
-      }
-    } finally {
-      reader.releaseLock()
-    }
-  }
-
-  res.end()
-}
-
-export function serve(handler: Handler, options?: ServeOptions): Server {
-  const port = options?.port ?? 0
-  const hostname = options?.hostname ?? '0.0.0.0'
-
-  const server = http.createServer(async (req, res) => {
-    try {
-      const body = await readBody(req)
-      const [request, query] = createRequest(req, body)
-      const response = await handler(request, { params: {}, query })
-      await sendResponse(res, response)
-    } catch {
-      res.writeHead(500, { 'Content-Type': 'text/plain' })
-      res.end('Internal Server Error')
-    }
-  })
-
-  if (options?.websocket) {
-    server.on('upgrade', options.websocket)
-  }
-
-  let resolveReady!: () => void
-  const ready = new Promise<void>((r) => { resolveReady = r })
-
-  if (options?.signal) {
-    if (options.signal.aborted) {
-      server.close()
-      resolveReady()
-      return {
-        stop: () => {},
-        ready,
-        get port() { return 0 },
-        get hostname() { return hostname },
-      }
-    }
-    options.signal.addEventListener('abort', () => { server.close() }, { once: true })
-  }
-
-  server.listen(port, hostname, () => { resolveReady() })
-
-  return {
-    stop: () => { server.close() },
-    ready,
-    get port() {
-      const addr = server.address()
-      if (!addr || typeof addr === 'string') return 0
-      return addr.port
-    },
-    get hostname() {
-      const addr = server.address()
-      if (!addr) return hostname
-      return typeof addr === 'string' ? addr : addr.address
-    },
-  }
-}

package/static.ts

@@ -1,113 +0,0 @@
-import { createHash } from 'node:crypto'
-import { open } from 'node:fs/promises'
-import { extname, resolve, normalize, sep } from 'node:path'
-import type { Handler } from './types.ts'
-
-export interface ServeStaticOptions {
-  index?: string
-  maxAge?: number
-  immutable?: boolean
-}
-
-export function serveStatic(root: string, options?: ServeStaticOptions): Handler {
-  const rootDir = resolve(root)
-
-  const opts = options ?? {}
-
-  return async (req, ctx) => {
-    const relativePath = ctx.params['*'] ?? new URL(req.url).pathname.slice(1)
-    const decoded = decodeURIComponent(relativePath)
-
-    if (decoded.includes('..') || decoded.includes('\0')) {
-      return new Response('Forbidden', { status: 403 })
-    }
-
-    let filePath = normalize(resolve(rootDir, decoded))
-    if (!filePath.startsWith(rootDir + sep) && filePath !== rootDir) {
-      return new Response('Forbidden', { status: 403 })
-    }
-
-    let fileHandle
-    try {
-      fileHandle = await open(filePath, 'r')
-      const stat = await fileHandle.stat()
-
-      if (stat.isDirectory()) {
-        await fileHandle.close()
-        const indexFile = opts.index ?? 'index.html'
-        filePath = resolve(filePath, indexFile)
-        if (!filePath.startsWith(rootDir + sep)) {
-          return new Response('Forbidden', { status: 403 })
-        }
-        fileHandle = await open(filePath, 'r')
-        const dirStat = await fileHandle.stat()
-        if (!dirStat.isFile()) {
-          await fileHandle.close()
-          return new Response('Not Found', { status: 404 })
-        }
-      }
-
-      const mimeType = MIME_TYPES[extname(filePath).toLowerCase()] ?? 'application/octet-stream'
-
-      const etag = `"${createHash('md5').update(`${stat.size}-${stat.mtimeMs}`).digest('hex')}"`
-      const ifNoneMatch = req.headers.get('if-none-match')
-      if (ifNoneMatch === etag) {
-        await fileHandle.close()
-        return new Response(null, { status: 304 })
-      }
-
-      const ifModifiedSince = req.headers.get('if-modified-since')
-      if (ifModifiedSince && stat.mtimeMs <= new Date(ifModifiedSince).getTime()) {
-        await fileHandle.close()
-        return new Response(null, { status: 304 })
-      }
-
-      const headers: Record<string, string> = {
-        'Content-Type': mimeType,
-        'Content-Length': String(stat.size),
-        'ETag': etag,
-        'Last-Modified': stat.mtime.toUTCString(),
-        'Cache-Control': opts.immutable
-          ? `public, max-age=${opts.maxAge ?? 31536000}, immutable`
-          : `public, max-age=${opts.maxAge ?? 0}`,
-      }
-
-      const stream = fileHandle.readableWebStream()
-      return new Response(stream as unknown as BodyInit, { headers })
-    } catch (err) {
-      if (fileHandle) await fileHandle.close().catch(() => {})
-      if ((err as NodeJS.ErrnoException)?.code === 'ENOENT') {
-        return new Response('Not Found', { status: 404 })
-      }
-      return new Response('Internal Server Error', { status: 500 })
-    }
-  }
-}
-
-const MIME_TYPES: Record<string, string> = {
-  '.html': 'text/html; charset=utf-8',
-  '.htm': 'text/html; charset=utf-8',
-  '.css': 'text/css; charset=utf-8',
-  '.js': 'application/javascript; charset=utf-8',
-  '.mjs': 'application/javascript; charset=utf-8',
-  '.json': 'application/json',
-  '.png': 'image/png',
-  '.jpg': 'image/jpeg',
-  '.jpeg': 'image/jpeg',
-  '.gif': 'image/gif',
-  '.svg': 'image/svg+xml',
-  '.ico': 'image/x-icon',
-  '.webp': 'image/webp',
-  '.avif': 'image/avif',
-  '.woff': 'font/woff',
-  '.woff2': 'font/woff2',
-  '.ttf': 'font/ttf',
-  '.otf': 'font/otf',
-  '.eot': 'application/vnd.ms-fontobject',
-  '.txt': 'text/plain; charset=utf-8',
-  '.xml': 'application/xml',
-  '.pdf': 'application/pdf',
-  '.zip': 'application/zip',
-  '.wasm': 'application/wasm',
-  '.map': 'application/json',
-}

package/test/compress.test.ts

@@ -1,106 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import { gunzipSync, brotliDecompressSync } from 'node:zlib'
-import { Router } from '../router.ts'
-import { compress } from '../compress.ts'
-
-describe('compress', () => {
-  it('compresses with gzip when accepted', async () => {
-    const r = new Router()
-      .use(compress({ threshold: 0 }))
-      .get('/data', () => new Response('hello '.repeat(100)))
-
-    const res = await r.handler()(
-      new Request('http://localhost/data', { headers: { 'accept-encoding': 'gzip' } }),
-      { params: {}, query: {} },
-    )
-    assert.equal(res.headers.get('content-encoding'), 'gzip')
-    const body = await res.bytes()
-    const decoded = gunzipSync(Buffer.from(body)).toString()
-    assert.equal(decoded, 'hello '.repeat(100))
-  })
-
-  it('compresses with brotli (preferred over gzip)', async () => {
-    const r = new Router()
-      .use(compress({ threshold: 0 }))
-      .get('/data', () => new Response('hello '.repeat(100)))
-
-    const res = await r.handler()(
-      new Request('http://localhost/data', { headers: { 'accept-encoding': 'br, gzip' } }),
-      { params: {}, query: {} },
-    )
-    assert.equal(res.headers.get('content-encoding'), 'br')
-  })
-
-  it('skips compression for small responses', async () => {
-    const r = new Router()
-      .use(compress({ threshold: 1000 }))
-      .get('/data', () => new Response('small'))
-
-    const res = await r.handler()(
-      new Request('http://localhost/data', { headers: { 'accept-encoding': 'gzip' } }),
-      { params: {}, query: {} },
-    )
-    assert.equal(res.headers.get('content-encoding'), null)
-  })
-
-  it('skips compression when Accept-Encoding is absent', async () => {
-    const r = new Router()
-      .use(compress({ threshold: 0 }))
-      .get('/data', () => new Response('hello '.repeat(100)))
-
-    const res = await r.handler()(
-      new Request('http://localhost/data'),
-      { params: {}, query: {} },
-    )
-    assert.equal(res.headers.get('content-encoding'), null)
-  })
-
-  it('does not compress images', async () => {
-    const r = new Router()
-      .use(compress({ threshold: 0 }))
-      .get('/data', () => new Response('fakeimage', { headers: { 'content-type': 'image/png' } }))
-
-    const res = await r.handler()(
-      new Request('http://localhost/data', { headers: { 'accept-encoding': 'gzip' } }),
-      { params: {}, query: {} },
-    )
-    assert.equal(res.headers.get('content-encoding'), null)
-  })
-
-  it('does not compress already encoded responses', async () => {
-    const r = new Router()
-      .use(compress({ threshold: 0 }))
-      .get('/data', () => new Response('data', { headers: { 'content-encoding': 'gzip' } }))
-
-    const res = await r.handler()(
-      new Request('http://localhost/data', { headers: { 'accept-encoding': 'gzip' } }),
-      { params: {}, query: {} },
-    )
-    assert.equal(res.headers.get('content-encoding'), 'gzip')
-  })
-
-  it('sets Content-Length after compression', async () => {
-    const r = new Router()
-      .use(compress({ threshold: 0 }))
-      .get('/data', () => new Response('hello '.repeat(100)))
-
-    const res = await r.handler()(
-      new Request('http://localhost/data', { headers: { 'accept-encoding': 'gzip' } }),
-      { params: {}, query: {} },
-    )
-    assert.ok(res.headers.get('content-length'))
-  })
-
-  it('sets Vary: Accept-Encoding', async () => {
-    const r = new Router()
-      .use(compress({ threshold: 0 }))
-      .get('/data', () => new Response('hello '.repeat(100)))
-
-    const res = await r.handler()(
-      new Request('http://localhost/data', { headers: { 'accept-encoding': 'gzip' } }),
-      { params: {}, query: {} },
-    )
-    assert.equal(res.headers.get('Vary'), 'Accept-Encoding')
-  })
-})

package/test/cookie.test.ts

@@ -1,79 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import { getCookies, setCookie, deleteCookie } from '../cookie.ts'
-
-describe('getCookies', () => {
-  it('parses a single cookie', () => {
-    const req = new Request('http://localhost', { headers: { cookie: 'name=value' } })
-    assert.deepEqual(getCookies(req), { name: 'value' })
-  })
-
-  it('parses multiple cookies', () => {
-    const req = new Request('http://localhost', { headers: { cookie: 'a=1; b=2; c=3' } })
-    assert.deepEqual(getCookies(req), { a: '1', b: '2', c: '3' })
-  })
-
-  it('decodes URL-encoded values', () => {
-    const req = new Request('http://localhost', { headers: { cookie: 'name=hello%20world' } })
-    assert.deepEqual(getCookies(req), { name: 'hello world' })
-  })
-
-  it('returns empty object when no cookie header', () => {
-    const req = new Request('http://localhost')
-    assert.deepEqual(getCookies(req), {})
-  })
-
-  it('handles whitespace around pairs', () => {
-    const req = new Request('http://localhost', { headers: { cookie: ' a = 1 ; b=2 ' } })
-    assert.deepEqual(getCookies(req), { a: '1', b: '2' })
-  })
-})
-
-describe('setCookie', () => {
-  it('sets a cookie on the response', () => {
-    const res = new Response('ok')
-    const updated = setCookie(res, 'session', 'abc123')
-    assert.equal(updated.headers.get('Set-Cookie'), 'session=abc123')
-  })
-
-  it('appends multiple Set-Cookie headers', () => {
-    let res = new Response('ok')
-    res = setCookie(res, 'a', '1')
-    res = setCookie(res, 'b', '2')
-    const headers = res.headers.getSetCookie?.() ?? res.headers.get('Set-Cookie')
-    assert.ok(Array.isArray(headers) ? headers.length === 2 : true)
-  })
-
-  it('adds cookie options', () => {
-    const res = new Response('ok')
-    const updated = setCookie(res, 'token', 'xyz', {
-      httpOnly: true,
-      secure: true,
-      sameSite: 'lax',
-      maxAge: 3600,
-      path: '/',
-    })
-    const cookie = updated.headers.get('Set-Cookie')!
-    assert.ok(cookie.includes('HttpOnly'))
-    assert.ok(cookie.includes('Secure'))
-    assert.ok(cookie.includes('SameSite=lax'))
-    assert.ok(cookie.includes('Max-Age=3600'))
-    assert.ok(cookie.includes('Path=/'))
-  })
-
-  it('does not mutate original response', () => {
-    const res = new Response('ok')
-    setCookie(res, 'x', 'y')
-    assert.equal(res.headers.get('Set-Cookie'), null)
-  })
-})
-
-describe('deleteCookie', () => {
-  it('sets Max-Age=0 to expire the cookie', () => {
-    const res = new Response('ok')
-    const updated = deleteCookie(res, 'session')
-    const cookie = updated.headers.get('Set-Cookie')!
-    assert.ok(cookie.includes('session='))
-    assert.ok(cookie.includes('Max-Age=0'))
-  })
-})

package/test/fixtures/pages/about/page.tsx

@@ -1,3 +0,0 @@
-export default function About() {
-  return <h1>About</h1>
-}

package/test/fixtures/pages/blog/[slug]/load.ts

@@ -1,3 +0,0 @@
-export default async function load({ params }: { params: { slug: string } }) {
-  return { post: { title: `Post: ${params.slug}` } }
-}

package/test/fixtures/pages/blog/[slug]/page.tsx

@@ -1,3 +0,0 @@
-export default function Post({ post, params }: { post?: { title: string }; params: { slug: string } }) {
-  return <article><h1>{post?.title ?? params.slug}</h1></article>
-}

package/test/fixtures/pages/blog/[slug]/route.ts

@@ -1,7 +0,0 @@
-export async function GET(req: Request, ctx: { params: { slug: string } }) {
-  return Response.json({ method: 'GET', slug: ctx.params.slug })
-}
-
-export async function POST(req: Request, ctx: { params: { slug: string } }) {
-  return Response.json({ method: 'POST', slug: ctx.params.slug })
-}

package/test/fixtures/pages/blog/layout.tsx

@@ -1,3 +0,0 @@
-export default function BlogLayout({ children }: { children: any }) {
-  return <div className="blog-layout">{children}</div>
-}

package/test/fixtures/pages/layout.tsx

@@ -1,12 +0,0 @@
-export default function RootLayout({ children }: { children: any }) {
-  return (
-    <html>
-      <head>
-        <title>App</title>
-      </head>
-      <body>
-        <div id="__weifuwu_root">{children}</div>
-      </body>
-    </html>
-  )
-}

package/test/fixtures/pages/page.tsx

@@ -1,3 +0,0 @@
-export default function Home() {
-  return <h1>Home</h1>
-}