@bhooai/nexus-core 2.0.9 → 2.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bhooai/nexus-core",
-    "version": "2.0.9",
+    "version": "2.0.11",
     "publishConfig": {
         "access": "public"
     },

package/src/app/createNexusApp.ts

@@ -109,6 +109,15 @@ export async function createNexusApp(opts: CreateNexusAppOptions = {}): Promise<
   // ------------------------------------------------------------------
   const discovery = await discoverBackend(srcRoot);
 
+  // ------------------------------------------------------------------
+  // DB must be connected before importing routes/graphql that define models
+  // (blog-crud Post/Author/Comment call model() at import time — previously
+  // connect was only inside `if (admin.enabled)` after routes were mounted,
+  // causing "Not connected — call connect(uri) first." and missing /api/posts)
+  // ------------------------------------------------------------------
+  console.log(`[db] early connect ${config.db.uri} autoIndex=${config.db.autoIndex}`);
+  try { connect(config.db.uri, { autoIndex: config.db.autoIndex }); console.log(`[db] early connect ok`); } catch (e) { console.error(`[db] early connect failed`, e); }
+
   // ------------------------------------------------------------------
   // Storage facade + queue + mail — always configured, even if minimal
   // ------------------------------------------------------------------
@@ -320,6 +329,111 @@ export async function createNexusApp(opts: CreateNexusAppOptions = {}): Promise<
     onError: (err, ctx) => errorHandler.toApiError(err),
   });
 
+  // ------------------------------------------------------------------
+  // Realtime WS server — mount discovered ws/*.room.ts handlers (chat lobby)
+  // ------------------------------------------------------------------
+  let realtime: any = null;
+  try {
+    const { RealtimeServer } = await import('@bhooai/nexus-realtime');
+    realtime = new RealtimeServer({ httpServer: server.httpServer, path: '/ws' });
+    // Load custom ws rooms (e.g. chat) for persistence + presence bridging
+    const roomHandlers = new Map<string, any>();
+    for (const file of discovery.rooms) {
+      try {
+        const mod: any = await importDefault(file);
+        const def = mod?.default ?? mod;
+        if (def?.name) roomHandlers.set(def.name, def);
+      } catch (e) {
+        console.warn(`[realtime] failed to load ws room ${file.path}:`, e);
+      }
+    }
+    // Bridge custom chat protocol (roomId/msg/typing) to generic realtime (room/broadcast)
+    // so lobby works with both old clients (roomId) and new (room/broadcast).
+    const chatRoom = roomHandlers.get('chat');
+    if (chatRoom) {
+      const origOnMessage = (realtime as any).onMessage.bind(realtime);
+      (realtime as any).onMessage = async (conn: any, raw: string) => {
+        let msg: any;
+        try { msg = JSON.parse(raw); } catch { return origOnMessage(conn, raw); }
+        // Normalize join with roomId/username (chat) → generic join with room
+        if (msg.type === 'join' && (msg.roomId || msg.room)) {
+          const room = msg.room ?? msg.roomId;
+          (conn as any).data = (conn as any).data ?? {};
+          if (msg.username) (conn as any).data.username = msg.username;
+          // Persist room for later msg attribution
+          (conn as any).username = msg.username ?? (conn as any).username;
+          // Only call custom onJoin for side-effects, but suppress its broadcast (generic will handle presence)
+          try {
+            const sockLike: any = { data: (conn as any).data, join: () => {}, to: () => ({ emit: () => {} }) };
+            const ctxNoop: any = { server: { to: () => ({ emit: () => {} }), broadcast: () => {} } };
+            await chatRoom.onJoin?.(sockLike, { roomId: room, room, username: msg.username }, ctxNoop);
+          } catch {}
+          msg.room = room;
+          return origOnMessage(conn, JSON.stringify(msg));
+        }
+        // Custom msg → persist + single broadcast as 'msg' (legacy) — also visible to generic broadcast listeners
+        if (msg.type === 'msg' && (msg.roomId || msg.room) && msg.text) {
+          const room = msg.roomId ?? msg.room;
+          const from = (conn as any).data?.username ?? msg.username ?? (conn as any).username ?? 'anon';
+          const at = new Date().toISOString();
+          // Persist via chat handler (Message.create) without double-broadcast
+          if (chatRoom?.onMessage?.['msg']) {
+            try {
+              const sockLike: any = { data: (conn as any).data ?? { username: from } };
+              const ctxNoop: any = { server: { to: () => ({ emit: () => {} }), broadcast: () => {} } };
+              await chatRoom.onMessage['msg'](sockLike, { roomId: room, room, text: msg.text }, ctxNoop);
+            } catch {}
+          }
+          // Single publish as 'msg' — include room so deliverRoom can route to all members (including sender, since origin undefined)
+          const payload: any = { type: 'msg', room, from, text: msg.text, at, payload: { from, text: msg.text, at } };
+          try { (realtime as any).adapter.publish(`room:${room}`, JSON.stringify(payload)); } catch {}
+          try { (realtime as any).adapter.publish(`room:chat:${room}`, JSON.stringify(payload)); } catch {}
+          return;
+        }
+        if (msg.type === 'typing' && (msg.roomId || msg.room)) {
+          const room = msg.roomId ?? msg.room;
+          const username = (conn as any).data?.username ?? msg.username ?? 'anon';
+          const payload: any = { type: 'typing', room, username, payload: { username } };
+          try { (realtime as any).adapter.publish(`room:${room}`, JSON.stringify(payload)); } catch {}
+          try { (realtime as any).adapter.publish(`room:chat:${room}`, JSON.stringify(payload)); } catch {}
+          return;
+        }
+        // Handle generic broadcast with event:msg (from new clients) → persist + re-broadcast as msg
+        if (msg.type === 'broadcast' && msg.event === 'msg' && msg.data?.text) {
+          const room = msg.room;
+          const from = msg.data.from ?? (conn as any).data?.username ?? 'anon';
+          const text = msg.data.text;
+          const at = msg.data.at ?? new Date().toISOString();
+          if (chatRoom?.onMessage?.['msg']) {
+            try {
+              const sockLike: any = { data: (conn as any).data ?? { username: from } };
+              const ctxNoop: any = { server: { to: () => ({ emit: () => {} }), broadcast: () => {} } };
+              await chatRoom.onMessage['msg'](sockLike, { roomId: room, room, text }, ctxNoop);
+            } catch {}
+          }
+          const payload: any = { type: 'msg', room, from, text, at, payload: { from, text, at } };
+          try { (realtime as any).adapter.publish(`room:${room}`, JSON.stringify(payload)); } catch {}
+          try { (realtime as any).adapter.publish(`room:chat:${room}`, JSON.stringify(payload)); } catch {}
+          return;
+        }
+        if (msg.type === 'broadcast' && msg.event === 'typing') {
+          const room = msg.room;
+          const username = msg.data?.username ?? (conn as any).data?.username ?? 'anon';
+          const payload: any = { type: 'typing', room, username, payload: { username } };
+          try { (realtime as any).adapter.publish(`room:${room}`, JSON.stringify(payload)); } catch {}
+          try { (realtime as any).adapter.publish(`room:chat:${room}`, JSON.stringify(payload)); } catch {}
+          return;
+        }
+        // Normalize roomId → room for generic handling
+        if (msg.roomId && !msg.room) msg.room = msg.roomId;
+        return origOnMessage(conn, JSON.stringify(msg));
+      };
+    }
+  } catch (e) {
+    // realtime optional — if not installed, ws lobby falls back to no-op
+    if ((e as any)?.code !== 'ERR_MODULE_NOT_FOUND') console.warn('[realtime] ws init failed:', e);
+  }
+
   // Body parsing (JSON / urlencoded / multipart) — before everything else so
   // POST/PUT/PATCH handlers see ctx.body.
   server.use(bodyParser(config.server.bodyLimit));