weifuwu 0.11.0 → 0.12.0

package/README.md

@@ -17,7 +17,7 @@ Everything follows the same `(req, ctx) => Response` contract. The Router handle
 - **React SSR + Hydration** — `tsx({ dir })` — page.tsx / load.ts / layout.tsx / route.ts / not-found.tsx
 - **WebSocket** — `router.ws()` with upgrade middleware (auth before connect)
 - **GraphQL** — `graphql(handler)` sub-Router with GraphiQL IDE
-- **AI streaming** — `ai(handler)` sub-Router via Vercel AI SDK
+- **AI streaming** — `aiStream(handler)` sub-Router via Vercel AI SDK
 - **DAG workflow tool** — `runWorkflow()` — multi-step execution engine as a single AI SDK `Tool`
 - **AI Agent** — `agent()` — server-side AI agents with chat/tool-use/knowledge types, OpenAI-compatible, Ollama-ready
 - **Messaging** — `messager()` — real-time chat with channels, WebSocket, agent routing, webhook support
@@ -851,7 +851,7 @@ GraphQL endpoint with GraphiQL IDE. Mount as a sub-Router:
 import { serve, Router, graphql } from 'weifuwu'
 
 const app = new Router()
-app.use('/graphql', graphql(() => ({
+const gql = graphql(() => ({
   schema: `
     type Query { hello: String }
     type Mutation { setMessage(msg: String!): String }
@@ -861,7 +861,8 @@ app.use('/graphql', graphql(() => ({
     Mutation: { setMessage: (_, { msg }) => msg },
   },
   graphiql: true,
-})))
+}))
+app.use('/graphql', gql.router())
 
 serve(app.handler(), { port: 3000 })
 ```
@@ -873,14 +874,15 @@ The handler receives `(req, ctx)` so you can customize the schema based on the r
 Server-sent event streaming via the Vercel AI SDK:
 
 ```ts
-import { serve, Router, ai } from 'weifuwu'
+import { serve, Router, aiStream } from 'weifuwu'
 import { openai } from '@ai-sdk/openai'
 
 const app = new Router()
-app.use('/chat', ai(async (req, ctx) => {
+const chat = await aiStream(async (req, ctx) => {
   const { messages } = await req.json()
   return { model: openai('gpt-4o'), messages }
-}))
+})
+app.use('/chat', chat.router())
 
 serve(app.handler(), { port: 3000 })
 ```
@@ -1153,15 +1155,81 @@ export default function NotFound() {
 }
 ```
 
+## Health check
+
+```ts
+import { serve, Router, health } from 'weifuwu'
+
+const app = new Router()
+app.use(health())                              // GET /health → 200
+app.use(health({ path: '/healthz' }))          // custom path
+app.use(health({
+  check: async () => { await db.sql`SELECT 1` },  // fail → 503
+}))
+serve(app.handler(), { port: 3000 })
+```
+
+Returns a `Router` — mount with `app.use()`.
+
+## Internationalization
+
+```ts
+import { i18n } from 'weifuwu'
+
+app.use(i18n({ dir: './locales', defaultLocale: 'en' }))
+
+// In any handler after i18n middleware:
+app.get('/hello', (req, ctx) => {
+  const msg = ctx.t('greeting', { name: 'World' })
+  return Response.json({ message: msg, locale: ctx.locale })
+})
+```
+
+Locale detection: `Cookie: locale=zh` → `Accept-Language: zh-CN` → `defaultLocale`.
+
+## Email
+
+```ts
+import { mailer } from 'weifuwu'
+
+// SMTP transport
+const mail = mailer({
+  transport: 'smtp://user:pass@smtp.example.com',
+  from: 'noreply@example.com',
+})
+await mail.send({ to: 'user@example.com', subject: 'Welcome', html: '<h1>Hi!</h1>' })
+await mail.close()
+
+// Custom transport (Resend, SES, SendGrid, etc.)
+const mail2 = mailer({
+  send: async (msg) => { await resend.emails.send(msg) },
+})
+await mail2.send({ to: 'user@example.com', subject: 'Hi', text: 'Hello' })
+await mail2.close()
+```
+
+## Test utilities
+
+```ts
+import { createTestServer } from 'weifuwu'
+
+const { server, url } = await createTestServer(app.handler())
+const res = await fetch(`${url}/api/users`)
+assert.equal(res.status, 200)
+server.stop()
+```
+
 ## Usage within a full app
 
 ```ts
-import { serve, Router, ai, graphql } from 'weifuwu'
+import { serve, Router, aiStream, graphql } from 'weifuwu'
 
 const app = new Router()
 app.use('/', await tsx({ dir: './pages/' }))
-app.use('/chat', ai(async (req) => ({ model: openai('gpt-4o'), messages: (await req.json()).messages })))
-app.use('/graphql', graphql(() => ({ schema: `type Query { hello: String }`, resolvers: { Query: { hello: () => 'world' } } })))
+const chat = await aiStream(async (req) => ({ model: openai('gpt-4o'), messages: (await req.json()).messages }))
+app.use('/chat', chat.router())
+const gql = graphql(() => ({ schema: `type Query { hello: String }`, resolvers: { Query: { hello: () => 'world' } } }))
+app.use('/graphql', gql.router())
 app.ws('/chat', { message(ws, _, data) { ws.send(data) } })
 
 serve(app.handler(), { websocket: app.websocketHandler() })
@@ -1382,7 +1450,7 @@ serve(app.handler(), { websocket: app.websocketHandler() })
 | `messager(options)` | Real-time messaging — channels, WebSocket, agent routing, webhooks |
 | `opencode(options)` | AI programming assistant — chat agents with tools, skills, permissions, isolated workspaces |
 | `graphql(handler)` | GraphQL endpoint (GET/POST + GraphiQL) |
-| `ai(handler)` | AI streaming endpoint (POST) |
+| `aiStream(handler)` | AI streaming endpoint (POST) |
 | `runWorkflow(options)` | DAG execution engine as an AI SDK `Tool` — use with `streamText()` |
 
 ### Deploy

package/dist/ai.d.ts

@@ -1,19 +1,7 @@
 import type { Context } from './types.ts';
 import { Router } from './router.ts';
-type StreamTextParams = {
-    model: unknown;
-    prompt?: string;
-    system?: string;
-    messages?: unknown[];
-    maxTokens?: number;
-    temperature?: number;
-    [key: string]: unknown;
-};
-export type AIHandler = (req: Request, ctx: Context) => StreamTextParams | Promise<StreamTextParams>;
-export declare const _ai: {
-    streamText: (params: StreamTextParams) => {
-        toTextStreamResponse: () => Response;
-    };
-};
-export declare function ai(handler: AIHandler): Promise<Router>;
-export {};
+export type AIHandler = (req: Request, ctx: Context) => Record<string, unknown> | Promise<Record<string, unknown>>;
+export declare const _ai: Record<string, any>;
+export declare function aiStream(handler: AIHandler): Promise<{
+    router(): Router;
+}>;

package/dist/deploy/types.d.ts

@@ -37,7 +37,7 @@ export interface AppStatus {
     error?: string;
 }
 export interface DeployServer {
-    stop(): Promise<void>;
+    close(): Promise<void>;
     ready: Promise<void>;
     url: string;
     apps: {

package/dist/graphql.d.ts

@@ -9,4 +9,6 @@ export interface GraphQLOptions {
     graphiql?: boolean;
 }
 export type GraphQLHandler = (req: Request, ctx: Context) => GraphQLOptions | Promise<GraphQLOptions>;
-export declare function graphql(handler: GraphQLHandler): Router;
+export declare function graphql(handler: GraphQLHandler): {
+    router(): Router;
+};

package/dist/health.d.ts

@@ -0,0 +1,6 @@
+import { Router } from './router.ts';
+export interface HealthOptions {
+    path?: string;
+    check?: () => Promise<void>;
+}
+export declare function health(options?: HealthOptions): Router;

package/dist/i18n.d.ts

@@ -0,0 +1,6 @@
+import type { Middleware } from './types.ts';
+export interface I18nOptions {
+    dir: string;
+    defaultLocale?: string;
+}
+export declare function i18n(options: I18nOptions): Middleware;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export type { Context, Handler, Middleware, ErrorHandler } from './types.ts';
-export { serve } from './serve.ts';
+export { serve, createTestServer } from './serve.ts';
 export type { ServeOptions, Server } from './serve.ts';
 export { Router } from './router.ts';
 export type { WebSocketHandler } from './router.ts';
@@ -21,7 +21,7 @@ export { compress } from './compress.ts';
 export type { CompressOptions } from './compress.ts';
 export { graphql } from './graphql.ts';
 export type { GraphQLOptions, GraphQLHandler } from './graphql.ts';
-export { ai } from './ai.ts';
+export { aiStream } from './ai.ts';
 export type { AIHandler } from './ai.ts';
 export { runWorkflow } from './ai/workflow.ts';
 export { postgres } from './postgres/index.ts';
@@ -42,3 +42,9 @@ export { deploy, defineConfig } from './deploy/index.ts';
 export type { DeployConfig, AppConfig, DeployServer, AppStatus } from './deploy/types.ts';
 export { opencode } from './opencode/index.ts';
 export type { OpencodeOptions, OpencodeModule, SkillDef, OpencodePermissions, Session as OpencodeSession } from './opencode/types.ts';
+export { health } from './health.ts';
+export type { HealthOptions } from './health.ts';
+export { i18n } from './i18n.ts';
+export type { I18nOptions } from './i18n.ts';
+export { mailer } from './mailer.ts';
+export type { MailerOptions, MailOptions, Mailer } from './mailer.ts';

package/dist/index.js

@@ -63,6 +63,11 @@ async function sendResponse(res, response) {
   }
   res.end();
 }
+async function createTestServer(handler) {
+  const server = serve(handler, { port: 0 });
+  await server.ready;
+  return { server, url: `http://localhost:${server.port}` };
+}
 function serve(handler, options) {
   const port = options?.port ?? 0;
   const hostname = options?.hostname ?? "0.0.0.0";
@@ -329,13 +334,13 @@ var Router = class _Router {
             const mw = match.middlewares[index++];
             return mw(innerReq, ctx2, dispatch);
           }
-          return await new Promise((resolve9) => {
+          return await new Promise((resolve10) => {
             try {
               upgradeSocket(router.wss, req, socket, head, match.handler, ctx2);
-              resolve9(new Response(null, { status: 101 }));
+              resolve10(new Response(null, { status: 101 }));
             } catch {
               socket.destroy();
-              resolve9(new Response("WebSocket upgrade failed", { status: 500 }));
+              resolve10(new Response("WebSocket upgrade failed", { status: 500 }));
             }
           });
         };
@@ -1946,24 +1951,34 @@ function graphql(handler) {
     }
     return executeQuery(schema, params, options, req, ctx);
   });
-  return r;
+  return { router: () => r };
 }
 
 // ai.ts
-var _ai = {
-  streamText: null
-};
-async function ai(handler) {
-  if (!_ai.streamText) {
-    _ai.streamText = (await import("ai")).streamText;
-  }
+var _ai = {};
+async function getStreamText() {
+  if (!_ai.streamText) _ai.streamText = (await import("ai")).streamText;
+  return _ai.streamText;
+}
+async function getStreamObject() {
+  if (!_ai.streamObject) _ai.streamObject = (await import("ai")).streamObject;
+  return _ai.streamObject;
+}
+async function aiStream(handler) {
   const r = new Router();
   r.post("/", async (req, ctx) => {
     const options = await handler(req, ctx);
-    const result = _ai.streamText(options);
+    if (options.schema) {
+      const streamObject = await getStreamObject();
+      const { schema, ...params } = options;
+      const result2 = streamObject({ ...params, schema, output: "object" });
+      return result2.toTextStreamResponse();
+    }
+    const streamText3 = await getStreamText();
+    const result = streamText3(options);
     return result.toTextStreamResponse();
   });
-  return r;
+  return { router: () => r };
 }
 
 // ai/workflow.ts
@@ -2090,7 +2105,10 @@ async function executeNode(node, ctx) {
         const test = typeof c.test === "string" ? Boolean(resolveValue(c.test, ctx)) : c.test;
         if (test && c.body) {
           let last;
-          for (const n of c.body) last = await executeNode(n, ctx);
+          for (const n of c.body) {
+            last = await executeNode(n, ctx);
+            ctx.nodeOutputs.set(n.id, last);
+          }
           return last;
         }
       }
@@ -2106,7 +2124,10 @@ async function executeNode(node, ctx) {
         ctx.stepCount++;
         if (ctx.stepCount > ctx.maxSteps) throw new Error(`Step limit exceeded`);
         if (!Boolean(evaluateExpression(conditionExpr, ctx))) break;
-        for (const n of body ?? []) last = await executeNode(n, ctx);
+        for (const n of body ?? []) {
+          last = await executeNode(n, ctx);
+          ctx.nodeOutputs.set(n.id, last);
+        }
       }
       return last;
     }
@@ -5085,14 +5106,14 @@ function forkApp(opts) {
   return { child, port: opts.port };
 }
 function stopProcess(mp, timeout = 1e4) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const timer = setTimeout(() => {
       mp.child.kill("SIGKILL");
-      resolve9();
+      resolve10();
     }, timeout);
     mp.child.on("exit", () => {
       clearTimeout(timer);
-      resolve9();
+      resolve10();
     });
     mp.child.kill("SIGTERM");
   });
@@ -5311,7 +5332,7 @@ async function deploy(config) {
   });
   const portSuffix = config.port !== 80 ? `:${config.port}` : "";
   return {
-    stop: async () => {
+    close: async () => {
       for (const [, app] of apps) {
         if (app.restartTimer) clearTimeout(app.restartTimer);
         if (app.process) {
@@ -5651,10 +5672,10 @@ function createBashTool(ctx) {
         return { stdout: "", stderr: "Command denied: potentially dangerous command", exitCode: 1 };
       }
       const cwd = workdir ? `${ctx.workspace}/${workdir}` : ctx.workspace;
-      return new Promise((resolve9) => {
+      return new Promise((resolve10) => {
         const child = exec(command, { cwd, timeout: timeout * 1e3, maxBuffer: 1024 * 1024 }, (error, stdout, stderr) => {
           const truncated = stdout.length > 1e6 || stderr.length > 1e6;
-          resolve9({
+          resolve10({
             stdout: stdout.slice(0, 1e6),
             stderr: stderr.slice(0, 1e6),
             exitCode: error?.code ?? 0,
@@ -5882,7 +5903,7 @@ function createQuestionTool(ctx) {
       options: z12.array(z12.string()).optional().describe("Optional multiple choice options")
     }),
     execute: async ({ question, options }, { toolCallId }) => {
-      return new Promise((resolve9, reject) => {
+      return new Promise((resolve10, reject) => {
         const timeout = setTimeout(() => {
           ctx.pendingQuestions.delete(toolCallId);
           reject(new Error("Question timed out"));
@@ -5890,7 +5911,7 @@ function createQuestionTool(ctx) {
         ctx.pendingQuestions.set(toolCallId, {
           resolve: (answer) => {
             clearTimeout(timeout);
-            resolve9(answer);
+            resolve10(answer);
           },
           reject: (err) => {
             clearTimeout(timeout);
@@ -6275,20 +6296,124 @@ async function opencode(options) {
     close: () => base.close()
   };
 }
+
+// health.ts
+function health(options) {
+  const path2 = options?.path ?? "/health";
+  const r = new Router();
+  const handler = async () => {
+    try {
+      await options?.check?.();
+      return new Response("OK", { status: 200 });
+    } catch {
+      return new Response("Service Unavailable", { status: 503 });
+    }
+  };
+  r.get(path2, handler);
+  r.head(path2, handler);
+  return r;
+}
+
+// i18n.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { existsSync as existsSync3 } from "node:fs";
+import { join as join4, resolve as resolve9 } from "node:path";
+function i18n(options) {
+  const dir = resolve9(options.dir);
+  const defaultLocale = options.defaultLocale ?? "en";
+  const cache = /* @__PURE__ */ new Map();
+  async function load(locale) {
+    const cached = cache.get(locale);
+    if (cached) return cached;
+    const filePath = join4(dir, `${locale}.json`);
+    if (!existsSync3(filePath)) return {};
+    try {
+      const content = await readFile2(filePath, "utf-8");
+      const data = JSON.parse(content);
+      cache.set(locale, data);
+      return data;
+    } catch {
+      return {};
+    }
+  }
+  function detect(req) {
+    const url = new URL(req.url);
+    const fromCookie = extractCookie(req, "locale");
+    if (fromCookie) return fromCookie;
+    const fromHeader = req.headers.get("Accept-Language")?.split(",")[0]?.split("-")[0];
+    if (fromHeader) return fromHeader;
+    return defaultLocale;
+  }
+  function t(localeMsgs, key, params) {
+    let msg = localeMsgs[key];
+    if (msg === void 0) msg = key;
+    if (params) {
+      for (const [k, v] of Object.entries(params)) {
+        msg = msg.replace(`{${k}}`, v);
+      }
+    }
+    return msg;
+  }
+  return async (req, ctx, next) => {
+    const locale = detect(req);
+    const msgs = await load(locale);
+    ctx.locale = locale;
+    ctx.t = (key, params) => t(msgs, key, params);
+    return next(req, ctx);
+  };
+}
+function extractCookie(req, name) {
+  const cookie = req.headers.get("cookie");
+  if (!cookie) return null;
+  for (const part of cookie.split(";")) {
+    const [k, v] = part.trim().split("=");
+    if (k === name && v) return decodeURIComponent(v);
+  }
+  return null;
+}
+
+// mailer.ts
+import { createTransport } from "nodemailer";
+function mailer(options) {
+  const sender = options.send;
+  const from = options.from;
+  let transporter = null;
+  if (!sender && options.transport) {
+    transporter = typeof options.transport === "string" ? createTransport(options.transport) : options.transport;
+  }
+  async function send(opts) {
+    if (sender) {
+      await sender(opts);
+      return;
+    }
+    if (!transporter) {
+      throw new Error("mailer: no transport configured \u2014 provide `transport` or `send` option");
+    }
+    await transporter.sendMail({ ...opts, from: opts.from ?? from });
+  }
+  async function close() {
+    if (transporter) transporter.close();
+  }
+  return { send, close };
+}
 export {
   Router,
   TsxContext,
   agent,
-  ai,
+  aiStream,
   auth,
   compress,
   cors,
+  createTestServer,
   defineConfig,
   deleteCookie,
   deploy,
   getCookies,
   graphql,
+  health,
+  i18n,
   logger,
+  mailer,
   messager,
   opencode,
   postgres,

package/dist/mailer.d.ts

@@ -0,0 +1,20 @@
+import type { Transporter } from 'nodemailer';
+export interface MailOptions {
+    to: string | string[];
+    subject: string;
+    text?: string;
+    html?: string;
+    from?: string;
+    cc?: string | string[];
+    bcc?: string | string[];
+}
+export interface MailerOptions {
+    transport?: string | Transporter;
+    from?: string;
+    send?: (opts: MailOptions) => Promise<void>;
+}
+export interface Mailer {
+    send: (opts: MailOptions) => Promise<void>;
+    close: () => Promise<void>;
+}
+export declare function mailer(options: MailerOptions): Mailer;

package/dist/serve.d.ts

@@ -17,4 +17,8 @@ export interface Server {
 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): Promise<void>;
+export declare function createTestServer(handler: Handler): Promise<{
+    server: Server;
+    url: string;
+}>;
 export declare function serve(handler: Handler, options?: ServeOptions): Server;

package/dist/types.d.ts

@@ -4,6 +4,8 @@ export interface Context {
     user?: unknown;
     parsed?: Record<string, unknown>;
     mountPath?: string;
+    locale?: string;
+    t?: (key: string, params?: Record<string, string>) => string;
 }
 export type Handler = (req: Request, ctx: Context) => Response | Promise<Response>;
 export type Middleware = (req: Request, ctx: Context, next: Handler) => Response | Promise<Response>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weifuwu",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Web-standard HTTP framework for Node.js — (req, ctx) => Response",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -28,6 +28,7 @@
     "graphql": "^16",
     "ioredis": "^5.11.0",
     "jsonwebtoken": "^9.0.3",
+    "nodemailer": "^8.0.10",
     "postgres": "^3.4.9",
     "react": "^19",
     "react-dom": "^19",
@@ -39,6 +40,7 @@
   "license": "MIT",
   "devDependencies": {
     "@types/jsonwebtoken": "^9.0.10",
+    "@types/nodemailer": "^8.0.0",
     "@types/react": "^19",
     "@types/react-dom": "^19",
     "@types/ws": "^8.18.1",