weifuwu 0.23.4 → 0.24.0

package/dist/rate-limit.d.ts

@@ -35,5 +35,6 @@ export interface RateLimitOptions {
  * ```
  */
 export declare function rateLimit(options?: RateLimitOptions): Middleware & {
-    stop: () => void;
+    close: () => void;
+    stop?: () => void;
 };

package/dist/request-id.d.ts

@@ -1,4 +1,9 @@
 import type { Context, Middleware } from './types.ts';
+declare module './types.ts' {
+    interface Context {
+        requestId: string;
+    }
+}
 /** Options for {@link requestId}. */
 export interface RequestIdOptions {
     /** Header name for request ID (default: `'X-Request-ID'`). */
@@ -9,18 +14,22 @@ export interface RequestIdOptions {
 /**
  * Request ID middleware.
  *
- * Reads an incoming `X-Request-ID` header (or custom header name) from the
- * request. If absent, generates a new UUID. Sets the response header and
- * injects `ctx.requestId`.
+ * @deprecated Use `trace()` from 'weifuwu' instead — it injects `ctx.trace.requestId`
+ * along with `traceId` and `elapsed()` in a single middleware.
  *
  * ```ts
- * import { requestId } from 'weifuwu'
+ * // Old:
  * app.use(requestId())
+ * ctx.requestId
  *
- * app.get('/', (req, ctx) => {
- *   console.log('request ID:', ctx.requestId)
- * })
+ * // New:
+ * app.use(trace())
+ * ctx.trace.requestId
  * ```
+ *
+ * Reads an incoming `X-Request-ID` header (or custom header name) from the
+ * request. If absent, generates a new UUID. Sets the response header and
+ * injects `ctx.requestId`.
  */
 export declare function requestId(options?: RequestIdOptions): Middleware<Context, Context & {
     requestId: string;

package/dist/router.d.ts

@@ -25,6 +25,9 @@ export declare class Router<T extends Context = Context> {
     use<Out extends Context>(mw: Middleware<Context, Out>): Router<T & Out>;
     use(path: string, mw: Middleware<T, T>): Router<T>;
     use(path: string, router: Router<any>): Router<T>;
+    use(mod: Router & {
+        middleware: () => Middleware;
+    }): Router<T>;
     get(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<any>]): Router<T>;
     post(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<any>]): Router<T>;
     put(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<any>]): Router<T>;

package/dist/theme.d.ts

@@ -1,8 +1,31 @@
-import type { Middleware } from './types.ts';
+import type { Context, Middleware } from './types.ts';
+import { Router } from './router.ts';
+declare module './types.ts' {
+    interface Context {
+        theme: ThemeInjected;
+    }
+}
+export interface ThemeInjected {
+    value: string;
+    set: (value: string, loc?: string) => Response;
+}
 export interface ThemeOptions {
     /** Default theme value (default: 'system'). */
     default?: string;
     /** Cookie name (default: 'theme'). Set to empty string to disable cookie. */
     cookie?: string;
 }
-export declare function theme(options?: ThemeOptions): Middleware;
+/**
+ * Theme module. Returns a Router with an attached `.middleware()` method.
+ *
+ * ```ts
+ * const t = theme()
+ * app.use(t.middleware())  // → ctx.theme = { value, set }
+ * app.use('/', t)          // → GET /__theme/dark (switch route)
+ * ```
+ */
+export interface ThemeModule extends Router {
+    /** Middleware that injects `ctx.theme = { value, set }`. */
+    middleware: () => Middleware<Context, Context & ThemeInjected>;
+}
+export declare function theme(options?: ThemeOptions): ThemeModule;

package/dist/trace.d.ts

@@ -1,3 +1,19 @@
+import type { Context, Middleware } from './types.ts';
+declare module './types.ts' {
+    interface Context {
+        trace: TraceInjected;
+    }
+}
+export interface TraceInjected {
+    /** Unique request identifier (from X-Request-ID header or auto-generated). */
+    requestId: string;
+    /** Unique trace identifier for the request. */
+    traceId: string;
+    /** Milliseconds elapsed since the trace started. */
+    elapsed: () => number;
+    /** Timestamp (ms) when the trace started. */
+    startTime: number;
+}
 export interface TraceContext {
     /** Unique identifier for the current request trace. */
     traceId: string;
@@ -49,3 +65,31 @@ export declare function runWithTrace<T>(incomingTraceId: string | null, fn: () =
  * ```
  */
 export declare function traceElapsed(): number;
+/** Options for {@link trace}. */
+export interface TraceOptions {
+    /** Header name for request ID (default: `'X-Request-ID'`). */
+    header?: string;
+    /** Custom ID generator (default: `crypto.randomUUID`). */
+    generator?: () => string;
+}
+/**
+ * Request tracing middleware.
+ *
+ * Injects `ctx.trace = { requestId, traceId, elapsed, startTime }`.
+ * Reads/writes `X-Request-ID` header. Combines the functionality of `requestId()`
+ * with the per-request tracing from `AsyncLocalStorage`.
+ *
+ * ```ts
+ * import { trace } from 'weifuwu'
+ * app.use(trace())
+ *
+ * app.get('/', (req, ctx) => {
+ *   console.log(ctx.trace.requestId)  // 550e8400-e29b-...
+ *   console.log(ctx.trace.traceId)    // same as currentTraceId()
+ *   console.log(ctx.trace.elapsed())  // ms since request start
+ * })
+ * ```
+ */
+export declare function trace(options?: TraceOptions): Middleware<Context, Context & {
+    trace: TraceInjected;
+}>;

package/dist/types.d.ts

@@ -1,24 +1,7 @@
 export interface Context {
     params: Record<string, string>;
     query: Record<string, string>;
-    user?: unknown;
-    parsed?: Record<string, unknown>;
     mountPath?: string;
-    theme?: {
-        value: string;
-        set?: (value: string, loc?: string) => Response;
-    };
-    flash?: {
-        value: unknown;
-        set: (data: unknown, location?: string) => Response;
-    };
-    i18n?: {
-        locale: string;
-        messages?: Record<string, unknown>;
-        t: (key: string, params?: Record<string, string>, fallback?: string) => string;
-        set?: (value: string, loc?: string) => Response;
-    };
-    env?: Record<string, string>;
     layoutStack?: {
         path: string;
         component: any;

package/dist/upload.d.ts

@@ -1,4 +1,9 @@
 import type { Middleware } from './types.ts';
+declare module './types.ts' {
+    interface Context {
+        parsed: Record<string, unknown>;
+    }
+}
 /** A parsed file from a multipart upload. */
 export interface UploadedFile {
     /** Original filename from the client. */

package/dist/user/client.d.ts

@@ -1,17 +1,25 @@
 import type { UserOptions, UserModule } from './types.ts';
 /**
  * User authentication module — local register/login, JWT verification, OAuth2 server, social login.
+ * Supports DB-less auth via tokens/verify/proxy options.
  *
  * ```ts
+ * // Full auth with DB
  * import { user, postgres } from 'weifuwu'
- *
  * const pg = postgres({ connection: DATABASE_URL })
  * const auth = user({ pg, jwtSecret: process.env.JWT_SECRET })
  *
  * await auth.migrate()
+ * app.use(auth.middleware())   // inject ctx.user
+ * app.use('/', auth)           // /register, /login
+ *
+ * // DB-less token auth
+ * const auth = user({ tokens: ['sk-123', 'sk-456'] })
+ * app.use(auth.middleware())   // injects ctx.user for valid tokens
  *
- * app.use(auth.middleware())   // inject `ctx.user` on every request
- * app.use('/', auth)           // mount auth routes: /register, /login
+ * // DB-less custom verify
+ * const auth = user({ verify: async (token) => validateToken(token) })
+ * app.use(auth.middleware())
  * ```
  */
 export declare function user(options: UserOptions): UserModule;

package/dist/user/types.d.ts

@@ -58,14 +58,29 @@ export interface OAuthProviderConfig {
 }
 /** Options for {@link user}. */
 export interface UserOptions {
-    /** PostgreSQL client for user storage. */
-    pg: PostgresClient;
-    /** Secret key for JWT signing. */
-    jwtSecret: string;
+    /** PostgreSQL client for user storage. Omit for DB-less token/verify/proxy auth. */
+    pg?: PostgresClient;
+    /** Secret key for JWT signing. Required for JWT auth and login/register routes. */
+    jwtSecret?: string;
     /** Custom table name for users (default: `'users'`). */
     table?: string;
     /** JWT expiration time (default: `'7d'`). */
     expiresIn?: string | number;
+    /** Static token(s) for simple bearer auth. No DB or JWT needed. */
+    tokens?: string[];
+    /** Custom verify function. Receives the token and request, returns user data or null. */
+    verify?: (token: string, req: Request) => unknown | Promise<unknown>;
+    /** Proxy auth — forward request to an external auth service for validation. */
+    proxy?: string | URL;
+    /** Custom header name for token extraction (default: `'Authorization'`). */
+    header?: string;
+    /**
+     * Function to load user data from a user ID stored in the session.
+     * Called when `ctx.session.userId` is present. Only used when `pg` is not provided.
+     * Return a falsy value to reject (e.g. if the user was deleted).
+     * If not provided and no pg, `ctx.user` is set to `{ id: userId }`.
+     */
+    resolveUser?: (userId: unknown) => unknown | Promise<unknown>;
     /** Enable OAuth2 server mode (authorization code flow). */
     oauth2?: OAuth2ServerOptions;
     /**

package/dist/validate.d.ts

@@ -1,5 +1,10 @@
 import type { ZodSchema } from 'zod';
 import type { Middleware } from './types.ts';
+declare module './types.ts' {
+    interface Context {
+        parsed: Record<string, unknown>;
+    }
+}
 export interface ValidationSchemas {
     body?: ZodSchema;
     query?: ZodSchema;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weifuwu",
-  "version": "0.23.4",
+  "version": "0.24.0",
   "description": "Web-standard HTTP framework for Node.js — (req, ctx) => Response",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",