@bhooai/nexus-examples 2.0.9 → 2.0.11

package/examples/blog-crud/apps/backend/src/routes/posts.ts

@@ -39,7 +39,7 @@ export default defineRoutes([
     method: 'GET',
     path: '/api/posts',
     handler: async (ctx) => {
-      const posts = await Post.find({}, { sort: { createdAt: -1 } });
+      const posts = await Post.find().sort({ createdAt: -1 });
       ctx.json({ posts: posts.map(toJson) });
     },
   },
@@ -75,7 +75,7 @@ export default defineRoutes([
     handler: async (ctx) => {
       const post = await Post.findById(ctx.params.id);
       if (!post) throw new NotFoundError('post not found');
-      const comments = await Comment.find({ postId: ctx.params.id }, { sort: { createdAt: 1 } });
+      const comments = await Comment.find({ postId: ctx.params.id }).sort({ createdAt: 1 });
       ctx.json({ post: toJson(post), comments: comments.map((c) => (c as unknown as { toObject(): Record<string, unknown> }).toObject?.() ?? c) });
     },
   },

package/examples/chat/apps/backend/src/routes/chat.ts

@@ -7,10 +7,20 @@ export default defineRoutes([
     path: '/api/chat/rooms/:roomId/messages',
     handler: async (ctx) => {
       const limit = Math.min(parseInt((ctx.query.limit as string) ?? '50', 10), 200);
-      const messages = await Message.find(
-        { roomId: ctx.params.roomId },
-        { sort: { createdAt: -1 }, limit },
-      );
+      const docs = await Message.find({ roomId: ctx.params.roomId }).sort({ createdAt: -1 }).limit(limit);
+      // Normalize to frontend shape {from, text, at} — Message has {username, text, createdAt}
+      const messages = docs.map((d: any) => {
+        const o = (d as any).toObject?.() ?? (d as any)._doc ?? d;
+        return {
+          _id: o._id,
+          roomId: o.roomId,
+          from: o.username ?? o.from ?? 'anon',
+          username: o.username ?? o.from ?? 'anon',
+          text: o.text,
+          at: o.createdAt ? new Date(o.createdAt).toISOString() : o.at ?? new Date().toISOString(),
+          createdAt: o.createdAt,
+        };
+      });
       ctx.json({ messages: messages.reverse() });
     },
   },

package/examples/chat/apps/backend/src/ws/chat.room.ts

@@ -12,45 +12,60 @@
 export default {
   name: 'chat',
 
-  async onJoin(socket: any, payload: { roomId: string; username: string }) {
+  async onJoin(socket: any, payload: { roomId?: string; room?: string; username: string }) {
+    const roomId = payload.roomId ?? payload.room ?? 'lobby';
+    socket.data = socket.data ?? {};
     socket.data.username = payload.username;
-    socket.join(`chat:${payload.roomId}`);
-    socket.to(`chat:${payload.roomId}`).emit('presence', {
-      type: 'join',
-      username: payload.username,
-    });
+    // Support both legacy Socket.IO style (join/to) and RealtimeServer (broadcast)
+    try { socket.join?.(`chat:${roomId}`); } catch {}
+    try { socket.join?.(roomId); } catch {}
+    const emitPresence = (type: 'join' | 'leave') => {
+      const data = { type, username: payload.username };
+      try { socket.to?.(`chat:${roomId}`)?.emit?.('presence', data); } catch {}
+      try { socket.to?.(roomId)?.emit?.('presence', data); } catch {}
+    };
+    emitPresence('join');
   },
 
-  async onLeave(socket: any, payload: { roomId: string }) {
-    socket.to(`chat:${payload.roomId}`).emit('presence', {
-      type: 'leave',
-      username: socket.data?.username,
-    });
+  async onLeave(socket: any, payload: { roomId?: string; room?: string }) {
+    const roomId = payload.roomId ?? payload.room ?? 'lobby';
+    const data = { type: 'leave', username: socket.data?.username };
+    try { socket.to?.(`chat:${roomId}`)?.emit?.('presence', data); } catch {}
+    try { socket.to?.(roomId)?.emit?.('presence', data); } catch {}
   },
 
   onMessage: {
-    'msg': async (socket: any, payload: { roomId: string; text: string }, ctx: any) => {
+    'msg': async (socket: any, payload: { roomId?: string; room?: string; text: string }, ctx: any) => {
+      const roomId = payload.roomId ?? payload.room ?? 'lobby';
       const msg = {
         from: socket.data?.username ?? 'anon',
         text: payload.text,
         at: new Date().toISOString(),
       };
-      // Persist (optional; async so we don't block broadcast)
       try {
         const { Message } = await import('../models/Message.js');
         await Message.create({
-          roomId: payload.roomId,
+          roomId,
           userId: socket.data?.userId ?? 'anon',
           username: msg.from,
           text: msg.text,
         });
       } catch { /* swallow */ }
-      ctx.server.to(`chat:${payload.roomId}`).emit('msg', msg);
+      // Broadcast via both legacy and RealtimeServer APIs for compatibility
+      try { ctx.server.to?.(`chat:${roomId}`)?.emit?.('msg', msg); } catch {}
+      try { ctx.server.to?.(roomId)?.emit?.('msg', msg); } catch {}
+      try { ctx.server.broadcast?.(roomId, 'msg', msg); } catch {}
+      try { ctx.server.broadcast?.(`chat:${roomId}`, 'msg', msg); } catch {}
+      // Also generic broadcast with event for RealtimeServer clients
+      try { ctx.server.broadcast?.(roomId, 'broadcast', { event: 'msg', data: msg }); } catch {}
     },
-    'typing': (socket: any, payload: { roomId: string }, ctx: any) => {
-      socket.to(`chat:${payload.roomId}`).emit('typing', {
-        username: socket.data?.username,
-      });
+    'typing': (socket: any, payload: { roomId?: string; room?: string }, ctx: any) => {
+      const roomId = payload.roomId ?? payload.room ?? 'lobby';
+      const data = { username: socket.data?.username };
+      try { socket.to?.(`chat:${roomId}`)?.emit?.('typing', data); } catch {}
+      try { socket.to?.(roomId)?.emit?.('typing', data); } catch {}
+      try { ctx.server.broadcast?.(roomId, 'typing', data); } catch {}
+      try { ctx.server.broadcast?.(roomId, 'broadcast', { event: 'typing', data }); } catch {}
     },
   },
 };

package/examples/chat/apps/frontend/src/main.tsx

@@ -1,7 +1,7 @@
 import React, { useEffect, useRef, useState } from 'react';
 import { createRoot } from 'react-dom/client';
 
-interface Msg { from: string; text: string; at: string }
+interface Msg { from: string; text: string; at: string; username?: string; createdAt?: string }
 
 function App() {
   const [roomId, setRoomId] = useState('lobby');
@@ -21,45 +21,81 @@ function App() {
 
     ws.onopen = () => {
       setConnected(true);
-      ws.send(JSON.stringify({ type: 'join', roomId, username }));
+      // Send both room and roomId for compatibility (generic RealtimeServer uses room, chat.room uses roomId)
+      ws.send(JSON.stringify({ type: 'join', room: roomId, roomId, username }));
     };
     ws.onclose = () => setConnected(false);
     ws.onmessage = (ev) => {
       try {
         const data = JSON.parse(ev.data);
-        if (data.type === 'msg') setMessages((m) => [...m, data.payload]);
+        // Legacy chat protocol
+        if (data.type === 'msg') setMessages((m) => [...m, data.payload ?? data]);
         else if (data.type === 'presence') {
           setPresence((p) => {
-            if (data.payload.type === 'join') return [...new Set([...p, data.payload.username])];
-            return p.filter((u) => u !== data.payload.username);
+            if (data.payload?.type === 'join' || data.type === 'join') return [...new Set([...p, data.payload?.username ?? data.username])];
+            return p.filter((u) => u !== (data.payload?.username ?? data.username));
           });
         } else if (data.type === 'typing') {
-          setTypingUsers((t) => [...new Set([...t, data.payload.username])]);
-          setTimeout(() => setTypingUsers((t) => t.filter((u) => u !== data.payload.username)), 2000);
+          const u = data.payload?.username ?? data.username;
+          if (!u) return;
+          setTypingUsers((t) => [...new Set([...t, u])]);
+          setTimeout(() => setTypingUsers((t) => t.filter((x) => x !== u)), 2000);
+        }
+        // Generic RealtimeServer protocol
+        else if (data.type === 'joined') {
+          if (Array.isArray(data.peers)) setPresence((p) => [...new Set([...p, ...data.peers])]);
+        } else if (data.type === 'peer-joined') {
+          if (data.peer) setPresence((p) => [...new Set([...p, data.peer])]);
+        } else if (data.type === 'peer-left') {
+          if (data.peer) setPresence((p) => p.filter((u) => u !== data.peer));
+        } else if (data.type === 'broadcast') {
+          const ev = data.event;
+          const payload = data.data ?? data.payload;
+          if (ev === 'msg' && payload) setMessages((m) => [...m, { from: payload.from ?? data.from, text: payload.text, at: payload.at ?? new Date().toISOString() }]);
+          else if (ev === 'typing' && payload?.username) {
+            const u2 = payload.username;
+            setTypingUsers((t) => [...new Set([...t, u2])]);
+            setTimeout(() => setTypingUsers((t) => t.filter((x) => x !== u2)), 2000);
+          } else if (ev === 'presence' && payload) {
+            setPresence((p) => {
+              if (payload.type === 'join') return [...new Set([...p, payload.username])];
+              return p.filter((u) => u !== payload.username);
+            });
+          }
         }
       } catch { /* ignore */ }
     };
     return () => ws.close();
   }, [roomId, username]);
 
-  // Load history on room change
+  // Load history on room change — normalize createdAt→at and username→from for legacy docs
   useEffect(() => {
     fetch(`/api/chat/rooms/${roomId}/messages`)
       .then((r) => r.json())
-      .then((data) => setMessages(data.messages ?? []))
+      .then((data) => {
+        const list = (data.messages ?? []) as any[];
+        const normalized = list.map((m: any) => ({
+          from: m.from ?? m.username ?? 'anon',
+          text: m.text,
+          at: m.at ?? (m.createdAt ? new Date(m.createdAt).toISOString() : new Date().toISOString()),
+          username: m.username ?? m.from,
+          createdAt: m.createdAt ?? m.at,
+        }));
+        setMessages(normalized);
+      })
       .catch(() => {});
   }, [roomId]);
 
   const send = () => {
     if (!draft.trim() || !wsRef.current) return;
-    wsRef.current.send(JSON.stringify({ type: 'msg', roomId, text: draft }));
+    wsRef.current.send(JSON.stringify({ type: 'msg', roomId, room: roomId, text: draft, username }));
     setDraft('');
   };
 
   const onType = (v: string) => {
     setDraft(v);
     if (wsRef.current && v.length % 3 === 0) {
-      wsRef.current.send(JSON.stringify({ type: 'typing', roomId }));
+      wsRef.current.send(JSON.stringify({ type: 'typing', roomId, room: roomId }));
     }
   };
 
@@ -78,11 +114,17 @@ function App() {
       </div>
 
       <div style={{ border: '1px solid #ccc', borderRadius: 8, padding: '1rem', minHeight: 300, maxHeight: 400, overflow: 'auto', marginBottom: '1rem', background: '#fafafa' }}>
-        {messages.map((m, i) => (
-          <div key={i} style={{ marginBottom: '0.5rem' }}>
-            <strong>{m.from}</strong>: {m.text} <span style={{ color: '#999', fontSize: '0.75rem' }}>{new Date(m.at).toLocaleTimeString()}</span>
-          </div>
-        ))}
+        {messages.map((m, i) => {
+          const from = (m as any).from ?? (m as any).username ?? 'anon';
+          const at = (m as any).at ?? (m as any).createdAt;
+          const time = at ? new Date(at).toLocaleTimeString() : '';
+          const isInvalid = !at || time === 'Invalid Date';
+          return (
+            <div key={i} style={{ marginBottom: '0.5rem' }}>
+              <strong>{from}</strong>: {m.text} <span style={{ color: '#999', fontSize: '0.75rem' }}>{isInvalid ? '' : time}</span>
+            </div>
+          );
+        })}
       </div>
 
       <div style={{ display: 'flex', gap: '0.5rem' }}>

package/examples/checkout/apps/backend/src/mail/templates/order-confirmation.ejs

@@ -2,13 +2,13 @@
 <html>
   <body style="font-family: system-ui, sans-serif; color: #222;">
     <h1>Thanks for your order!</h1>
-    <p>Order <strong><%= orderId %></strong> has been confirmed.</p>
+    <p>Order <strong><%= typeof orderId !== 'undefined' ? orderId : '' %></strong> has been confirmed.</p>
     <table cellpadding="6" style="border-collapse: collapse;">
       <thead>
         <tr><th align="left">Item</th><th align="right">Qty</th><th align="right">Price</th></tr>
       </thead>
       <tbody>
-        <% items.forEach(function (item) { %>
+        <% if (typeof items !== 'undefined' && Array.isArray(items)) items.forEach(function (item) { %>
           <tr>
             <td><%= item.name %></td>
             <td align="right"><%= item.qty %></td>
@@ -19,7 +19,7 @@
       <tfoot>
         <tr>
           <td colspan="2" align="right"><strong>Total</strong></td>
-          <td align="right"><strong><%= currency %> <%= total %></strong></td>
+          <td align="right"><strong><%= typeof currency !== 'undefined' ? currency : '' %> <%= typeof total !== 'undefined' ? total : '' %></strong></td>
         </tr>
       </tfoot>
     </table>

package/examples/multi-app/_setup.mjs

@@ -0,0 +1,39 @@
+/**
+ * multi-app example — setup script run by `nexus init --example multi-app`
+ * BEFORE the overlay is copied (`init.ts` runs this before `renderTemplateTree`).
+ *
+ * Scaffolds the extra backends/frontends so the subsequent overlay can drop
+ * products.ts / users.ts into already-existing app folders.
+ *
+ * Each add* is idempotent — if the app dir already exists but is incomplete,
+ * missing files are filled and port is ensured.
+ *
+ * @param {import('../../../nexus-cli/src/commands/init.js').SetupContext} ctx
+ */
+export default async function setup(ctx) {
+  const { utils, vars } = ctx;
+  const log = utils.log ?? console.log;
+
+  log('  → multi-app setup: scaffolding extra apps...');
+
+  // Two extra backends (default backend already exists from base template)
+  const shop = await utils.addBackend('shop');
+  log(`    backend-shop :${shop.port} ${shop.created ? '(created)' : '(repaired/exists)'}`);
+
+  const api = await utils.addBackend('api');
+  log(`    backend-api  :${api.port} ${api.created ? '(created)' : '(repaired/exists)'}`);
+
+  // Two extra frontends wired to their backends
+  const feShop = await utils.addFrontend('shop', { for: 'backend-shop' });
+  log(`    frontend-shop :${feShop.port} → ${feShop.backend}:${feShop.backendPort} ${feShop.created ? '(created)' : '(repaired)'}`);
+
+  const feWeb = await utils.addFrontend('web', { for: 'backend' });
+  log(`    frontend-web  :${feWeb.port} → ${feWeb.backend}:${feWeb.backendPort} ${feWeb.created ? '(created)' : '(repaired)'}`);
+
+  // Overlay will now copy:
+  //   apps/backend-shop/src/routes/products.ts
+  //   apps/backend-api/src/routes/users.ts
+  // on top of these freshly scaffolded apps.
+  log('  → multi-app setup done. Overlay routes will be applied next.');
+  void vars;
+}

package/examples/multi-app/apps/backend-api/src/routes/users.ts

@@ -1,11 +1,17 @@
 import { defineRoutes } from '@bhooai/nexus-core';
+import { z } from 'zod';
 
-// Mounted on the "api" backend (apps/backend-api) — shared identity/service API.
+// Mounted on the "api" backend (apps/backend-api) — shared identity/service API. In-memory for smoke test.
 const USERS = [
   { id: 'u-1', name: 'Ada Lovelace', email: 'ada@example.com' },
   { id: 'u-2', name: 'Grace Hopper', email: 'grace@example.com' },
 ];
 
+const createUserSchema = z.object({
+  name: z.string().min(1, 'name required').max(80),
+  email: z.string().email('invalid email'),
+});
+
 export default defineRoutes([
   {
     method: 'GET',
@@ -23,4 +29,15 @@ export default defineRoutes([
       ctx.json({ user });
     },
   },
+  {
+    method: 'POST',
+    path: '/api/users',
+    handler: async (ctx) => {
+      const parsed = createUserSchema.safeParse(ctx.body);
+      if (!parsed.success) return ctx.json({ error: 'validation failed', details: parsed.error.flatten() }, 400);
+      const user = { id: `u-${Date.now()}`, ...parsed.data };
+      USERS.push(user);
+      ctx.json({ user }, 201);
+    },
+  },
 ]);

package/examples/multi-app/apps/backend-shop/src/routes/products.ts

@@ -1,12 +1,18 @@
 import { defineRoutes } from '@bhooai/nexus-core';
+import { z } from 'zod';
 
-// Mounted on the "shop" backend (apps/backend-shop) — the storefront API.
+// Mounted on the "shop" backend (apps/backend-shop) — the storefront API. In-memory for smoke test.
 const PRODUCTS = [
   { id: 'sku-1', name: 'Nexus mug', priceCents: 49900 },
   { id: 'sku-2', name: 'Nexus tee', priceCents: 89900 },
   { id: 'sku-3', name: 'Sticker pack', priceCents: 14900 },
 ];
 
+const createProductSchema = z.object({
+  name: z.string().min(1, 'name required').max(100),
+  priceCents: z.number().int().min(0).max(1_000_000).optional().default(0),
+});
+
 export default defineRoutes([
   {
     method: 'GET',
@@ -24,4 +30,15 @@ export default defineRoutes([
       ctx.json({ product });
     },
   },
+  {
+    method: 'POST',
+    path: '/api/products',
+    handler: async (ctx) => {
+      const parsed = createProductSchema.safeParse(ctx.body);
+      if (!parsed.success) return ctx.json({ error: 'validation failed', details: parsed.error.flatten() }, 400);
+      const product = { id: `sku-${Date.now()}`, ...parsed.data };
+      PRODUCTS.push(product);
+      ctx.json({ product }, 201);
+    },
+  },
 ]);

package/examples/multi-app/apps/frontend-shop/src/main.tsx

@@ -0,0 +1,63 @@
+import React, { useEffect, useState } from 'react';
+import { createRoot } from 'react-dom/client';
+
+type Product = { id: string; name: string; priceCents: number };
+
+function App() {
+  const [products, setProducts] = useState<Product[]>([]);
+  const [name, setName] = useState('');
+  const [price, setPrice] = useState('');
+  const [msg, setMsg] = useState('');
+
+  const fetchProducts = async () => {
+    try {
+      const r = await fetch('/api/products');
+      const data = await r.json();
+      setProducts(data.products ?? []);
+    } catch (e) { setMsg(String(e)); }
+  };
+
+  useEffect(() => { fetchProducts(); }, []);
+
+  const createProduct = async (e: React.FormEvent) => {
+    e.preventDefault();
+    setMsg('');
+    const priceCents = price ? parseInt(price, 10) : 0;
+    const res = await fetch('/api/products', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ name, priceCents }),
+    });
+    const data = await res.json();
+    if (!res.ok) {
+      setMsg(`Error ${res.status}: ${JSON.stringify(data)}`);
+      return;
+    }
+    setMsg(`Created ${data.product.id}`);
+    setName(''); setPrice('');
+    fetchProducts();
+  };
+
+  return <main style={{ fontFamily: 'system-ui', padding: '2rem', maxWidth: 640 }}>
+    <h1>shop — backend-shop via proxy</h1>
+    <p style={{ color: '#666' }}>Served by apps/frontend-shop; proxying /api to backend-shop.</p>
+
+    <h2>Products (GET /api/products)</h2>
+    <ul>
+      {products.map(p => <li key={p.id}><b>{p.name}</b> — {(p.priceCents/100).toFixed(2)} ({p.id})</li>)}
+      {products.length===0 && <li style={{color:'#999'}}>no products</li>}
+    </ul>
+    <button onClick={fetchProducts} style={{ marginBottom: 16 }}>Refresh</button>
+
+    <h2>Create product (POST /api/products) — zod validated</h2>
+    <form onSubmit={createProduct} style={{ display:'grid', gap: 8, maxWidth: 360 }}>
+      <input placeholder="name (required)" value={name} onChange={e=>setName(e.target.value)} />
+      <input placeholder="priceCents (int)" value={price} onChange={e=>setPrice(e.target.value)} />
+      <button type="submit">Create</button>
+    </form>
+    {msg && <pre style={{ background:'#f5f5f5', padding:8, marginTop:12 }}>{msg}</pre>}
+  </main>;
+}
+
+const el = document.getElementById('root');
+if (el) createRoot(el).render(<App />);

package/examples/multi-app/apps/frontend-web/src/main.tsx

@@ -0,0 +1,70 @@
+import React, { useEffect, useState } from 'react';
+import { createRoot } from 'react-dom/client';
+
+type User = { id: string; name: string; email: string };
+
+function App() {
+  const [users, setUsers] = useState<User[]>([]);
+  const [me, setMe] = useState<any>(null);
+  const [name, setName] = useState('');
+  const [email, setEmail] = useState('');
+  const [msg, setMsg] = useState('');
+
+  const fetchMe = async () => {
+    try {
+      const r = await fetch('/me');
+      setMe(await r.json());
+    } catch {}
+  };
+
+  const fetchUsers = async () => {
+    try {
+      const r = await fetch('/api/users');
+      const data = await r.json();
+      setUsers(data.users ?? []);
+    } catch (e) { setMsg(String(e)); }
+  };
+
+  useEffect(() => { fetchUsers(); fetchMe(); }, []);
+
+  const createUser = async (e: React.FormEvent) => {
+    e.preventDefault();
+    setMsg('');
+    const res = await fetch('/api/users', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ name, email }),
+    });
+    const data = await res.json();
+    if (!res.ok) { setMsg(`Error ${res.status}: ${JSON.stringify(data)}`); return; }
+    setMsg(`Created ${data.user.id}`);
+    setName(''); setEmail('');
+    fetchUsers();
+  };
+
+  return <main style={{ fontFamily: 'system-ui', padding: '2rem', maxWidth: 640 }}>
+    <h1>web — demos both backends</h1>
+    <p style={{ color:'#666' }}>frontend-web :3002 proxies /api/users → backend-api:4002, /me → backend:4000.</p>
+
+    <h2>GET /me (backend :4000)</h2>
+    <pre style={{ background:'#f5f5f5', padding:8 }}>{me ? JSON.stringify(me,null,2) : 'loading...'}</pre>
+
+    <h2>Users — backend-api :4002 (GET /api/users)</h2>
+    <ul>
+      {users.map(u => <li key={u.id}><b>{u.name}</b> — {u.email} ({u.id})</li>)}
+      {users.length===0 && <li style={{color:'#999'}}>no users</li>}
+    </ul>
+    <button onClick={fetchUsers} style={{ marginBottom:16 }}>Refresh users</button>
+
+    <h2>Create user (POST /api/users) — zod validated</h2>
+    <form onSubmit={createUser} style={{ display:'grid', gap:8, maxWidth:360 }}>
+      <input placeholder="name (required)" value={name} onChange={e=>setName(e.target.value)} />
+      <input placeholder="email (required, must be email)" value={email} onChange={e=>setEmail(e.target.value)} />
+      <button type="submit">Create</button>
+    </form>
+    {msg && <pre style={{ background:'#f5f5f5', padding:8, marginTop:12 }}>{msg}</pre>}
+  </main>;
+}
+
+const el = document.getElementById('root');
+if (el) createRoot(el).render(<App />);

package/examples/multi-app/apps/frontend-web/vite.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from 'vite';
+
+const backendHost = process.env.NEXUS_BACKEND_HOST ?? 'localhost';
+
+export default defineConfig({
+  server: {
+    port: 3002,
+    proxy: {
+      '/api/users': { target: `http://${backendHost}:4002`, changeOrigin: true },
+      '/api/products': { target: `http://${backendHost}:4001`, changeOrigin: true },
+      '/api': { target: `http://${backendHost}:4000`, changeOrigin: true },
+      '/me': { target: `http://${backendHost}:4000`, changeOrigin: true },
+      '/uploads': { target: `http://${backendHost}:4000`, changeOrigin: true },
+      '/ws': { target: `ws://${backendHost}:4000`, ws: true },
+    },
+  },
+});

package/examples/saas-starter/apps/backend/src/middleware/auth.ts

@@ -5,10 +5,11 @@ import { AuthenticationError } from '@bhooai/nexus-core';
  * Demo auth middleware: trusts an `x-user-id` header instead of verifying a
  * real session/JWT. Swap for nexus-auth's jwt middleware in production.
  */
-export const requireAuth: Middleware = async (ctx) => {
+export const requireAuth: Middleware = async (ctx, next) => {
   const userId = ctx.headers['x-user-id'];
   if (typeof userId !== 'string' || userId.length === 0) {
     throw new AuthenticationError('Sign in required (x-user-id header in this demo)');
   }
   ctx.state.userId = userId;
+  await next();
 };

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@bhooai/nexus-examples",
-    "version": "2.0.9",
-    "description": "Working examples for BhooAI Nexus v2 — each demos a slice of the framework.",
+    "version": "2.0.11",
+    "description": "Working examples for BhooAI Nexus v2 — each demos a slice of the framework.",
     "license": "MIT",
     "type": "module",
     "main": "./src/index.ts",