weifuwu 0.16.2 → 0.16.3

package/README.md

@@ -151,6 +151,7 @@ All use the same pattern — `const m = module(options)` → `app.use('/path', m
 | `embed()` / `embedMany()` | AI SDK — text embeddings |
 | `smoothStream()` | AI SDK — smooth streaming middleware |
 | `openai` / `createOpenAI()` | OpenAI provider for AI SDK |
+| `createHub(options?)` | WebSocket channel hub — `join()`, `leave()`, `broadcast()` with optional Redis pub/sub |
 
 ---
 
@@ -307,6 +308,39 @@ const server = serve(app.handler(), {
 })
 ```
 
+### Cross-process WebSocket with `createHub`
+
+Use `createHub()` to group WebSocket connections into named channels and broadcast to them — works within a single process, and with optional Redis pub/sub across multiple Node.js processes behind a load balancer.
+
+```ts
+import { createHub, serve, Router } from 'weifuwu'
+import { redis } from 'weifuwu'
+
+const hub = createHub({ redis })   // omit redis for in-process only
+
+const app = new Router().ws('/chat/:room', {
+  open(ws, ctx) {
+    hub.join(`room:${ctx.params.room}`, ws)
+  },
+  message(ws, ctx, data) {
+    hub.broadcast(`room:${ctx.params.room}`, {
+      user: ctx.user?.id,
+      text: data.toString(),
+    })
+  },
+  close(ws) {
+    hub.leave(ws)
+  },
+})
+
+serve(app.handler(), {
+  port: 3000,
+  websocket: app.websocketHandler(),
+})
+```
+
+With Redis configured, `hub.broadcast()` publishes to a Redis channel — all processes subscribed via `createHub({ redis })` receive and forward to their local WebSocket connections.
+
 ---
 
 # Middleware
@@ -1326,10 +1360,14 @@ All routes require `ctx.tenant` (set by `t.middleware()`). All queries automatic
 Real-time chat with channels, WebSocket, and agent routing.
 
 ```ts
-import { messager, agent } from 'weifuwu'
+import { messager, agent, redis } from 'weifuwu'
 
 const agents = agent({ pg })
-const msg = messager({ pg, agents })
+
+// Single process (no cross-process broadcast):
+// const msg = messager({ pg, agents })
+// Multi-process (Redis pub/sub broadcast):
+const msg = messager({ pg, agents, redis: redis() })
 
 await msg.migrate()
 app.use('/api', msg.router())

package/dist/hub.d.ts

@@ -0,0 +1,12 @@
+import type { Redis } from './vendor.ts';
+export interface HubOptions {
+    redis?: Redis;
+    prefix?: string;
+}
+export interface Hub {
+    join(key: string, ws: WebSocket): void;
+    leave(ws: WebSocket): void;
+    broadcast(key: string, data: unknown): void;
+    close(): Promise<void>;
+}
+export declare function createHub(opts?: HubOptions): Hub;

package/dist/index.d.ts

@@ -38,6 +38,8 @@ export { user } from './user/index.ts';
 export type { UserOptions, UserData, UserModule, OAuth2Client, } from './user/types.ts';
 export { redis } from './redis/index.ts';
 export type { RedisOptions, RedisClient } from './redis/types.ts';
+export { createHub } from './hub.ts';
+export type { Hub, HubOptions } from './hub.ts';
 export { queue } from './queue/index.ts';
 export type { QueueOptions, QueueJob, Queue } from './queue/types.ts';
 export { tenant } from './tenant/index.ts';

package/dist/index.js

@@ -3465,6 +3465,62 @@ function redis(opts) {
   return mw;
 }
 
+// hub.ts
+function createHub(opts) {
+  const prefix = opts?.prefix ?? "hub:";
+  const channels2 = /* @__PURE__ */ new Map();
+  let redisPub;
+  let redisSub = null;
+  if (opts?.redis) {
+    redisPub = opts.redis;
+    redisSub = opts.redis.duplicate();
+    redisSub.on("message", (rawChannel, rawData) => {
+      if (!rawChannel.startsWith(prefix)) return;
+      const key = rawChannel.slice(prefix.length);
+      const members = channels2.get(key);
+      if (!members) return;
+      for (const ws of members) {
+        try {
+          ws.send(rawData);
+        } catch {
+        }
+      }
+    });
+  }
+  function join5(key, ws) {
+    if (!channels2.has(key)) {
+      channels2.set(key, /* @__PURE__ */ new Set());
+      redisSub?.subscribe(`${prefix}${key}`);
+    }
+    channels2.get(key).add(ws);
+  }
+  function leave(ws) {
+    for (const [, members] of channels2) {
+      members.delete(ws);
+    }
+  }
+  function broadcast(key, data) {
+    const msg = JSON.stringify(data);
+    const members = channels2.get(key);
+    if (members) {
+      for (const ws of members) {
+        try {
+          ws.send(msg);
+        } catch {
+        }
+      }
+    }
+    redisPub?.publish(`${prefix}${key}`, msg);
+  }
+  async function close() {
+    channels2.clear();
+    if (redisSub) {
+      await redisSub.quit();
+    }
+  }
+  return { join: join5, leave, broadcast, close };
+}
+
 // queue/index.ts
 import { Redis as IORedis2 } from "ioredis";
 import crypto3 from "node:crypto";
@@ -4809,40 +4865,17 @@ function agent(options) {
 }
 
 // messager/ws.ts
-var channels = /* @__PURE__ */ new Map();
 var userConnections = /* @__PURE__ */ new Map();
+var hub;
 function broadcastToChannel(channelId, data) {
-  const members = channels.get(channelId);
-  if (!members) return;
-  const msg = JSON.stringify(data);
-  for (const { ws } of members) {
-    try {
-      ws.send(msg);
-    } catch {
-    }
-  }
-}
-function subscribe(ws, userId, channelId) {
-  if (!channels.has(channelId)) channels.set(channelId, /* @__PURE__ */ new Set());
-  channels.get(channelId).add({ ws, userId });
-  if (!userConnections.has(userId)) userConnections.set(userId, /* @__PURE__ */ new Set());
-  userConnections.get(userId).add(ws);
-}
-function unsubscribe(ws) {
-  for (const [, members] of channels) {
-    for (const m of members) {
-      if (m.ws === ws) {
-        members.delete(m);
-        break;
-      }
-    }
-  }
-  for (const [, conns] of userConnections) {
-    conns.delete(ws);
-  }
+  hub?.broadcast(`messager:${channelId}`, data);
 }
 function createWSHandler(deps) {
   const { sql: sql2, agents } = deps;
+  hub = createHub({
+    redis: deps.redis,
+    prefix: "messager:"
+  });
   return {
     open(ws, ctx) {
       const userId = ctx.user?.id;
@@ -4871,8 +4904,10 @@ function createWSHandler(deps) {
             RETURNING *
           `;
           const message = row;
+          hub.join(`messager:${channel_id}`, ws);
+          if (!userConnections.has(userId)) userConnections.set(userId, /* @__PURE__ */ new Set());
+          userConnections.get(userId).add(ws);
           broadcastToChannel(channel_id, { type: "message", data: message });
-          subscribe(ws, userId, channel_id);
           if (agents) {
             const agentMembers = await sql2`
               SELECT member_id FROM "_channel_members"
@@ -4898,7 +4933,9 @@ function createWSHandler(deps) {
           break;
         }
         case "typing": {
-          if (channel_id) subscribe(ws, userId, channel_id);
+          if (channel_id) {
+            hub.join(`messager:${channel_id}`, ws);
+          }
           broadcastToChannel(channel_id, {
             type: "typing",
             channel_id,
@@ -4909,7 +4946,7 @@ function createWSHandler(deps) {
         }
         case "read": {
           if (!channel_id || !last_message_id) return;
-          subscribe(ws, userId, channel_id);
+          hub.join(`messager:${channel_id}`, ws);
           await sql2`
             UPDATE "_channel_members"
             SET last_read_id = ${last_message_id}, last_read_at = NOW()
@@ -4926,22 +4963,28 @@ function createWSHandler(deps) {
       }
     },
     close(ws) {
-      unsubscribe(ws);
+      hub?.leave(ws);
+      for (const [, conns] of userConnections) {
+        conns.delete(ws);
+      }
     },
     error(ws) {
-      unsubscribe(ws);
+      hub?.leave(ws);
+      for (const [, conns] of userConnections) {
+        conns.delete(ws);
+      }
     }
   };
 }
 
 // messager/rest.ts
 function buildRouter3(deps) {
-  const { sql: sql2, channels: channels3, members, messages: messages2, agents } = deps;
+  const { sql: sql2, channels: channels2, members, messages: messages2, agents } = deps;
   const r = new Router();
   r.post("/channels", async (req) => {
     const body = await req.json();
     if (!body.name) return Response.json({ error: "name is required" }, { status: 400 });
-    const channel = await channels3.insert({
+    const channel = await channels2.insert({
       name: body.name,
       type: body.type || "channel",
       created_by: body.created_by || 1
@@ -4984,14 +5027,14 @@ function buildRouter3(deps) {
   });
   r.get("/channels/:id", async (_req, ctx) => {
     const id2 = parseInt(ctx.params.id, 10);
-    const ch = await channels3.read(id2);
+    const ch = await channels2.read(id2);
     if (!ch) return Response.json({ error: "Channel not found" }, { status: 404 });
     const { data: memberRows } = await members.readMany({ channel_id: id2 });
     return Response.json({ channel: ch, members: memberRows });
   });
   r.delete("/channels/:id", async (_req, ctx) => {
     const id2 = parseInt(ctx.params.id, 10);
-    await channels3.delete(id2);
+    await channels2.delete(id2);
     return Response.json({ ok: true });
   });
   r.post("/channels/:id/members", async (req, ctx) => {
@@ -5092,8 +5135,9 @@ function messager(options) {
   const pg = options.pg;
   const sql2 = pg.sql;
   const agents = options.agents;
+  const redis2 = options.redis;
   const base = new PgModule(pg);
-  const channels3 = pg.table("_channels", {
+  const channels2 = pg.table("_channels", {
     id: serial("id").primaryKey(),
     tenant_id: text("tenant_id"),
     name: text("name").notNull().default(""),
@@ -5125,16 +5169,16 @@ function messager(options) {
   });
   return {
     migrate: async () => {
-      await channels3.create();
-      await channels3.createIndex("tenant_id");
+      await channels2.create();
+      await channels2.createIndex("tenant_id");
       await members.create();
       await members.createIndex("member_id");
       await members.createIndex(["channel_id", "member_id", "member_type"], { unique: true });
       await messages2.create();
       await messages2.createIndex(["channel_id", "created_at"], { desc: true });
     },
-    router: () => buildRouter3({ sql: sql2, channels: channels3, members, messages: messages2, agents }),
-    wsHandler: () => createWSHandler({ sql: sql2, agents }),
+    router: () => buildRouter3({ sql: sql2, channels: channels2, members, messages: messages2, agents }),
+    wsHandler: () => createWSHandler({ sql: sql2, agents, redis: redis2 }),
     async send(channelId, content, opts) {
       const msg = await messages2.insert({
         channel_id: channelId,
@@ -7013,7 +7057,7 @@ function logdb(options) {
 import crypto5 from "node:crypto";
 
 // iii/stream.ts
-var channels2 = /* @__PURE__ */ new Map();
+var channels = /* @__PURE__ */ new Map();
 function notify(stream, group, item, event, data) {
   const keys = [
     `${stream}`,
@@ -7022,7 +7066,7 @@ function notify(stream, group, item, event, data) {
   ];
   const msg = JSON.stringify({ type: "stream", stream_name: stream, group_id: group, item_id: item, event, data });
   for (const key of keys) {
-    const subs = channels2.get(key);
+    const subs = channels.get(key);
     if (!subs) continue;
     for (const ws of subs) {
       try {
@@ -7347,14 +7391,14 @@ function createStream(opts) {
     ...store,
     subscribe(ws, sub) {
       const key = sub.item_id ? `${sub.stream_name}:${sub.group_id}:${sub.item_id}` : sub.group_id ? `${sub.stream_name}:${sub.group_id}` : sub.stream_name;
-      if (!channels2.has(key)) channels2.set(key, /* @__PURE__ */ new Set());
-      channels2.get(key).add(ws);
+      if (!channels.has(key)) channels.set(key, /* @__PURE__ */ new Set());
+      channels.get(key).add(ws);
       if (redisSub && sub.stream_name) {
         redisSub.subscribe(`iii:stream:${sub.stream_name}`);
       }
     },
     unsubscribe(ws) {
-      for (const [, subs] of channels2) subs.delete(ws);
+      for (const [, subs] of channels) subs.delete(ws);
     },
     async migrate() {
       if (opts?.pg) {
@@ -7997,6 +8041,7 @@ export {
   auth,
   compress,
   cors,
+  createHub,
   createOpenAI,
   createSSEStream,
   createTestServer,

package/dist/messager/types.d.ts

@@ -1,9 +1,11 @@
 import type { AgentModule } from '../agent/types.ts';
 import type { PostgresClient } from '../postgres/types.ts';
+import type { Redis } from '../vendor.ts';
 export interface MessagerOptions {
     pg: PostgresClient;
     agents?: AgentModule;
     webhookTimeout?: number;
+    redis?: Redis;
 }
 export interface Channel {
     id: number;

package/dist/messager/ws.d.ts

@@ -3,6 +3,7 @@ import type { AgentModule } from '../agent/types.ts';
 interface WSDeps {
     sql: Sql<{}>;
     agents?: AgentModule;
+    redis?: import('../vendor.ts').Redis;
 }
 export declare function broadcastToChannel(channelId: number, data: any): void;
 export declare function createWSHandler(deps: WSDeps): any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weifuwu",
-  "version": "0.16.2",
+  "version": "0.16.3",
   "description": "Web-standard HTTP framework for Node.js — (req, ctx) => Response",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",