weifuwu 0.28.2 → 0.30.0

package/dist/redis/client.d.ts

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

package/dist/redis/index.d.ts

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

package/dist/redis/types.d.ts

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

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

package/dist/types.d.ts

@@ -0,0 +1,82 @@
+import type postgres from 'postgres';
+/** Untyped postgres.js SQL client. Use typed `Sql<{ table: { col: type } }>` for schemas. */
+export type SqlClient = postgres.Sql<Record<string, unknown>>;
+/** Re-export for downstream usage. */
+export type { Sql } from 'postgres';
+/** Lightweight WebSocket interface for WS handler types (avoids external dep resolution). */
+export interface WebSocket {
+    send(data: string | Buffer): void;
+    close(code?: number, reason?: string): void;
+    ping(data?: unknown): void;
+    readyState: number;
+    readonly OPEN: number;
+    readonly CLOSED: number;
+    readonly CONNECTING: number;
+    readonly CLOSING: number;
+    on(event: string, handler: (...args: unknown[]) => void): this;
+    off(event: string, handler: (...args: unknown[]) => void): this;
+    addEventListener(event: string, handler: (...args: unknown[]) => void): void;
+    removeEventListener(event: string, handler: (...args: unknown[]) => void): void;
+}
+export type { Redis, RedisOptions } from 'ioredis';
+export interface WsContext {
+    /** Per-connection state object */
+    state: Record<string, unknown>;
+    /** Send JSON to this connection */
+    json(data: unknown): void;
+    /** Join a room */
+    join(room: string): void;
+    /** Leave a room */
+    leave(room: string): void;
+    /** Broadcast to a room */
+    sendRoom(room: string, data: unknown): void;
+}
+export interface Context {
+    params: Record<string, string>;
+    query: Record<string, string>;
+    mountPath?: string;
+    /** Currently authenticated user (set by user/auth middleware). */
+    user?: unknown;
+    /** Server-side data loaded for the current page (React SSR). */
+    loaderData?: Record<string, unknown>;
+    /** Public environment variables. */
+    env?: Record<string, string>;
+    [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/package.json

@@ -1,19 +1,41 @@
 {
   "name": "weifuwu",
   "type": "module",
-  "version": "0.28.2",
-  "description": "Web-standard HTTP microframework — alias for @weifuwujs/core",
+  "version": "0.30.0",
+  "description": "Web-standard HTTP microframework for Node.js — (req, ctx) => Response",
   "exports": {
     ".": {
-      "types": "./index.d.ts",
-      "default": "./index.js"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     }
   },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "prepublishOnly": "npm run build && tsc --emitDeclarationOnly --outdir dist",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test 'src/test/**/*.test.ts'",
+    "test:coverage": "node --experimental-test-coverage --test 'src/test/**/*.test.ts'",
+    "release": "node scripts/release.mjs",
+    "release:dry": "node scripts/release.mjs --dry-run"
+  },
   "dependencies": {
-    "@weifuwujs/core": "*"
+    "@graphql-tools/schema": "^10",
+    "graphql": "^16",
+    "ioredis": "^5.11.0",
+    "postgres": "^3.4.9",
+    "ws": "^8",
+    "zod": "^4.4.3"
   },
-  "files": [
-    "index.js",
-    "index.d.ts"
-  ]
+  "devDependencies": {
+    "@types/node": "^25",
+    "@types/ws": "^8",
+    "@eslint/js": "^10.0.1",
+    "globals": "^17.7.0",
+    "typescript-eslint": "^8.62.1"
+  },
+  "sideEffects": false
 }

package/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * @deprecated Use `import { ... } from '@weifuwujs/core'` instead.
- *
- * Migration:
- *   `weifuwu` → `@weifuwujs/core`  for framework core
- *   `weifuwu` → `@weifuwujs/react` for React SSR
- */
-export * from '@weifuwujs/core'

package/index.js

@@ -1,26 +0,0 @@
-/**
- * @deprecated weifuwu has been split into scoped packages.
- *
- * Update your imports:
- *   import { serve } from 'weifuwu'           → import { serve } from '@weifuwujs/core'
- *   import { ssr, theme } from 'weifuwu'      → import { ssr, theme } from '@weifuwujs/react'
- *
- * The 'weifuwu' package is a backward-compatibility alias and
- * will receive no new features. Migrate to '@weifuwujs/core'.
- */
-
-if (!process.env.WEIFUWU_SUPPRESS_DEPRECATION) {
-  process.emitWarning(
-    [
-      `'weifuwu' is deprecated. Use scoped packages instead:`,
-      `  import { serve } from 'weifuwu'        →  import { serve } from '@weifuwujs/core'`,
-      `  import { ssr } from 'weifuwu'           →  import { ssr } from '@weifuwujs/react'`,
-      `  import { aiProvider } from 'weifuwu'    →  npm install ai  (use vercel/ai-sdk directly)`,
-      `Set WEIFUWU_SUPPRESS_DEPRECATION=1 to silence this warning.`,
-    ].join('\n'),
-    'DeprecationWarning',
-    'WEIFUWU_DEP001',
-  )
-}
-
-export * from '@weifuwujs/core'