weifuwu 0.25.2 → 0.27.0

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/types.d.ts

@@ -1,18 +0,0 @@
-import type { Redis, RedisOptions as IORedisOptions } from '../vendor.ts';
-import type { 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/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/router.d.ts

@@ -1,73 +0,0 @@
-import type { WebSocket } from './vendor.ts';
-import { type IncomingMessage } from 'node:http';
-import type { Duplex } from 'node:stream';
-import type { Context, Handler, Middleware, ErrorHandler } from './types.ts';
-import { type Hub } from './hub.ts';
-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>;
-};
-type WsUpgradeHandler = (req: IncomingMessage, socket: Duplex, head: Buffer) => void;
-export declare class Router<T extends Context = Context> {
-    private root;
-    private wsRoot;
-    private globalMws;
-    private errorHandler?;
-    private _hasWildcard;
-    private _hub?;
-    private _wss?;
-    /** Track which ctx fields have been injected so far (for dependency checking). */
-    private _ctxFields;
-    private get wss();
-    private get hub();
-    /** Inject a custom hub (e.g. with Redis for cross-process broadcast). */
-    wsHub(hub: Hub): this;
-    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<Context>): Router<T>;
-    use(mod: Router & {
-        middleware: () => Middleware;
-    }): Router<T>;
-    /**
-     * Check a middleware's dependency metadata and emit warnings if
-     * required fields haven't been injected yet.
-     * Attach __meta to a middleware function:
-     *
-     * ```ts
-     * mw.__meta = { injects: ['sql'], depends: ['session'] }
-     * ```
-     */
-    private _checkMiddlewareMeta;
-    get(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
-    post(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
-    put(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
-    delete(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
-    patch(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
-    head(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
-    options(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
-    all(path: string, ...args: [...Middleware<T, T>[], Handler<T> | Router<Context>]): Router<T>;
-    onError(handler: ErrorHandler<T>): Router<T>;
-    private _route;
-    /** Internal route registration — no type constraints (used by _mountRouter). */
-    private _routeImpl;
-    ws(path: string, ...args: [...Middleware<T, T>[], WebSocketHandler]): Router<T>;
-    handler(): Handler<T>;
-    /** Returns a human-readable list of all registered routes. Useful for debugging. */
-    routes(): string[];
-    private _collectRoutes;
-    private _collectWsRoutes;
-    websocketHandler(): WsUpgradeHandler;
-    private _mountRouter;
-    private mergeMws;
-    private _collect;
-    private _collectWs;
-    private splitPath;
-    private matchTrie;
-    private matchWsTrie;
-    private handleError;
-    private handle;
-    private runChain;
-}
-export {};

package/dist/s3.d.ts

@@ -1,68 +0,0 @@
-import { S3Client } from '@aws-sdk/client-s3';
-import type { Middleware } from './types.ts';
-import type { Readable } from 'node:stream';
-declare module './types.ts' {
-    interface Context {
-        s3: S3Module;
-    }
-}
-export interface S3Options {
-    /** S3 bucket name. Required. */
-    bucket: string;
-    /** AWS region. Default: 'us-east-1'. */
-    region?: string;
-    /** Custom endpoint (MinIO, Cloudflare R2, Backblaze B2, etc.). */
-    endpoint?: string;
-    /** Force path-style addressing (required for MinIO, some private clouds). */
-    forcePathStyle?: boolean;
-    /** AWS credentials. Falls back to AWS env vars / IAM role if omitted. */
-    credentials?: {
-        accessKeyId: string;
-        secretAccessKey: string;
-    };
-    /**
-     * Base public URL for unsigned URLs.
-     * When set, `s3.url(key, { expiresIn: 0 })` returns a public URL.
-     * Example: 'https://cdn.example.com' or 'https://pub-xxx.r2.dev'
-     */
-    publicUrl?: string;
-}
-export interface S3PutOptions {
-    /** Content-Type of the object. */
-    contentType?: string;
-    /** Cache-Control header value. */
-    cacheControl?: string;
-    /** User-defined metadata (prefix x-amz-meta-). */
-    metadata?: Record<string, string>;
-}
-export interface S3UrlOptions {
-    /**
-     * Signed URL expiry in seconds.
-     * Default: 3600 (1 hour).
-     * Set to 0 to return an unsigned public URL (requires `publicUrl` option).
-     */
-    expiresIn?: number;
-}
-export interface S3Module {
-    /** Upload a file. Returns the key. */
-    put(key: string, body: S3Body, options?: S3PutOptions): Promise<string>;
-    /** Download a file. Returns the body as Buffer, or null if not found. */
-    get(key: string): Promise<Buffer | null>;
-    /** Delete a file. */
-    delete(key: string): Promise<void>;
-    /** Check if a file exists. */
-    exists(key: string): Promise<boolean>;
-    /**
-     * Generate a URL for an object.
-     * - If `expiresIn` > 0 (default): returns a signed URL with that expiry.
-     * - If `expiresIn` === 0 and `publicUrl` is configured: returns an unsigned
-     *   public URL. Throws if `publicUrl` is not set.
-     */
-    url(key: string, options?: S3UrlOptions): Promise<string>;
-    /** List object keys under a prefix. */
-    list(prefix?: string): Promise<string[]>;
-    /** The underlying S3Client (for advanced usage). */
-    client: S3Client;
-}
-export type S3Body = Buffer | Uint8Array | string | ReadableStream | Readable;
-export declare function s3(options: S3Options): S3Module & Middleware;

package/dist/seo.d.ts

@@ -1,104 +0,0 @@
-import type { Middleware, Context } from './types.ts';
-import { Router } from './router.ts';
-/** A rule in `robots.txt`. */
-export interface RobotsRule {
-    /** User-agent this rule applies to (default: `'*'`). */
-    userAgent?: string;
-    /** Path(s) to allow. */
-    allow?: string | string[];
-    /** Path(s) to disallow. */
-    disallow?: string | string[];
-}
-/** A URL entry in `sitemap.xml`. */
-export interface SitemapUrl {
-    /** Absolute URL of the page. */
-    loc: string;
-    /** Last modification date (ISO 8601). */
-    lastmod?: string;
-    /** Expected change frequency. */
-    changefreq?: 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
-    /** Priority (0.0 to 1.0). */
-    priority?: number;
-}
-/** Configuration for sitemap generation. */
-export interface SitemapConfig {
-    /** Static list of URLs to include. */
-    urls?: SitemapUrl[];
-    /** Dynamic URL resolver (called on each sitemap request, or cached per `cacheTTL`). */
-    resolve?: () => SitemapUrl[] | Promise<SitemapUrl[]>;
-    /** Cache TTL in ms (default: 3600000 = 1 hour). Set 0 to disable cache. */
-    cacheTTL?: number;
-}
-/** Configuration for per-path response headers. */
-export interface SeoHeadersConfig {
-    /** `X-Robots-Tag` header value. Use a function for path-dependent values. */
-    'X-Robots-Tag'?: string | ((path: string) => string | undefined);
-}
-/** Options for {@link seo}. */
-export interface SeoOptions {
-    /** Rules for `robots.txt`. */
-    robots?: RobotsRule[];
-    /** Configuration for `sitemap.xml`. */
-    sitemap?: SitemapConfig;
-    /** Per-path response headers. */
-    headers?: SeoHeadersConfig;
-    baseUrl?: string;
-}
-/**
- * SEO middleware — sets `X-Robots-Tag` headers per path.
- * Used standalone or included automatically by {@link seo}.
- *
- * ```ts
- * app.use(seoMiddleware({
- *   headers: { 'X-Robots-Tag': (path) => path.startsWith('/admin') ? 'noindex' : undefined },
- * }))
- * ```
- */
-export declare function seoMiddleware(options?: SeoOptions): Middleware<Context, Context>;
-/**
- * SEO module — serves `robots.txt` and `sitemap.xml`.
- *
- * ```ts
- * import { seo } from 'weifuwu'
- *
- * app.use(seo({
- *   robots: [{ userAgent: '*', allow: '/', disallow: '/admin' }],
- *   sitemap: {
- *     resolve: async () => [
- *       { loc: 'https://example.com/', changefreq: 'daily', priority: 1.0 },
- *     ],
- *   },
- * }))
- * ```
- */
-export declare function seo(options?: SeoOptions): Router;
-/** Options for {@link seoTags}. */
-export interface SeoTagsConfig {
-    /** Page title (`<title>` + `og:title`). */
-    title?: string;
-    /** Meta description. */
-    description?: string;
-    /** Open Graph image URL. */
-    ogImage?: string;
-    /** Override `og:title` (defaults to `title`). */
-    ogTitle?: string;
-    /** Override `og:description` (defaults to `description`). */
-    ogDescription?: string;
-    /** Twitter card type. */
-    twitterCard?: 'summary' | 'summary_large_image';
-    /** Canonical URL (`<link rel="canonical">`). */
-    canonical?: string;
-}
-/**
- * Generate `<meta>` and `<link>` tag HTML string for SEO.
- *
- * ```ts
- * const tags = seoTags({
- *   title: 'My App',
- *   description: 'A description',
- *   ogImage: 'https://example.com/og.png',
- * })
- * // <meta name="description" content="A description" />...
- * ```
- */
-export declare function seoTags(config: SeoTagsConfig): string;

package/dist/serve.d.ts

@@ -1,38 +0,0 @@
-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;
-    /** Max request body size in bytes. Default: 10MB. Set to 0 for unlimited. */
-    maxBodySize?: number;
-    /** Socket timeout in ms (inactivity). Default: 30_000. */
-    timeout?: number;
-    /** Keep-Alive idle timeout in ms. Default: 5_000. */
-    keepAliveTimeout?: number;
-    /** Headers timeout in ms (must be > keepAliveTimeout). Default: 6_000. */
-    headersTimeout?: number;
-    shutdown?: boolean;
-}
-export interface Server {
-    stop: (timeoutMs?: number) => Promise<void>;
-    /** Alias for `stop()`. Prefer this for consistency with other modules. */
-    close: (timeoutMs?: number) => Promise<void>;
-    readonly port: number;
-    readonly hostname: string;
-    ready: Promise<void>;
-}
-/** Default max body size: 10MB. Set maxBodySize: 0 for unlimited. */
-export declare const DEFAULT_MAX_BODY: number;
-export declare function readBody(req: IncomingMessage, maxSize?: number): Promise<Buffer>;
-export declare function createRequest(req: IncomingMessage, body: Buffer): [Request, Record<string, string>];
-export declare function sendResponse(res: ServerResponse, response: Response, opts?: {
-    traceId?: string | null;
-}): Promise<void>;
-export declare function createTestServer(handler: Handler, options?: ServeOptions): Promise<{
-    server: Server;
-    url: string;
-}>;
-export declare function serve(handler: Handler, options?: ServeOptions): Server;

package/dist/server-registry.d.ts

@@ -1,10 +0,0 @@
-/**
- * Get (or load) a server-side module. Cached in registry after first load.
- * Synchronous — uses transformSync and vm.Script.
- */
-export declare function getServerModule(absPath: string): any;
-/**
- * Clear cached modules. If `absPath` given, clear only that module (for HMR).
- * Otherwise clear all modules.
- */
-export declare function clearServerModule(absPath?: string): void;

package/dist/session.d.ts

@@ -1,117 +0,0 @@
-import type { Context, Middleware, Closeable } from './types.ts';
-import type { Redis } from './vendor.ts';
-declare module './types.ts' {
-    interface Context {
-        session: Session;
-    }
-}
-declare const kSaved: unique symbol;
-declare const kDestroyed: unique symbol;
-declare const kId: unique symbol;
-declare const kStore: unique symbol;
-declare const kTtl: unique symbol;
-export interface SessionData {
-    [key: string]: unknown;
-}
-/** The session object injected into ctx.session. Plain data + control methods. */
-export interface Session extends SessionData {
-    /** Mark session as modified. Auto-detected on mutation, but call explicitly for deep mutations. */
-    save(): void;
-    /** Destroy session. Clears data and removes from store on response. */
-    destroy(): void;
-    /** Session ID (readonly). */
-    readonly id: string;
-    [kSaved]: boolean;
-    [kDestroyed]: boolean;
-    [kId]: string;
-    [kStore]: SessionStore;
-    [kTtl]: number;
-}
-export interface SessionStore extends Closeable {
-    get(sid: string): Promise<Record<string, unknown> | null>;
-    set(sid: string, data: Record<string, unknown>, ttl: number): Promise<void>;
-    destroy(sid: string): Promise<void>;
-    /** Release resources. Default no-op. */
-    close(): Promise<void>;
-}
-export interface SessionOptions {
-    /** Session store. 'memory' (default) or 'redis'. */
-    store?: 'memory' | 'redis' | SessionStore;
-    /** Redis client (required when store: 'redis'). */
-    redis?: Redis;
-    /** Session TTL in milliseconds. Default: 24 hours. */
-    ttl?: number;
-    /** Cookie name. Default: '__session'. */
-    cookieName?: string;
-    /** Cookie options. */
-    cookie?: {
-        path?: string;
-        domain?: string;
-        httpOnly?: boolean;
-        secure?: boolean;
-        sameSite?: 'strict' | 'lax' | 'none';
-    };
-    /**
-     * Secret for signing the session cookie with HMAC-SHA256.
-     * When set, the cookie value becomes `sid.signature` — tampering is detected
-     * and rejected. Strongly recommended in production.
-     */
-    secret?: string;
-    /**
-     * Interval (ms) for automatic session ID rotation.
-     * Rotating the ID mitigates session fixation attacks.
-     * Default: 900_000 (15 min). Set to 0 to disable.
-     */
-    rotateInterval?: number;
-}
-export interface SessionInjected {
-    session: Session;
-    sessionId: string;
-}
-export declare class MemoryStore implements SessionStore {
-    private store;
-    private interval;
-    constructor(cleanupMs?: number);
-    get(sid: string): Promise<Record<string, unknown> | null>;
-    set(sid: string, data: Record<string, unknown>, ttl: number): Promise<void>;
-    destroy(sid: string): Promise<void>;
-    private cleanup;
-    close(): Promise<void>;
-    /** Testing only: return approximate count. */
-    get size(): number;
-}
-/**
- * Redis-backed session store.
- * Pass to `session({ store: new RedisStore({ redis }) })`.
- */
-export declare class RedisStore implements SessionStore {
-    private redis;
-    private prefix;
-    constructor(redis: Redis, prefix?: string);
-    private key;
-    get(sid: string): Promise<Record<string, unknown> | null>;
-    set(sid: string, data: Record<string, unknown>, ttl: number): Promise<void>;
-    destroy(sid: string): Promise<void>;
-    close(): Promise<void>;
-}
-/**
- * Session middleware. Injects `ctx.session` with a persistent key-value store
- * scoped to the request. Data is automatically saved to the store on response.
- *
- * Defaults to memory store. Use `{ store: 'redis', redis }` for multi-process setups.
- *
- * ```ts
- * import { session } from 'weifuwu'
- * app.use(session())
- *
- * app.get('/visit', (req, ctx) => {
- *   ctx.session.count = (ctx.session.count ?? 0) + 1
- *   return Response.json({ visits: ctx.session.count })
- * })
- * ```
- */
-export declare function session(options?: SessionOptions): Middleware<Context, Context & SessionInjected> & {
-    close: () => Promise<void>;
-    store: SessionStore;
-};
-export {};

package/dist/sse.d.ts

@@ -1,47 +0,0 @@
-/**
- * Format an SSE message string with a named event type.
- *
- * ```ts
- * formatSSE('ping', { ts: Date.now() })
- * // "event: ping\ndata: {"ts":...}\n\n"
- * ```
- */
-export declare function formatSSE(event: string, data: unknown): string;
-/**
- * Format an SSE message string with only a data line (no event type).
- *
- * ```ts
- * formatSSEData({ message: 'hello' })
- * // "data: {"message":"hello"}\n\n"
- * ```
- */
-export declare function formatSSEData(data: unknown): string;
-/** An SSE event to be sent via {@link createSSEStream}. */
-export interface SSEEvent {
-    /** Event type (maps to `event:` field). */
-    event: string;
-    /** Event payload (serialized as JSON in `data:` field). */
-    data: unknown;
-}
-/**
- * Create a Server-Sent Events (SSE) `Response` from an async iterable.
- *
- * Each item in the iterable is serialized as an SSE message:
- * - If the item has a `.type` property → `event: {type}` + `data: {item}`
- * - Otherwise → `data: {item}`
- *
- * Errors are sent as `event: error` messages. `AbortError` is silently ignored.
- *
- * ```ts
- * app.get('/events', () => {
- *   async function* generate() {
- *     yield { type: 'ping', data: { ts: Date.now() } }
- *   }
- *   return createSSEStream(generate())
- * })
- * ```
- */
-export declare function createSSEStream(iterable: AsyncIterable<any>, opts?: {
-    headers?: Record<string, string>;
-    status?: number;
-}): Response;

package/dist/ssr-entries.d.ts

@@ -1,4 +0,0 @@
-export interface SsrEntry {
-    path: string;
-}
-export declare const ssrEntries: Map<string, SsrEntry>;

package/dist/ssr.d.ts

@@ -1,11 +0,0 @@
-import { Router } from './router.ts';
-export interface RouteEntry {
-    path: string;
-    file: string;
-}
-export declare function ssr(opts: {
-    dir: string;
-}): Router & {
-    close?: () => void;
-    pages?: () => RouteEntry[];
-};

package/dist/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/stream.d.ts

@@ -1,24 +0,0 @@
-import type { Context } from './types.ts';
-/** Options for {@link streamResponse}. */
-export interface StreamOpts {
-    /** Request context (for injecting hydration data). */
-    ctx: Context;
-    /** Base path for SSR asset URLs. */
-    base: string;
-    /** Tailwind CSS context. */
-    tailwind?: {
-        css: string;
-        url: string;
-    };
-    /** Whether in development mode (injects livereload script). */
-    isDev: boolean;
-    /** HTTP status code (default: 200). */
-    status?: number;
-    /** Serialized loader data injected into the HTML shell. */
-    loaderData?: Record<string, unknown>;
-}
-export declare function readStream(stream: ReadableStream): Promise<string>;
-/**
- * Create an HTML response from a React SSR stream.
- */
-export declare function streamResponse(reactStream: ReadableStream, opts: StreamOpts, hydrationScript?: string): Response;

package/dist/tailwind.d.ts

@@ -1,15 +0,0 @@
-import { Router } from './router.ts';
-import type { Middleware } from './types.ts';
-export interface TailwindInjected {
-    css: string;
-    url: string;
-}
-declare module './types.ts' {
-    interface Context {
-        tailwind?: TailwindInjected;
-    }
-}
-export declare function addTailwindSource(dir: string): void;
-export declare function tailwindContext(dir: string): Middleware;
-export declare function tailwindRouter(dir: string): Router;
-export declare function compileTailwindCss(cssPath: string, cssDir: string): Promise<string>;

package/dist/tenant/client.d.ts

@@ -1,2 +0,0 @@
-import type { TenantOptions, TenantModule } from './types.ts';
-export declare function tenant(options: TenantOptions): TenantModule;

package/dist/tenant/graphql.d.ts

@@ -1,3 +0,0 @@
-import type { SqlClient } from '../vendor.ts';
-import { Router } from '../router.ts';
-export declare function buildGraphQLHandler(sql: SqlClient): Router;

package/dist/tenant/index.d.ts

@@ -1,2 +0,0 @@
-export { tenant } from './client.ts';
-export type { TenantOptions, TenantModule, TenantContext, FieldDef, FieldType, RelationDef, UserTableRow, } from './types.ts';

package/dist/tenant/rest.d.ts

@@ -1,3 +0,0 @@
-import type { SqlClient } from '../vendor.ts';
-import { Router } from '../router.ts';
-export declare function buildRouter(sql: SqlClient, usersTable: string): Router;

package/dist/tenant/schema.d.ts

@@ -1,5 +0,0 @@
-import type { FieldDef } from './types.ts';
-export declare function createTableSQL(tenantId: string, slug: string, fields: FieldDef[]): string;
-export declare function addColumnSQL(tenantId: string, slug: string, field: FieldDef): string;
-export declare function dropTableSQL(tenantId: string, slug: string): string;
-export declare function createIndexesSQL(tenantId: string, slug: string, fields: FieldDef[]): string[];