weifuwu 0.25.2 → 0.27.0

package/dist/tenant/types.d.ts

@@ -1,48 +0,0 @@
-import type { Context, Handler } from '../types.ts';
-import type { Router } from '../router.ts';
-import type { PostgresClient } from '../postgres/types.ts';
-declare module '../types.ts' {
-    interface Context {
-        tenant: TenantContext;
-    }
-}
-export interface TenantContext {
-    id: string;
-    name: string;
-    role: string;
-}
-export type FieldType = 'string' | 'integer' | 'float' | 'boolean' | 'text' | 'datetime' | 'date' | 'enum' | 'json' | 'vector';
-export interface RelationDef {
-    table: string;
-    field?: string;
-    onDelete?: 'cascade' | 'restrict' | 'setnull';
-}
-export interface FieldDef {
-    name: string;
-    type: FieldType;
-    required?: boolean;
-    unique?: boolean;
-    index?: boolean | 'desc' | 'gin' | 'hnsw';
-    default?: unknown;
-    options?: string[];
-    dimensions?: number;
-    relation?: RelationDef;
-}
-export interface UserTableRow {
-    id: number;
-    tenant_id: string;
-    slug: string;
-    label: string;
-    fields: FieldDef[];
-    created_at: string;
-}
-export interface TenantOptions {
-    pg: PostgresClient;
-    usersTable: string;
-}
-export interface TenantModule extends Router {
-    migrate: () => Promise<void>;
-    middleware: () => (req: Request, ctx: Context, next: Handler<Context>) => Promise<Response>;
-    graphql: () => Router;
-    close: () => Promise<void>;
-}

package/dist/tenant/utils.d.ts

@@ -1,9 +0,0 @@
-import type { FieldDef } from './types.ts';
-export declare function internalTableName(tenantId: string, slug: string): string;
-export declare function pascalCase(slug: string): string;
-export declare function sqlTypeForField(field: FieldDef): string;
-export declare function validateSlug(slug: string): string | null;
-export declare function validateFieldDefs(fields: FieldDef[]): string[];
-export declare function formatDefault(field: FieldDef): string;
-export declare function getRelationFields(fields: FieldDef[]): FieldDef[];
-export declare function findRelation(fields: FieldDef[], targetSlug: string): FieldDef | undefined;

package/dist/test-utils.d.ts

@@ -1,194 +0,0 @@
-import type { Context, Handler } from './types.ts';
-import type { SqlClient } from './vendor.ts';
-import { Router } from './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('./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>;

package/dist/theme.d.ts

@@ -1,31 +0,0 @@
-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;
-}
-/**
- * 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,95 +0,0 @@
-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;
-    /** Timestamp (ms since epoch) when the trace started. */
-    startTime: number;
-}
-/**
- * Get the current request's trace ID.
- * Returns `undefined` when called outside a request context (e.g. at startup).
- *
- * ```ts
- * const traceId = currentTraceId()
- * log.info({ traceId }, 'request started')
- * ```
- */
-export declare function currentTraceId(): string | undefined;
-/**
- * Get the full current trace context ({ traceId, startTime }).
- * Returns `undefined` outside a request.
- */
-export declare function currentTrace(): TraceContext | undefined;
-/**
- * Run a function inside a trace context.
- * Used internally by `serve()` for every incoming request.
- * If `incomingTraceId` is provided (e.g. from an `X-Trace-Id` header) it is reused;
- * otherwise a new UUID is generated.
- *
- * ```ts
- * const result = runWithTrace(req.headers.get('x-trace-id'), () => {
- *   return handleRequest(req)
- * })
- * ```
- *
- * @param incomingTraceId - Optional trace ID from upstream. Pass `null` to auto-generate.
- * @param fn - Function to execute within the trace scope.
- * @returns The return value of `fn`.
- */
-export declare function runWithTrace<T>(incomingTraceId: string | null, fn: () => T): T;
-/**
- * Milliseconds elapsed since the current trace started.
- * Returns `0` if called outside a request context.
- *
- * ```ts
- * app.use(async (req, ctx, next) => {
- *   const res = await next(req, ctx)
- *   console.log('handled in', traceElapsed(), 'ms')
- *   return res
- * })
- * ```
- */
-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/tsx-context.d.ts

@@ -1,32 +0,0 @@
-export interface PageContext {
-    params: Record<string, string>;
-    query: Record<string, string>;
-    user: {
-        id?: string;
-    };
-    parsed: Record<string, unknown>;
-    theme?: {
-        value: string;
-        set?: (value: string, loc?: string) => Response;
-    };
-    i18n?: {
-        locale: string;
-        messages?: Record<string, unknown>;
-        t: (key: string, params?: Record<string, string>, fallback?: string) => string;
-    };
-    flash?: {
-        value?: string;
-        set?: (data: any, loc?: string) => Response;
-    };
-    loaderData: Record<string, unknown>;
-    env: Record<string, string>;
-}
-type Rebuilder = (value: Partial<PageContext>) => Partial<PageContext> | null;
-export declare function addCtxRebuilder(fn: Rebuilder): void;
-/** @internal Injected by tsx-instance.ts for async-safe context isolation */
-export declare function __registerAls(getStore: () => PageContext | undefined): void;
-declare function setCtx(value: Partial<PageContext>): void;
-declare function useCtx(): PageContext;
-export declare function useLoaderData<T = Record<string, unknown>>(): T;
-export declare const TsxContext: import("react").Context<PageContext>;
-export { useCtx, setCtx };

package/dist/types.d.ts

@@ -1,47 +0,0 @@
-export interface Context {
-    params: Record<string, string>;
-    query: Record<string, string>;
-    mountPath?: string;
-    layoutStack?: {
-        path: string;
-        component: unknown;
-    }[];
-    [key: string]: unknown;
-}
-export type Handler<T extends Context = Context> = (req: Request, ctx: T) => Response | Promise<Response>;
-/**
- * Metadata for middleware dependency checking.
- * Middleware factories attach this for runtime validation.
- */
-export interface MiddlewareMeta {
-    /** Fields this middleware injects into ctx. */
-    injects: string[];
-    /** Fields this middleware depends on (must be injected earlier). */
-    depends: string[];
-}
-export type Middleware<In extends Context = Context, Out extends In = In> = {
-    (req: Request, ctx: In, next: Handler<Out>): Response | Promise<Response>;
-    __meta?: MiddlewareMeta;
-};
-export type ErrorHandler<T extends Context = Context> = (error: Error, req: Request, ctx: T) => Response | Promise<Response>;
-/**
- * Interface for resources that require explicit cleanup (connections, pools, timers).
- * All stateful modules implement this.
- */
-export interface Closeable {
-    /** Release all resources. Call once when shutting down. */
-    close(): Promise<void>;
-}
-/**
- * HTTP error with an explicit status code.
- * Throw from a handler or middleware to return a non-200 response.
- *
- * ```ts
- * if (!resource) throw new HttpError('Not found', 404)
- * serve() catches it and returns the status code.
- * ```
- */
-export declare class HttpError extends Error {
-    status: number;
-    constructor(message: string, status: number);
-}

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

@@ -1,42 +0,0 @@
-/** Options for {@link useAction}. */
-export interface UseActionOptions<T = any> {
-    /** HTTP method (default: `'POST'`). */
-    method?: string;
-    /** Additional request headers. */
-    headers?: Record<string, string>;
-    /** Called with the response data on success. */
-    onSuccess?: (data: T) => void;
-    /** Called with the error on failure. */
-    onError?: (err: Error) => void;
-}
-/** Return value of {@link useAction}. */
-export interface UseActionReturn<T = any> {
-    /** Submit the action. Pass a body to send as JSON (or FormData). */
-    submit: (body?: any) => Promise<T | undefined>;
-    /** Response data from the last successful submission. */
-    data: T | null;
-    /** Error from the last failed submission. */
-    error: Error | null;
-    /** Whether a submission is in progress. */
-    pending: boolean;
-    /** Reset data and error to their initial states. */
-    reset: () => void;
-}
-/**
- * Hook to submit form actions via `fetch`. Handles JSON serialization,
- * CSRF token injection, and loading/error state.
- *
- * ```tsx
- * import { useAction } from 'weifuwu/react'
- *
- * function SaveButton() {
- *   const { submit, pending, error } = useAction('/api/save')
- *   return (
- *     <button onClick={() => submit({ title: 'Hello' })} disabled={pending}>
- *       {pending ? 'Saving...' : 'Save'}
- *     </button>
- *   )
- * }
- * ```
- */
-export declare function useAction<T = any>(url: string | URL, options?: UseActionOptions<T>): UseActionReturn<T>;

package/dist/use-agent-stream.d.ts

@@ -1,49 +0,0 @@
-/** Streaming state for all agents in a channel. */
-export interface AgentStreamState {
-    /** Accumulated streaming text per agent, keyed by `agent_id`. */
-    streams: Record<number, string>;
-    /** Whether any agent is currently streaming (typing). */
-    streaming: boolean;
-    /** Set of agent IDs currently streaming. */
-    activeAgents: Set<number>;
-}
-/** Options for {@link useAgentStream}. */
-export interface UseAgentStreamOptions {
-    /** WebSocket path, e.g. `'/ws'`. */
-    wsPath: string;
-    /** Channel ID to listen for agent streams. */
-    channelId: number;
-    /** Called when an agent finishes generating. */
-    onStreamEnd?: (agentId: number, fullText: string) => void;
-    /** Called on stream error. */
-    onError?: (agentId: number, error: string) => void;
-}
-/** Return value of {@link useAgentStream}. */
-export interface UseAgentStreamReturn {
-    /** Accumulated streaming state for all agents. */
-    stream: AgentStreamState;
-    /** Get accumulated text for a specific agent by ID. */
-    getAgentText: (agentId: number) => string;
-    /** Whether a specific agent is currently streaming. */
-    isAgentStreaming: (agentId: number) => boolean;
-}
-/**
- * React hook to consume agent AI streaming output via WebSocket.
- *
- * Connects to a WebSocket endpoint, listens for `agent_stream`,
- * `agent_stream_end`, and `agent_error` messages, and accumulates
- * the token stream per agent.
- *
- * ```tsx
- * import { useAgentStream } from 'weifuwu/react'
- *
- * function Chat() {
- *   const { stream, getAgentText } = useAgentStream({
- *     wsPath: '/ws/chat',
- *     channelId: 1,
- *   })
- *   return <pre>{getAgentText(1)}</pre>
- * }
- * ```
- */
-export declare function useAgentStream(opts: UseAgentStreamOptions): UseAgentStreamReturn;

package/dist/use-flash-message.d.ts

@@ -1,17 +0,0 @@
-/**
- * React hook to read the server-flashed message on the client side.
- *
- * Reads `window.__WEIFUWU_CTX.flash.value` (set by the flash middleware
- * during SSR). Returns `null` when no flash message is present.
- *
- * ```tsx
- * import { useFlashMessage } from 'weifuwu/react'
- *
- * function FlashNotice() {
- *   const flash = useFlashMessage<{ type: string; text: string }>()
- *   if (!flash) return null
- *   return <div className={flash.type}>{flash.text}</div>
- * }
- * ```
- */
-export declare function useFlashMessage<T = any>(): T | null;

package/dist/use-websocket.d.ts

@@ -1,42 +0,0 @@
-/** Options for {@link useWebsocket}. */
-export type UseWebsocketOptions = {
-    /** Called when a message is received. */
-    onMessage?: (data: string) => void;
-    /** Auto-reconnect config. Set to `false` to disable. Default: `{ maxRetries: 10, delay: 3000 }`. */
-    reconnect?: boolean | {
-        maxRetries?: number;
-        delay?: number;
-    };
-    /** WebSocket sub-protocols. */
-    protocols?: string | string[];
-    /** Whether the WebSocket is enabled. Set to `false` to keep closed. Default: `true`. */
-    enabled?: boolean;
-};
-/** Return value of {@link useWebsocket}. */
-export type UseWebsocketReturn = {
-    /** Send data through the WebSocket. */
-    send: (data: string | ArrayBuffer | Blob) => void;
-    /** Close the WebSocket manually. */
-    close: () => void;
-    /** Current `WebSocket.readyState`. */
-    readyState: number;
-    /** The last received message string. */
-    lastMessage: string | null;
-    /** Manually trigger reconnection. */
-    reconnect: () => void;
-};
-/**
- * React hook for WebSocket connections with auto-reconnect.
- *
- * ```tsx
- * import { useWebsocket } from 'weifuwu/react'
- *
- * function Chat() {
- *   const { send, lastMessage, readyState } = useWebsocket('/ws/chat', {
- *     onMessage: (data) => console.log('received:', data),
- *   })
- *   return <button onClick={() => send('Hello')}>Send</button>
- * }
- * ```
- */
-export declare function useWebsocket(url: string | URL | (() => string | URL | null), options?: UseWebsocketOptions): UseWebsocketReturn;