weifuwu 0.2.2 → 0.2.3

package/dist/middleware.d.ts

@@ -0,0 +1,21 @@
+import type { Middleware } from './types.ts';
+export interface LoggerOptions {
+    format?: 'short' | 'combined';
+}
+export declare function logger(options?: LoggerOptions): Middleware;
+export interface CORSOptions {
+    origin?: string | string[] | ((origin: string) => string | boolean | undefined);
+    methods?: string[];
+    allowedHeaders?: string[];
+    exposedHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+}
+export declare function cors(options?: CORSOptions): Middleware;
+export interface AuthOptions {
+    token?: string;
+    verify?: (token: string, req: Request) => unknown | Promise<unknown>;
+    proxy?: string | URL;
+    header?: string;
+}
+export declare function auth(options: AuthOptions): Middleware;

package/dist/rate-limit.d.ts

@@ -0,0 +1,8 @@
+import type { Middleware } from './types.ts';
+export interface RateLimitOptions {
+    max?: number;
+    window?: number;
+    key?: (req: Request) => string;
+    message?: string;
+}
+export declare function rateLimit(options?: RateLimitOptions): Middleware;

package/dist/router.d.ts

@@ -0,0 +1,55 @@
+import { type WebSocket } from 'ws';
+import type { IncomingMessage } from 'node:http';
+import type { Duplex } from 'node:stream';
+import { type GraphQLSchema } from 'graphql';
+import { streamText } from 'ai';
+import type { Context, Handler, Middleware, ErrorHandler } from './types.ts';
+type StreamTextParams = Parameters<typeof streamText>[0];
+export type WebSocketHandler = {
+    open?: (ws: WebSocket, ctx: Context) => void | Promise<void>;
+    message?: (ws: WebSocket, ctx: Context, data: string | Buffer) => void | Promise<void>;
+    close?: (ws: WebSocket, ctx: Context) => void | Promise<void>;
+    error?: (ws: WebSocket, ctx: Context, error: Error) => void | Promise<void>;
+};
+export type AIOptions = Omit<StreamTextParams, 'model'> & {
+    model: string | (() => any);
+};
+export type AIHandler = (req: Request, ctx: Context) => AIOptions | Promise<AIOptions>;
+export type GraphQLOptions = {
+    schema: string | GraphQLSchema;
+    rootValue?: any;
+    resolvers?: any;
+    context?: (req: Request, ctx: Context) => Record<string, any> | Promise<Record<string, any>>;
+    graphiql?: boolean;
+};
+type WsUpgradeHandler = (req: IncomingMessage, socket: Duplex, head: Buffer) => void;
+export declare class Router {
+    private root;
+    private wsRoot;
+    private globalMws;
+    private errorHandler?;
+    use(mw: Middleware): this;
+    use(path: string, router: Router): this;
+    use(path: string, mw: Middleware): this;
+    get(path: string, ...args: [...Middleware[], Handler]): this;
+    post(path: string, ...args: [...Middleware[], Handler]): this;
+    put(path: string, ...args: [...Middleware[], Handler]): this;
+    delete(path: string, ...args: [...Middleware[], Handler]): this;
+    patch(path: string, ...args: [...Middleware[], Handler]): this;
+    head(path: string, ...args: [...Middleware[], Handler]): this;
+    options(path: string, ...args: [...Middleware[], Handler]): this;
+    all(path: string, ...args: [...Middleware[], Handler]): this;
+    onError(handler: ErrorHandler): this;
+    route(method: string, path: string, ...args: [...Middleware[], Handler]): this;
+    ws(path: string, ...args: [...Middleware[], WebSocketHandler]): this;
+    graphql(path: string, ...args: [...Middleware[], GraphQLOptions]): this;
+    ai(path: string, ...args: [...Middleware[], AIHandler]): this;
+    handler(): Handler;
+    websocketHandler(): WsUpgradeHandler;
+    private splitPath;
+    private matchTrie;
+    private matchWsTrie;
+    private handle;
+    private runChain;
+}
+export {};

package/dist/serve.d.ts

@@ -0,0 +1,19 @@
+import { 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 declare function readBody(req: IncomingMessage): Promise<Buffer>;
+export declare function createRequest(req: IncomingMessage, body: Buffer): [Request, Record<string, string>];
+export declare function sendResponse(res: ServerResponse, response: Response): Promise<void>;
+export declare function serve(handler: Handler, options?: ServeOptions): Server;

package/dist/static.d.ts

@@ -0,0 +1,7 @@
+import type { Handler } from './types.ts';
+export interface ServeStaticOptions {
+    index?: string;
+    maxAge?: number;
+    immutable?: boolean;
+}
+export declare function serveStatic(root: string, options?: ServeStaticOptions): Handler;

package/dist/tsx.d.ts

@@ -0,0 +1,17 @@
+import { Router } from './router.ts';
+export interface TsxOptions {
+    dir: string;
+}
+export declare const TsxContext: import("react").Context<{
+    params: Record<string, string>;
+    query: Record<string, string>;
+    user?: unknown;
+    parsed?: Record<string, unknown>;
+}>;
+export declare function useTsx(): {
+    params: Record<string, string>;
+    query: Record<string, string>;
+    user?: unknown;
+    parsed?: Record<string, unknown>;
+};
+export declare function tsx(options: TsxOptions): Promise<Router>;

package/dist/types.d.ts

@@ -0,0 +1,9 @@
+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;

package/dist/upload.d.ts

@@ -0,0 +1,14 @@
+import type { Middleware } from './types.ts';
+export interface UploadedFile {
+    name: string;
+    type: string;
+    size: number;
+    path?: string;
+    buffer?: Buffer;
+}
+export interface UploadOptions {
+    dir?: string;
+    maxFileSize?: number;
+    allowedTypes?: string[];
+}
+export declare function upload(options?: UploadOptions): Middleware;

package/dist/validate.d.ts

@@ -0,0 +1,9 @@
+import type { ZodSchema } from 'zod';
+import type { Middleware } from './types.ts';
+export interface ValidationSchemas {
+    body?: ZodSchema;
+    query?: ZodSchema;
+    params?: ZodSchema;
+    headers?: ZodSchema;
+}
+export declare function validate(schemas: ValidationSchemas): Middleware;

package/package.json

@@ -1,9 +1,21 @@
 {
   "name": "weifuwu",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Web-standard HTTP framework for Node.js — (req, ctx) => Response",
-  "main": "index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./tsx": "./dist/index.js"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
+    "build": "esbuild index.ts --bundle --format=esm --platform=node --outfile=dist/index.js --external:react --external:react-dom --external:esbuild --external:graphql --external:ws --external:zod --external:@graphql-tools/schema --external:ai",
+    "prepublishOnly": "npm run build && tsc --emitDeclarationOnly --outdir dist",
     "test": "node --test 'test/**/*.test.ts'"
   },
   "dependencies": {

package/AGENTS.md

@@ -1,105 +0,0 @@
-This is the weifuwu HTTP framework — pure Node.js, no build step.
-
-## Commands
-
-- `node --test` — run all tests
-- `npm install` — install dependencies
-- `npx tsc --noEmit` — type-check without emitting
-
-## TypeScript rules
-
-- All imports must use explicit `.ts` extensions (e.g. `import { x } from './foo.ts'`)
-- Node.js v24+ supports TypeScript natively (no `--experimental-strip-types` needed)
-- No `tsc` compiler needed for runtime (native TS via Node.js)
-
-## Code conventions
-
-- Read the full file before editing — context matters
-- Follow existing patterns: `Handler = (req, ctx) => Response | Promise<Response>`
-- All middleware returns a `Middleware` — `(req, ctx, next) => Response | Promise<Response>`
-- Import types from `./types.ts`, source from individual files
-- New modules get their own file, exported from `index.ts`
-- Every module needs tests in `test/`
-- All `ctx` mutations (like `ctx.parsed` or `ctx.user`) should be additive, never overwrite
-
-## Dependencies
-
-- `ws` for WebSocket server
-- `graphql` + `@graphql-tools/schema` for GraphQL
-- `ai` (Vercel AI SDK) for AI streaming
-- `zod` for request validation
-- `react` + `react-dom` for `.tsx()` SSR + hydration
-- `esbuild` for hydration bundle compilation
-- Node.js built-in `WebSocket` for WebSocket clients
-- Node.js built-in `zlib` for response compression
-
-## tsx() — React SSR + Auto Hydration
-
-`tsx({ dir })` — creates a Router from a React pages directory:
-
-```ts
-type TsxRoute = {
-  component: React.ComponentType<any>
-  props?: Record<string, any>       // custom props (merged with params + query)
-  source?: string                   // component source path → enables hydration
-}
-
-type TsxHandler = (
-  req: Request,
-  ctx: Context,
-) => TsxRoute | Promise<TsxRoute>
-```
-
-- SSR via `react-dom/server` `renderToReadableStream`
-- Props are serialized as `window.__WEIFUWU_PROPS` in HTML
-- Hydration: esbuild lazily compiles source → client bundle served at `/_wfw/client/`
-- Props passed to component: `{ ...props, params, query }` (never `req`/`ctx`)
-
-### File conventions
-
-```
-pages/
-  page.tsx              → GET /           (React component, default export)
-  layout.tsx            → root layout     (wraps all pages)
-  about/page.tsx        → GET /about
-  blog/[slug]/
-    page.tsx            → GET /blog/:slug
-    load.ts             → data fetching   (server-only, default export)
-    route.ts            → POST /blog/:slug (API, named exports GET/POST/...)
-  blog/layout.tsx       → /blog/* layout  (auto-wraps blog pages)
-```
-
-- `page.tsx` — default export = React component, receives `{ params, query }` + load data
-- `load.ts` — default export = async function `({ params, query }) => props`, server-only
-- `layout.tsx` — default export = React component with `{ children }`, auto-nested by directory level
-- `route.ts` — named exports `GET`/`POST`/`PUT`/`DELETE`/`PATCH`, standard Handler signature
-
-### Usage
-
-```ts
-import { serve, Router } from 'weifuwu'
-import { tsx } from 'weifuwu/tsx'
-
-const r = new Router()
-r.use('/', await tsx({ dir: './pages/' }))
-
-// Other features coexist
-r.ws('/chat', { message(ws, _, data) { ws.send(data) } })
-
-serve(r.handler())
-```
-
-## Testing
-
-```ts#test/example.test.ts
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-describe('example', () => {
-  it('works', () => {
-    assert.equal(1 + 1, 2)
-  })
-})
-```
-
-Tests live in `test/` and follow the pattern: create a `Router`, call `r.handler()(request, ctx)`, assert on the response. For end-to-end tests, use `serve()`.

package/compress.ts

@@ -1,69 +0,0 @@
-import { gzipSync, brotliCompressSync, constants } from 'node:zlib'
-import type { Middleware } from './types.ts'
-
-export interface CompressOptions {
-  level?: number
-  threshold?: number
-}
-
-export function compress(options?: CompressOptions): Middleware {
-  const level = options?.level ?? 6
-  const threshold = options?.threshold ?? 1024
-
-  return async (req, ctx, next) => {
-    const accept = req.headers.get('accept-encoding') ?? ''
-
-    const useBrotli = accept.includes('br')
-    const useGzip = !useBrotli && accept.includes('gzip')
-    const useDeflate = !useBrotli && !useGzip && accept.includes('deflate')
-
-    if (!useBrotli && !useGzip && !useDeflate) {
-      return next(req, ctx)
-    }
-
-    const res = await next(req, ctx)
-
-    if (res.status === 304 || res.status === 204 || res.status < 200 || res.status >= 300) {
-      return res
-    }
-
-    const ce = res.headers.get('content-encoding')
-    if (ce) return res
-
-    const ct = res.headers.get('content-type') ?? ''
-    if (!ct || ct.startsWith('audio/') || ct.startsWith('video/') || ct.startsWith('image/') || ct === 'application/zip') {
-      return res
-    }
-
-    const body = await res.bytes()
-    if (body.byteLength < threshold) return res
-
-    let compressed: Buffer
-    let encoding: string
-
-    if (useBrotli) {
-      compressed = brotliCompressSync(body, {
-        params: { [constants.BROTLI_PARAM_QUALITY]: Math.min(level, 11) },
-      })
-      encoding = 'br'
-    } else if (useGzip) {
-      compressed = gzipSync(body, { level: Math.min(level, 9) })
-      encoding = 'gzip'
-    } else {
-      compressed = gzipSync(body, { level: Math.min(level, 9) })
-      encoding = 'deflate'
-    }
-
-    const headers = new Headers(res.headers)
-    headers.set('Content-Encoding', encoding)
-    headers.set('Content-Length', String(compressed.byteLength))
-    headers.delete('Content-Range')
-    headers.set('Vary', 'Accept-Encoding')
-
-    return new Response(compressed as BodyInit, {
-      status: res.status,
-      statusText: res.statusText,
-      headers,
-    })
-  }
-}

package/cookie.ts

@@ -1,58 +0,0 @@
-export interface CookieOptions {
-  domain?: string
-  path?: string
-  maxAge?: number
-  expires?: Date
-  httpOnly?: boolean
-  secure?: boolean
-  sameSite?: 'strict' | 'lax' | 'none'
-}
-
-export function getCookies(req: Request): Record<string, string> {
-  const header = req.headers.get('cookie')
-  if (!header) return {}
-
-  const cookies: Record<string, string> = {}
-  for (const pair of header.split(';')) {
-    const idx = pair.indexOf('=')
-    if (idx === -1) continue
-    const name = pair.slice(0, idx).trim()
-    const value = pair.slice(idx + 1).trim()
-    if (name) {
-      cookies[name] = decodeURIComponent(value)
-    }
-  }
-  return cookies
-}
-
-function serializeCookie(name: string, value: string, options?: CookieOptions): string {
-  const parts = [`${encodeURIComponent(name)}=${encodeURIComponent(value)}`]
-  if (options?.maxAge != null) parts.push(`Max-Age=${options.maxAge}`)
-  if (options?.expires) parts.push(`Expires=${options.expires.toUTCString()}`)
-  if (options?.domain) parts.push(`Domain=${options.domain}`)
-  if (options?.path) parts.push(`Path=${options.path}`)
-  if (options?.httpOnly) parts.push('HttpOnly')
-  if (options?.secure) parts.push('Secure')
-  if (options?.sameSite) parts.push(`SameSite=${options.sameSite}`)
-  return parts.join('; ')
-}
-
-export function setCookie(res: Response, name: string, value: string, options?: CookieOptions): Response {
-  const headers = new Headers(res.headers)
-  headers.append('Set-Cookie', serializeCookie(name, value, options))
-  return new Response(res.body, {
-    status: res.status,
-    statusText: res.statusText,
-    headers,
-  })
-}
-
-export function deleteCookie(res: Response, name: string, options?: Omit<CookieOptions, 'maxAge'>): Response {
-  const headers = new Headers(res.headers)
-  headers.append('Set-Cookie', serializeCookie(name, '', { ...options, maxAge: 0 }))
-  return new Response(res.body, {
-    status: res.status,
-    statusText: res.statusText,
-    headers,
-  })
-}

package/index.ts

@@ -1,21 +0,0 @@
-export type { Context, Handler, Middleware, ErrorHandler } from './types.ts'
-export { serve } from './serve.ts'
-export type { ServeOptions, Server } from './serve.ts'
-export { Router } from './router.ts'
-export type { WebSocketHandler, GraphQLOptions, AIHandler } from './router.ts'
-export { tsx, TsxContext, useTsx } from './tsx.ts'
-export type { TsxOptions } from './tsx.ts'
-export { auth, cors, logger } from './middleware.ts'
-export type { AuthOptions, CORSOptions, LoggerOptions } from './middleware.ts'
-export { serveStatic } from './static.ts'
-export type { ServeStaticOptions } from './static.ts'
-export { validate } from './validate.ts'
-export type { ValidationSchemas } from './validate.ts'
-export { getCookies, setCookie, deleteCookie } from './cookie.ts'
-export type { CookieOptions } from './cookie.ts'
-export { upload } from './upload.ts'
-export type { UploadOptions, UploadedFile } from './upload.ts'
-export { rateLimit } from './rate-limit.ts'
-export type { RateLimitOptions } from './rate-limit.ts'
-export { compress } from './compress.ts'
-export type { CompressOptions } from './compress.ts'

package/middleware.ts

@@ -1,178 +0,0 @@
-import type { Middleware } from './types.ts'
-
-// ── Logger ────────────────────────────────────────────────────────────────────
-
-export interface LoggerOptions {
-  format?: 'short' | 'combined'
-}
-
-export function logger(options?: LoggerOptions): Middleware {
-  return async (req, ctx, next) => {
-    const start = Date.now()
-    const url = new URL(req.url)
-    const res = await next(req, ctx)
-    const ms = Date.now() - start
-
-    if (options?.format === 'combined') {
-      console.log(`${req.method} ${url.pathname}${url.search} ${res.status} ${ms}ms`)
-    } else {
-      console.log(`${req.method} ${url.pathname} ${res.status} ${ms}ms`)
-    }
-
-    return res
-  }
-}
-
-// ── CORS ──────────────────────────────────────────────────────────────────────
-
-export interface CORSOptions {
-  origin?: string | string[] | ((origin: string) => string | boolean | undefined)
-  methods?: string[]
-  allowedHeaders?: string[]
-  exposedHeaders?: string[]
-  credentials?: boolean
-  maxAge?: number
-}
-
-export function cors(options?: CORSOptions): Middleware {
-  const opts: Required<Pick<CORSOptions, 'origin' | 'methods' | 'allowedHeaders'>> & CORSOptions = {
-    origin: '*',
-    methods: ['GET', 'HEAD', 'PUT', 'PATCH', 'POST', 'DELETE'],
-    allowedHeaders: ['Content-Type', 'Authorization'],
-    ...options,
-  }
-
-  function resolveOrigin(requestOrigin: string): string {
-    if (typeof opts.origin === 'string') return opts.origin === '*' ? '*' : opts.origin
-    if (Array.isArray(opts.origin)) {
-      return opts.origin.includes(requestOrigin) ? requestOrigin : ''
-    }
-    const result = opts.origin(requestOrigin)
-    if (typeof result === 'boolean') return result ? requestOrigin : ''
-    if (typeof result === 'string') return result
-    return ''
-  }
-
-  function setCORSHeaders(res: Response, acao: string): Response {
-    if (!acao) return res
-    const headers = new Headers(res.headers)
-    headers.set('Access-Control-Allow-Origin', acao)
-    if (opts.credentials) headers.set('Access-Control-Allow-Credentials', 'true')
-    if (opts.exposedHeaders?.length) headers.set('Access-Control-Expose-Headers', opts.exposedHeaders.join(', '))
-    headers.set('Vary', 'Origin')
-    return new Response(res.body, { status: res.status, statusText: res.statusText, headers })
-  }
-
-  return (req, ctx, next) => {
-    const requestOrigin = req.headers.get('origin') ?? ''
-    const acao = resolveOrigin(requestOrigin)
-
-    if (req.method === 'OPTIONS' && acao) {
-      const headers = new Headers()
-      headers.set('Access-Control-Allow-Origin', acao)
-      headers.set('Access-Control-Allow-Methods', opts.methods.join(', '))
-      headers.set('Access-Control-Allow-Headers', opts.allowedHeaders.join(', '))
-      if (opts.credentials) headers.set('Access-Control-Allow-Credentials', 'true')
-      if (opts.maxAge != null) headers.set('Access-Control-Max-Age', String(opts.maxAge))
-      headers.set('Vary', 'Origin')
-      return new Response(null, { status: 204, headers })
-    }
-
-    if (!acao) return next(req, ctx)
-
-    return Promise.resolve(next(req, ctx)).then((res) => setCORSHeaders(res, acao))
-  }
-}
-
-// ── Auth ───────────────────────────────────────────────────────────────────────
-
-export interface AuthOptions {
-  token?: string
-  verify?: (token: string, req: Request) => unknown | Promise<unknown>
-  proxy?: string | URL
-  header?: string
-}
-
-export function auth(options: AuthOptions): Middleware {
-  return async (req, ctx, next) => {
-    const headerName = options.header ?? 'Authorization'
-    const header = req.headers.get(headerName)
-
-    if (!header) {
-      return new Response('Unauthorized', {
-        status: 401,
-        headers: headerName.toLowerCase() === 'authorization'
-          ? { 'WWW-Authenticate': 'Bearer' }
-          : undefined,
-      })
-    }
-
-    let token = header
-    if (headerName.toLowerCase() === 'authorization') {
-      const parts = header.split(' ')
-      if (parts[0]?.toLowerCase() === 'bearer') {
-        token = parts.slice(1).join(' ')
-      }
-    }
-
-    // ── Proxy mode ──────────────────────────────────────────────────────────
-    if (options.proxy) {
-      const proxyUrl = typeof options.proxy === 'string'
-        ? new URL(options.proxy)
-        : options.proxy
-
-      const proxyHeaders: Record<string, string> = {}
-
-      if (headerName.toLowerCase() === 'authorization') {
-        proxyHeaders['Authorization'] = header
-      } else {
-        proxyUrl.searchParams.set('access_token', token)
-      }
-
-      for (const name of ['x-forwarded-for', 'x-real-ip', 'user-agent', 'content-type']) {
-        const v = req.headers.get(name)
-        if (v) proxyHeaders[name] = v
-      }
-
-      const proxyRes = await fetch(proxyUrl.href, { headers: proxyHeaders })
-
-      if (proxyRes.status >= 400) {
-        return new Response(await proxyRes.text() || 'Forbidden', { status: proxyRes.status })
-      }
-
-      let userData: unknown = undefined
-      if (proxyRes.status === 200) {
-        const ct = proxyRes.headers.get('content-type')
-        if (ct?.includes('application/json')) {
-          try { userData = await proxyRes.json() } catch {}
-        }
-      }
-
-      ctx.user = userData
-      return next(req, ctx)
-    }
-
-    // ── Static token mode ───────────────────────────────────────────────────
-    if (options.token) {
-      if (token !== options.token) {
-        return new Response('Forbidden', { status: 403 })
-      }
-      return next(req, ctx)
-    }
-
-    // ── Verify mode ─────────────────────────────────────────────────────────
-    if (options.verify) {
-      const result = await options.verify(token, req)
-      if (!result) {
-        return new Response('Forbidden', { status: 403 })
-      }
-      if (typeof result === 'object' && result !== null) {
-        ctx.user = result
-      }
-      return next(req, ctx)
-    }
-
-    // ── Trust any token (no validation configured) ─────────────────────────
-    return next(req, ctx)
-  }
-}