weifuwu 0.27.28 → 0.28.2

package/dist/middleware/compress.d.ts

@@ -1,20 +0,0 @@
-import type { Middleware } from '../types.ts';
-/** Options for {@link compress}. */
-export interface CompressOptions {
-    /** Compression level (1-9, default: 6). */
-    level?: number;
-    /** Minimum response body size in bytes to compress (default: 1024). */
-    threshold?: number;
-}
-/**
- * Response compression middleware (brotli, gzip, deflate).
- *
- * Automatically selects the best encoding based on `Accept-Encoding` header.
- * Skips compression for small responses, images, audio, video, and already-encoded responses.
- *
- * ```ts
- * import { compress } from 'weifuwu'
- * app.use(compress())
- * ```
- */
-export declare function compress(options?: CompressOptions): Middleware;

package/dist/middleware/cors.d.ts

@@ -1,25 +0,0 @@
-import type { Middleware, Context } from '../types.ts';
-/** Options for {@link cors}. */
-export interface CORSOptions {
-    /** Allowed origin(s). Default `'*'`. If `credentials: true`, reflects the request origin. */
-    origin?: string | string[] | ((origin: string) => string | boolean | undefined);
-    /** Allowed HTTP methods. Default: `GET, HEAD, PUT, PATCH, POST, DELETE`. */
-    methods?: string[];
-    /** Allowed request headers. Default: `Content-Type, Authorization`. */
-    allowedHeaders?: string[];
-    /** Exposed response headers. */
-    exposedHeaders?: string[];
-    /** Whether to expose `Access-Control-Allow-Credentials`. */
-    credentials?: boolean;
-    /** `Access-Control-Max-Age` in seconds. */
-    maxAge?: number;
-}
-/**
- * CORS middleware.
- *
- * ```ts
- * import { cors } from 'weifuwu'
- * app.use(cors({ origin: 'https://myapp.com', credentials: true }))
- * ```
- */
-export declare function cors(options?: CORSOptions): Middleware<Context, Context>;

package/dist/middleware/health.d.ts

@@ -1,24 +0,0 @@
-import { Router } from '../core/router.ts';
-/** Options for {@link health}. */
-export interface HealthOptions {
-    /** Health check endpoint path (default: `'/__health'`). */
-    path?: string;
-    /** Async function that throws if the service is unhealthy. Called on each request. */
-    check?: () => Promise<void>;
-}
-/**
- * Health check endpoint.
- *
- * Returns 200 with `'OK'` if the check passes, 503 if it fails.
- *
- * ```ts
- * import { health } from 'weifuwu'
- *
- * app.use(health({
- *   check: async () => {
- *     await db.query('SELECT 1')
- *   },
- * }))
- * ```
- */
-export declare function health(options?: HealthOptions): Router;

package/dist/middleware/helmet.d.ts

@@ -1,33 +0,0 @@
-import type { Middleware, Context } from '../types.ts';
-/** Options for {@link helmet}. Set any header to `false` to omit it. */
-export interface HelmetOptions {
-    /** `Content-Security-Policy` header value. */
-    contentSecurityPolicy?: string | false;
-    /** `Cross-Origin-Embedder-Policy` header value. */
-    crossOriginEmbedderPolicy?: string | false;
-    /** `Cross-Origin-Opener-Policy` header value. */
-    crossOriginOpenerPolicy?: string | false;
-    /** `Cross-Origin-Resource-Policy` header value. */
-    crossOriginResourcePolicy?: string | false;
-    /** `Origin-Agent-Cluster` header value. */
-    originAgentCluster?: string | false;
-    /** `Referrer-Policy` header value. */
-    referrerPolicy?: string | false;
-    /** `Strict-Transport-Security` header value. */
-    strictTransportSecurity?: string | false;
-    /** `X-Content-Type-Options` header value. */
-    xContentTypeOptions?: string | false;
-    /** `X-DNS-Prefetch-Control` header value. */
-    xDnsPrefetchControl?: string | false;
-    /** `X-Download-Options` header value. */
-    xDownloadOptions?: string | false;
-    /** `X-Frame-Options` header value. */
-    xFrameOptions?: string | false;
-    /** `X-Permitted-Cross-Domain-Policies` header value. */
-    xPermittedCrossDomainPolicies?: string | false;
-    /** `X-XSS-Protection` header value. */
-    xXssProtection?: string | false;
-    /** `Permissions-Policy` header value. */
-    permissionsPolicy?: string | false;
-}
-export declare function helmet(options?: HelmetOptions): Middleware<Context, Context>;

package/dist/middleware/rate-limit.d.ts

@@ -1,44 +0,0 @@
-import type { Redis, Context, Middleware, Closeable } from '../types.ts';
-/** Options for {@link rateLimit}. */
-export interface RateLimitOptions {
-    /** Maximum requests within the window (default: 100). */
-    max?: number;
-    /** Window duration in ms (default: 60000 = 1 minute). */
-    window?: number;
-    /** Custom key function. Default: IP from `x-forwarded-for` or `x-real-ip` or `cf-connecting-ip`. */
-    key?: (req: Request, ctx: Context) => string;
-    /** Custom 429 response body." */
-    message?: string;
-    /** Store backend. `'memory'` (default) or `'redis'`. */
-    store?: 'memory' | 'redis';
-    /** Redis client (required when `store: 'redis'`). */
-    redis?: Redis;
-    /** Redis key prefix (default: `'ratelimit:'`). */
-    prefix?: string;
-}
-/** Rate limit module — middleware + stats. */
-export interface RateLimitModule extends Middleware<Context, Context>, Closeable {
-    stats(): {
-        store: string;
-        entries?: number;
-        maxEntries: number;
-    };
-}
-/**
- * Rate limiting middleware (in-memory or Redis-backed).
- *
- * Limits requests per key (default: client IP) within a rolling window.
- * Returns 429 when the limit is exceeded, with `Retry-After` header.
- *
- * ```ts
- * import { rateLimit } from 'weifuwu'
- *
- * // In-memory (single process)
- * app.use(rateLimit({ max: 60, window: 60_000 }))
- *
- * // Redis-backed (multi-process)
- * import { Redis } from 'ioredis'
- * app.use(rateLimit({ store: 'redis', redis: new Redis(), max: 100 }))
- * ```
- */
-export declare function rateLimit(options?: RateLimitOptions): RateLimitModule;

package/dist/middleware/request-id.d.ts

@@ -1,40 +0,0 @@
-import type { Context, Middleware } from '../types.ts';
-declare module '../types.ts' {
-    interface Context {
-        requestId: string;
-    }
-}
-/** Options for {@link requestId}. */
-/** Request ID module — a {@link Middleware} that injects `ctx.requestId`. */
-export type RequestIdModule = Middleware<Context, Context & {
-    requestId: string;
-}>;
-export interface RequestIdOptions {
-    /** Header name for request ID (default: `'X-Request-ID'`). */
-    header?: string;
-    /** Custom ID generator (default: `crypto.randomUUID`). */
-    generator?: () => string;
-}
-/**
- * Request ID middleware.
- *
- * @deprecated Use `trace()` from 'weifuwu' instead — it injects `ctx.trace.requestId`
- * along with `traceId` and `elapsed()` in a single middleware.
- *
- * ```ts
- * // Old:
- * app.use(requestId())
- * 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/middleware/static.d.ts

@@ -1,23 +0,0 @@
-import type { Handler } from '../types.ts';
-/** Options for {@link serveStatic}. */
-export interface ServeStaticOptions {
-    /** Directory index filename (default: `'index.html'`). */
-    index?: string;
-    /** `Cache-Control max-age` in seconds. */
-    maxAge?: number;
-    /** Add `immutable` to `Cache-Control` (requires `maxAge`). */
-    immutable?: boolean;
-}
-/**
- * Static file serving handler.
- *
- * Serves files from a root directory. Supports ETag/304, directory index,
- * Content-Type detection by extension, and directory traversal protection.
- *
- * ```ts
- * import { serveStatic, Router } from 'weifuwu'
- * const app = new Router()
- * app.get('/static/*', serveStatic('./public'))
- * ```
- */
-export declare function serveStatic(root: string, options?: ServeStaticOptions): Handler;

package/dist/middleware/upload.d.ts

@@ -1,55 +0,0 @@
-import type { Context, Middleware } from '../types.ts';
-declare module '../types.ts' {
-    interface Context {
-        parsed: Record<string, unknown>;
-    }
-}
-/** Upload middleware — a {@link Middleware} that injects `ctx.parsed` with file fields. */
-export type UploadModule = Middleware<Context, Context & {
-    parsed: Record<string, unknown>;
-}>;
-/** A parsed file from a multipart upload. */
-export interface UploadedFile {
-    /** Original filename from the client. */
-    name: string;
-    /** MIME type from the `Content-Type` part header. */
-    type: string;
-    /** File size in bytes. */
-    size: number;
-    /** Path where the file was saved (when `dir` option is set). */
-    path?: string;
-    /** File content as Buffer (when `dir` option is not set). */
-    buffer?: Buffer;
-}
-/** Options for {@link upload}. */
-export interface UploadOptions {
-    /** Directory to save uploaded files. If not set, files stay in memory via `.buffer`. */
-    dir?: string;
-    /** Maximum file size in bytes. Default: 10 MB. Set `0` to allow unlimited. */
-    maxFileSize?: number;
-    /** Allowed MIME types (e.g. `['image/jpeg', 'image/png']`). Empty array allows all. */
-    allowedTypes?: string[];
-}
-/**
- * Multipart file upload middleware.
- *
- * Parses `multipart/form-data` requests, extracting files and fields.
- * Files can be saved to disk (`dir` option) or kept in memory as Buffers.
- * Parsed fields are available in `ctx.parsed`.
- *
- * ```ts
- * import { upload } from 'weifuwu'
- *
- * // Save to disk
- * app.use(upload({ dir: './uploads', maxFileSize: 5_000_000 }))
- *
- * // In-memory
- * app.post('/upload', async (req, ctx) => {
- *   const file = ctx.parsed?.file as UploadedFile
- *   console.log(file.name, file.type, file.buffer!.length)
- * })
- * ```
- */
-export declare function upload(options?: UploadOptions): Middleware<Context, Context & {
-    parsed: Record<string, unknown>;
-}>;

package/dist/middleware/validate.d.ts

@@ -1,32 +0,0 @@
-import type { ZodSchema } from 'zod';
-import type { Middleware } from '../types.ts';
-declare module '../types.ts' {
-    interface Context {
-        parsed: Record<string, unknown>;
-    }
-}
-/** Validation middleware — a {@link Middleware} that injects `ctx.parsed` with validated data. */
-export type ValidateModule = Middleware;
-export interface ValidationSchemas {
-    body?: ZodSchema;
-    query?: ZodSchema;
-    params?: ZodSchema;
-    headers?: ZodSchema;
-}
-/**
- * Request validation middleware using Zod schemas.
- *
- * Validates `params`, `query`, `body`, and/or `headers` against schemas.
- * Returns 422 with error details on mismatch.
- * Injects `ctx.parsed` with validated-and-transformed values.
- *
- * ```ts
- * import { z } from 'zod'
- *
- * app.get('/users/:id', validate({
- *   params: z.object({ id: z.string() }),
- *   query: z.object({ include: z.string().optional() }),
- * }), handler)
- * ```
- */
-export declare function validate(schemas?: ValidationSchemas): Middleware;

package/dist/postgres/client.d.ts

@@ -1,4 +0,0 @@
-import type { PostgresOptions, PostgresClient } from './types.ts';
-/** Migration tracking table name. Created automatically on first migrate(). */
-export declare const MIGRATIONS_TABLE = "_weifuwu_migrations";
-export declare function postgres(opts?: string | PostgresOptions): PostgresClient;

package/dist/postgres/index.d.ts

@@ -1,3 +0,0 @@
-export { postgres, MIGRATIONS_TABLE } from './client.ts';
-export { PgModule } from './module.ts';
-export type { PostgresOptions, PostgresClient, PostgresInjected } from './types.ts';

package/dist/postgres/module.d.ts

@@ -1,12 +0,0 @@
-import type { SqlClient, Closeable } from '../types.ts';
-import type { PostgresClient } from './types.ts';
-export declare class PgModule implements Closeable {
-    protected sql: SqlClient;
-    protected pg: PostgresClient;
-    constructor(pg: PostgresClient);
-    transaction<T>(fn: (sql: SqlClient) => Promise<T>, retryOpts?: {
-        maxRetries?: number;
-    }): Promise<T>;
-    migrate(): Promise<void>;
-    close(): Promise<void>;
-}

package/dist/postgres/types.d.ts

@@ -1,42 +0,0 @@
-import type { SqlClient, Context, Middleware, Closeable } from '../types.ts';
-declare module '../types.ts' {
-    interface Context {
-        sql: SqlClient;
-    }
-}
-export interface PostgresInjected {
-    sql: SqlClient;
-}
-export interface PostgresOptions {
-    connection?: string | Record<string, unknown>;
-    signal?: AbortSignal;
-    closeTimeout?: number;
-    max?: number;
-    ssl?: boolean | Record<string, unknown>;
-    idle_timeout?: number;
-    connect_timeout?: number;
-    /** Per-statement timeout in ms. Set to 0 to disable. Default: 30_000. */
-    statementTimeout?: number;
-    /** Called after every query completes. Receives query text, duration in ms, and row count. */
-    onQuery?: (query: string, durationMs: number, rowCount: number) => void;
-}
-export interface PostgresClient extends Middleware<Context, Context & PostgresInjected>, Closeable {
-    sql: SqlClient;
-    /** Creates the migration tracking table (_weifuwu_migrations). Called once at startup. */
-    migrate: () => Promise<void>;
-    /** Record that a module's migration has been applied (idempotent). */
-    markMigrated: (moduleName: string) => Promise<void>;
-    /** Check whether a module has already been migrated. */
-    isMigrated: (moduleName: string) => Promise<boolean>;
-    transaction: <T>(fn: (sql: any) => Promise<T>, retryOpts?: {
-        maxRetries?: number;
-    }) => Promise<T>;
-    /** Snapshot of connection pool state: active, idle, waiting, max connections. */
-    poolStats: () => {
-        active: number;
-        idle: number;
-        waiting: number;
-        max: number;
-    };
-    close: () => Promise<void>;
-}

package/dist/queue/cron.d.ts

@@ -1,9 +0,0 @@
-/**
- * Cron expression parsing utilities (moved from cron-utils.ts).
- * Used internally by queue for scheduled job execution.
- *
- * All functions operate in local timezone.
- */
-export declare function parsePattern(pattern: string): Set<number>[];
-export declare function matches(fields: Set<number>[], date: Date): boolean;
-export declare function cronNext(expr: string, from?: Date): number;

package/dist/queue/index.d.ts

@@ -1,2 +0,0 @@
-import type { Queue, QueueOptions } from './types.ts';
-export declare function queue(opts?: QueueOptions): Queue;

package/dist/queue/types.d.ts

@@ -1,61 +0,0 @@
-import type { Redis, Context, Middleware, Closeable } from '../types.ts';
-declare module '../types.ts' {
-    interface Context {
-        queue: Queue;
-    }
-}
-export interface QueueJob<T = unknown> {
-    id: string;
-    type: string;
-    payload: T;
-    createdAt: number;
-    runAt: number;
-    schedule?: string;
-}
-export interface QueueOptions {
-    /** Backend store. Default: 'memory'. */
-    store?: 'memory' | 'pg' | 'redis';
-    redis?: Redis;
-    url?: string;
-    prefix?: string;
-    pollInterval?: number;
-    /** PostgreSQL client (required when store: 'pg'). */
-    pg?: {
-        sql: import('../types.ts').SqlClient;
-    };
-}
-export interface QueueInjected {
-    queue: Queue;
-}
-export interface QueueJobWithError<T = unknown> extends QueueJob<T> {
-    error: string;
-    failedAt: number;
-}
-export interface Queue extends Middleware<Context, Context & QueueInjected>, Closeable {
-    /** Register a cron job. Uses queue's backend (memory/pg/redis) for execution. */
-    cron(pattern: string, handler: () => void | Promise<void>): {
-        stop: () => void;
-    };
-    add<T>(type: string, payload: T, opts?: {
-        delay?: number;
-        schedule?: string;
-    }): Promise<string>;
-    process<T>(type: string, handler: (job: QueueJob<T>) => Promise<void>): void;
-    run(): Promise<void>;
-    stats(): {
-        running: boolean;
-        inflight: number;
-        processed: number;
-        failed: number;
-        handlers: number;
-        maxConcurrent: number;
-    };
-    jobs(limit?: number): Promise<QueueJob[]>;
-    failedJobs(limit?: number): Promise<QueueJobWithError[]>;
-    retryFailed(jobId: string): Promise<boolean>;
-    retryAllFailed(type?: string): Promise<number>;
-    dashboard(): import('../core/router.ts').Router;
-    /** Create the jobs table (PG mode only; safe to call multiple times). */
-    migrate?(): Promise<void>;
-    close(): Promise<void>;
-}

package/dist/redis/client.d.ts

@@ -1,2 +0,0 @@
-import type { RedisOptions, RedisClient } from './types.ts';
-export declare function redis(opts?: string | RedisOptions): RedisClient;

package/dist/redis/index.d.ts

@@ -1,2 +0,0 @@
-export { redis } from './client.ts';
-export type { RedisOptions, RedisClient, RedisInjected } from './types.ts';

package/dist/redis/types.d.ts

@@ -1,17 +0,0 @@
-import type { Redis, RedisOptions as IORedisOptions, Context, Middleware, Closeable } from '../types.ts';
-declare module '../types.ts' {
-    interface Context {
-        redis: Redis;
-    }
-}
-export type { Redis };
-export type RedisOptions = IORedisOptions & {
-    url?: string;
-};
-export interface RedisInjected {
-    redis: Redis;
-}
-export interface RedisClient extends Middleware<Context, Context & RedisInjected>, Closeable {
-    redis: Redis;
-    close: () => Promise<void>;
-}

package/dist/test/test-utils.d.ts

@@ -1,193 +0,0 @@
-import type { Context, Handler, SqlClient } from '../types.ts';
-import { Router } from '../core/router.ts';
-import { WebSocket as WSWebSocket } from 'ws';
-export interface TestResponse {
-    readonly status: number;
-    readonly headers: Headers;
-    json<T = unknown>(): Promise<T>;
-    text(): Promise<string>;
-}
-export declare class TestRequest {
-    private headers;
-    private ctxMixin;
-    private bodyData;
-    private app;
-    private method;
-    private path;
-    constructor(app: TestApp, method: string, path: string);
-    /** Set a request header */
-    header(name: string, value: string): this;
-    /** Mix properties into ctx (simulating middleware injection) */
-    with(mixin: Partial<Context>): this;
-    /** Shortcut: set ctx.user */
-    withUser(user: unknown): this;
-    /** Shortcut: set ctx.tenant */
-    withTenant(tenant: {
-        id: string;
-        name: string;
-        role: string;
-    }): this;
-    /** Set JSON request body */
-    body(data: unknown): this;
-    /** Set raw text body */
-    rawBody(data: string): this;
-    /** Send the request and return the response */
-    send(): Promise<TestResponse>;
-}
-export declare class TestApp {
-    private router;
-    private wsServer;
-    private wsConnections;
-    constructor();
-    /**
-     * Register a WebSocket handler.
-     */
-    ws(path: string, handler: import('../core/router.ts').WebSocketHandler): this;
-    /** Get the raw Router (for advanced use). */
-    get _router(): Router;
-    /** Add global middleware */
-    use(mw: any): this;
-    /** Register a GET route — supports route-level middleware via spread args. */
-    get(path: string, ...args: any[]): this;
-    /** Register a POST route. */
-    post(path: string, ...args: any[]): this;
-    /** Register a PUT route. */
-    put(path: string, ...args: any[]): this;
-    /** Register a PATCH route. */
-    patch(path: string, ...args: any[]): this;
-    /** Register a DELETE route. */
-    delete(path: string, ...args: any[]): this;
-    /** Start building a GET request */
-    getReq(path: string): TestRequest;
-    /** Start building a POST request */
-    postReq(path: string): TestRequest;
-    /** Start building a PUT request */
-    putReq(path: string): TestRequest;
-    /** Start building a PATCH request */
-    patchReq(path: string): TestRequest;
-    /** Start building a DELETE request */
-    deleteReq(path: string): TestRequest;
-    /** Get the underlying handler (for advanced usage) */
-    handler(): Handler;
-    /** Start building a WebSocket connection to the given path. */
-    wsReq(path: string): TestWSRequest;
-    /**
-     * Internal: ensure HTTP server is running for WebSocket connections.
-     * Starts on a random port.
-     */
-    _ensureServer(): Promise<string>;
-    /**
-     * Internal: register a WS connection for cleanup.
-     */
-    _trackConnection(conn: TestWSConnection): void;
-    /**
-     * Cleanup all WebSocket connections and stop the server.
-     */
-    close(): Promise<void>;
-}
-/** Start building a WebSocket test connection. */
-export declare class TestWSRequest {
-    private app;
-    private path;
-    private _timeout;
-    constructor(app: TestApp, path: string);
-    /** Set the timeout for operations (default: 5000ms). */
-    timeout(ms: number): this;
-    /**
-     * Connect to the WebSocket endpoint.
-     * Starts a real HTTP server (random port) if not already running.
-     */
-    connect(): Promise<TestWSConnection>;
-}
-/**
- * A connected WebSocket for testing.
- *
- * ```ts
- * const conn = await app.wsReq('/echo').connect()
- * conn.send('hello')
- * const msg = await conn.receive()
- * assert.equal(msg, 'hello')
- * conn.close()
- * ```
- */
-export declare class TestWSConnection {
-    private ws;
-    private _timeout;
-    private messageQueue;
-    private resolveQueue;
-    private _closed;
-    constructor(ws: WSWebSocket, timeout?: number);
-    /** Send a text message. */
-    send(data: string): void;
-    /** Send a JSON message. */
-    json(data: unknown): void;
-    /**
-     * Wait for the next message. Returns the raw text.
-     * Throws on timeout or if the connection is closed.
-     */
-    receive(timeout?: number): Promise<string>;
-    /** Wait for the next message and parse as JSON. */
-    receiveJson<T = unknown>(): Promise<T>;
-    /**
-     * Assert that no message is received within the given silence period.
-     * Useful for verifying that something did NOT happen.
-     */
-    expectSilent(ms: number): Promise<void>;
-    /** Close the connection. */
-    close(): void;
-    /** Whether the connection is closed. */
-    get closed(): boolean;
-}
-/** Create a new test app */
-export declare function testApp(): TestApp;
-/**
- * Result of createTestDb().
- */
-export interface TestDb {
-    /** Tagged-template SQL client connected to the test database. */
-    sql: SqlClient;
-    /** Connection URL of the test database. */
-    url: string;
-    /** Schema name used for this test session. */
-    schema: string;
-    /** Destroy the test database (drop schema). */
-    destroy: () => Promise<void>;
-}
-/**
- * Create an isolated test database schema for integration testing.
- *
- * Uses PostgreSQL schemas for isolation — no separate database needed.
- * Each call creates a unique schema under the same database.
- *
- * ```ts
- * const db = await createTestDb()
- * await db.sql`CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT)`
- * // ... run tests ...
- * await db.destroy()  // drops the schema
- * ```
- *
- * Uses `TEST_DATABASE_URL` or `DATABASE_URL` env var.
- */
-export declare function createTestDb(options?: {
-    /** Database URL. Default: TEST_DATABASE_URL or DATABASE_URL. */
-    url?: string;
-    /** Schema name. Default: auto-generated 'test_<timestamp>_<random>'. */
-    schema?: string;
-}): Promise<TestDb>;
-/**
- * Run a test callback within an isolated transaction that is rolled back
- * after completion. This provides the fastest isolation — no cleanup needed.
- *
- * ```ts
- * await withTestDb(async (sql) => {
- *   await sql`INSERT INTO users ...`
- *   // All changes are rolled back after this callback returns
- * })
- * ```
- *
- * @param optionsOrFn Either a URL string or options object, or the callback directly.
- * @param fn Async callback receiving a tagged-template sql client.
- */
-export declare function withTestDb(optionsOrFn: string | {
-    url?: string;
-} | ((sql: SqlClient) => Promise<void>), fn?: (sql: SqlClient) => Promise<void>): Promise<void>;