@emeryld/rrroutes-server 2.0.4 → 2.0.6

package/dist/index.cjs

@@ -419,10 +419,10 @@ function warnMissingControllers(router, registry, logger) {
   }
 }
 
-// src/sockets/socket.server.index.ts
-function createSocketConnections(io, events, opts) {
-  const debug = opts?.debug ?? {};
-  const dbg = (maybeEvent, e) => {
+// src/sockets/socket.server.debug.ts
+function createDebugger(options) {
+  const debug = options ?? {};
+  return (maybeEvent, e) => {
     if (!debug.logger) return;
     if (!debug[e.type]) return;
     if (debug.only && maybeEvent && (e.type === "register" || e.type === "handler" || e.type === "emit") && !debug.only.includes(maybeEvent)) {
@@ -430,40 +430,39 @@ function createSocketConnections(io, events, opts) {
     }
     debug.logger(e);
   };
-  const getSchema = (k) => events[k].message;
-  const toArray = (rooms) => rooms == null ? [] : Array.isArray(rooms) ? rooms : [rooms];
-  const registrations = /* @__PURE__ */ new Map();
-  const addRegistration = (eventName, reg) => {
-    let set = registrations.get(eventName);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      registrations.set(eventName, set);
-    }
-    set.add(reg);
-  };
-  const removeAllForEvent = (eventName) => {
-    const set = registrations.get(eventName);
-    if (!set) return;
-    for (const reg of set) {
-      io.off("connection", reg.connectionListener);
-      for (const socket of io.sockets.sockets.values()) {
-        const wrapped = reg.socketListeners.get(socket);
-        if (wrapped) socket.off(String(eventName), wrapped);
-      }
-    }
-    registrations.delete(eventName);
-    dbg(eventName, { type: "register", action: "unregister", event: eventName });
-  };
-  const roomJoinEvent = opts?.rooms?.roomJoinEvent ?? "room:join";
-  const roomLeaveEvent = opts?.rooms?.roomLeaveEvent ?? "room:leave";
-  const hb = opts?.heartbeat;
-  if (!hb) throw new Error("createSocketConnections: heartbeat config is required");
-  const pingEvent = hb.pingEvent ?? "sys:ping";
-  const pongEvent = hb.pongEvent ?? "sys:pong";
-  const sysEvents = opts?.sys ?? {};
+}
+
+// src/sockets/socket.server.sys.ts
+var import_zod = require("zod");
+var normalizeError = (error) => {
+  if (error instanceof Error) {
+    return { name: error.name, message: error.message };
+  }
+  if (typeof error === "string") return { message: error };
+  return { message: "Unknown error" };
+};
+var roomValueSchema = import_zod.z.union([import_zod.z.string(), import_zod.z.array(import_zod.z.string())]);
+var buildRoomPayloadSchema = (metaSchema) => import_zod.z.object({
+  rooms: roomValueSchema,
+  meta: metaSchema
+});
+var toArray = (rooms) => rooms == null ? [] : Array.isArray(rooms) ? rooms : [rooms];
+function createBuiltInConnectionHandlers(opts) {
+  const { heartbeat, sys, dbg, config, createCtx } = opts;
+  const roomJoinEvent = "sys:room_join";
+  const roomLeaveEvent = "sys:room_leave";
+  const pingEvent = "sys:ping";
+  const pongEvent = "sys:pong";
+  const heartbeatEnabled = heartbeat?.enabled !== false;
+  const joinPayloadSchema = buildRoomPayloadSchema(config.joinMetaMessage);
+  const leavePayloadSchema = buildRoomPayloadSchema(config.leaveMetaMessage);
+  const pingPayloadSchema = config.pingPayload;
+  const pongPayloadSchema = config.pongPayload;
+  const sysEvents = sys;
   const getSysEvent = (name) => sysEvents[name];
   const socketTeardowns = /* @__PURE__ */ new WeakMap();
   const builtInConnectionListener = (socket) => {
+    const typedSocket = socket;
     const defaultConnect = () => {
       if (socket.data?.user) {
         dbg(null, {
@@ -473,140 +472,160 @@ function createSocketConnections(io, events, opts) {
           sub: socket.data.user?.sub
         });
       }
-      const joinHandler = async ({ rooms }) => {
-        const list = toArray(rooms);
-        const defaultJoin = async () => {
-          for (const r of list) {
-            const allowed = !opts?.rooms?.onRoomJoin || await opts.rooms.onRoomJoin({ room: r, socket }) === true;
-            if (allowed) {
-              await socket.join(r);
-              dbg(null, { type: "rooms", action: "join", rooms: [r], socketId: socket.id });
-            }
-          }
+      const joinHandler = async (msg) => {
+        const parsed = joinPayloadSchema.safeParse(msg);
+        if (!parsed.success) {
+          socket.emit(`${roomJoinEvent}:error`, {
+            eventName: roomJoinEvent,
+            issues: parsed.error.issues
+          });
+          dbg("sys:room_join", {
+            type: "handler",
+            phase: "validation_error",
+            event: roomJoinEvent,
+            issues: parsed.error.issues
+          });
+          return;
+        }
+        const list = toArray(parsed.data.rooms);
+        const join = async (room) => {
+          await socket.join(room);
+          dbg(null, { type: "rooms", action: "join", room, socketId: socket.id });
         };
-        const sysRoomJoin = getSysEvent("sys:room_join");
-        if (sysRoomJoin?.sysHandler) {
-          await sysRoomJoin.sysHandler({
-            name: "sys:room_join",
-            socket,
+        const run = async () => {
+          await getSysEvent("sys:room_join")({
+            socket: typedSocket,
             rooms: list,
-            next: () => {
-              void defaultJoin();
-            }
+            meta: parsed.data.meta,
+            join
+          });
+        };
+        try {
+          await run();
+        } catch (error) {
+          socket.emit(`${roomJoinEvent}:error`, { error: normalizeError(error) });
+          dbg("sys:room_join", {
+            type: "handler",
+            phase: "handler_error",
+            event: roomJoinEvent,
+            error
           });
-        } else {
-          await defaultJoin();
         }
       };
-      const leaveHandler = async ({ rooms }) => {
-        const list = toArray(rooms);
-        const defaultLeave = async () => {
-          for (const r of list) {
-            const allowed = !opts?.rooms?.onRoomLeave || await opts.rooms.onRoomLeave({ room: r, socket }) === true;
-            if (allowed) {
-              dbg(null, { type: "rooms", action: "leave", rooms: [r], socketId: socket.id });
-              await socket.leave(r);
-            }
-          }
+      const leaveHandler = async (msg) => {
+        const parsed = leavePayloadSchema.safeParse(msg);
+        if (!parsed.success) {
+          socket.emit(`${roomLeaveEvent}:error`, {
+            eventName: roomLeaveEvent,
+            issues: parsed.error.issues
+          });
+          dbg("sys:room_leave", {
+            type: "handler",
+            phase: "validation_error",
+            event: roomLeaveEvent,
+            issues: parsed.error.issues
+          });
+          return;
+        }
+        const list = toArray(parsed.data.rooms);
+        const leave = async (room) => {
+          dbg(null, { type: "rooms", action: "leave", room, socketId: socket.id });
+          await socket.leave(room);
         };
-        const sysRoomLeave = getSysEvent("sys:room_leave");
-        if (sysRoomLeave?.sysHandler) {
-          await sysRoomLeave.sysHandler({
-            name: "sys:room_leave",
-            socket,
+        const run = async () => {
+          await getSysEvent("sys:room_leave")({
+            socket: typedSocket,
             rooms: list,
-            next: () => {
-              void defaultLeave();
-            }
+            meta: parsed.data.meta,
+            leave
+          });
+        };
+        try {
+          await run();
+        } catch (error) {
+          socket.emit(`${roomLeaveEvent}:error`, { error: normalizeError(error) });
+          dbg("sys:room_leave", {
+            type: "handler",
+            phase: "handler_error",
+            event: roomLeaveEvent,
+            error
           });
-        } else {
-          await defaultLeave();
         }
       };
-      const pingHandler = (msg = {}, ack) => {
-        const emitPong = (pong) => {
-          const sysPong = getSysEvent("sys:pong");
-          const sendPong = () => {
-            if (hb.pongSchema) {
-              const check = hb.pongSchema.safeParse(pong);
-              if (!check.success) {
-                socket.emit(`${pongEvent}:error`, { issues: check.error.issues });
-                dbg(null, {
-                  type: "heartbeat",
-                  phase: "pong",
-                  socketId: socket.id,
-                  issues: check.error.issues,
-                  error: true
-                });
-                return;
-              }
-            }
-            socket.emit(pongEvent, pong);
-            dbg(null, {
-              type: "heartbeat",
-              phase: "pong",
-              socketId: socket.id,
-              payload: pong,
-              error: false
-            });
-          };
-          if (sysPong?.sysHandler) {
-            void sysPong.sysHandler({
-              name: "sys:pong",
-              socket,
-              payload: pong,
-              next: sendPong
-            });
-          } else {
-            sendPong();
-          }
-        };
-        const defaultPing = () => {
-          const parsed = hb.pingSchema.safeParse(msg?.payload);
-          if (!parsed.success) {
-            socket.emit(`${pingEvent}:error`, { issues: parsed.error.issues });
-            dbg(null, {
-              type: "heartbeat",
-              phase: "ping",
-              socketId: socket.id,
-              payload: msg?.payload,
-              issues: parsed.error.issues,
-              error: true
-            });
-            return;
-          }
+      const pingHandler = async (msg) => {
+        if (!heartbeatEnabled) return;
+        const parsedPing = pingPayloadSchema.safeParse(msg);
+        if (!parsedPing.success) {
+          socket.emit(`${pingEvent}:error`, {
+            eventName: pingEvent,
+            issues: parsedPing.error.issues
+          });
           dbg(null, {
             type: "heartbeat",
             phase: "ping",
             socketId: socket.id,
-            payload: parsed.data
+            issues: parsedPing.error.issues,
+            error: true
           });
-          const pong = hb.makePongPayload({ socket, ping: parsed.data });
-          emitPong(pong);
-          if (typeof ack === "function") {
-            ack({ serverNow: (/* @__PURE__ */ new Date()).toISOString() });
-          }
-        };
-        const sysPing = getSysEvent("sys:ping");
-        if (sysPing?.sysHandler) {
-          void sysPing.sysHandler({
-            name: "sys:ping",
-            socket,
-            raw: msg,
-            ack,
-            next: defaultPing
+          return;
+        }
+        const ctx = createCtx(socket);
+        dbg(null, {
+          type: "heartbeat",
+          phase: "ping",
+          socketId: socket.id,
+          payload: parsedPing.data,
+          error: false
+        });
+        let pongPayload;
+        try {
+          pongPayload = await getSysEvent("sys:ping")(parsedPing.data, ctx);
+        } catch (error) {
+          socket.emit(`${pingEvent}:error`, { error: normalizeError(error) });
+          dbg(null, {
+            type: "heartbeat",
+            phase: "ping",
+            socketId: socket.id,
+            payload: parsedPing.data,
+            error: true
           });
-        } else {
-          defaultPing();
+          return;
+        }
+        const parsedPong = pongPayloadSchema.safeParse(pongPayload);
+        if (!parsedPong.success) {
+          socket.emit(`${pongEvent}:error`, {
+            eventName: pongEvent,
+            issues: parsedPong.error.issues
+          });
+          dbg(null, {
+            type: "heartbeat",
+            phase: "pong",
+            socketId: socket.id,
+            issues: parsedPong.error.issues,
+            error: true
+          });
+          return;
         }
+        socket.emit(pongEvent, parsedPong.data);
+        dbg(null, {
+          type: "heartbeat",
+          phase: "pong",
+          socketId: socket.id,
+          payload: parsedPong.data,
+          error: false
+        });
       };
       socket.on(roomJoinEvent, joinHandler);
       socket.on(roomLeaveEvent, leaveHandler);
-      socket.on(pingEvent, pingHandler);
+      if (heartbeatEnabled) {
+        socket.on(pingEvent, pingHandler);
+      }
       const cleanup = () => {
         socket.off(roomJoinEvent, joinHandler);
         socket.off(roomLeaveEvent, leaveHandler);
-        socket.off(pingEvent, pingHandler);
+        if (heartbeatEnabled) {
+          socket.off(pingEvent, pingHandler);
+        }
       };
       socketTeardowns.set(socket, cleanup);
       socket.once("disconnect", (reason) => {
@@ -614,30 +633,91 @@ function createSocketConnections(io, events, opts) {
           cleanup();
           socketTeardowns.delete(socket);
         };
-        const sysDisconnect = getSysEvent("sys:disconnect");
-        if (sysDisconnect?.sysHandler) {
-          void sysDisconnect.sysHandler({
-            name: "sys:disconnect",
-            socket,
-            reason: String(reason),
-            next: defaultDisconnect
-          });
-        } else {
-          defaultDisconnect();
-        }
+        getSysEvent("sys:disconnect")({
+          socket: typedSocket,
+          reason: String(reason),
+          cleanup: defaultDisconnect
+        });
       });
     };
-    const sysConnect = getSysEvent("sys:connect");
-    if (sysConnect?.sysHandler) {
-      void sysConnect.sysHandler({
-        name: "sys:connect",
-        socket,
-        next: defaultConnect
-      });
-    } else {
-      defaultConnect();
+    getSysEvent("sys:connect")({
+      socket: typedSocket,
+      initConnection: defaultConnect
+    });
+  };
+  return {
+    builtInConnectionListener,
+    socketTeardowns,
+    roomJoinEvent,
+    roomLeaveEvent,
+    pingEvent
+  };
+}
+
+// src/sockets/socket.server.index.ts
+var createBaseHandlerCtx = (socket) => ({
+  sentAt: /* @__PURE__ */ new Date(),
+  socket,
+  socketId: socket.id,
+  nsp: socket.nsp.name,
+  rooms: Array.from(socket.rooms),
+  user: socket.data?.user,
+  scopes: socket.data?.scopes
+});
+var normalizeError2 = (error, verbose) => {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: verbose ? error.stack : void 0
+    };
+  }
+  if (typeof error === "string") return { message: error };
+  if (typeof error === "object" && error !== null) {
+    return verbose ? error : { message: "Unknown error" };
+  }
+  return { message: String(error) };
+};
+function createSocketConnections(io, events, opts) {
+  const dbg = createDebugger(opts?.debug);
+  const socketConfig = opts.config;
+  const getSchema = (k) => events[k].message;
+  const toArray2 = (rooms) => rooms == null ? [] : Array.isArray(rooms) ? rooms : [rooms];
+  const registrations = /* @__PURE__ */ new Map();
+  const addRegistration = (eventName, reg) => {
+    let set = registrations.get(eventName);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      registrations.set(eventName, set);
     }
+    set.add(reg);
   };
+  const removeAllForEvent = (eventName) => {
+    const set = registrations.get(eventName);
+    if (!set) return;
+    for (const reg of set) {
+      io.off("connection", reg.connectionListener);
+      for (const socket of io.sockets.sockets.values()) {
+        const wrapped = reg.socketListeners.get(socket);
+        if (wrapped) socket.off(String(eventName), wrapped);
+      }
+    }
+    registrations.delete(eventName);
+    dbg(eventName, { type: "register", action: "unregister", event: eventName });
+  };
+  const {
+    builtInConnectionListener,
+    socketTeardowns,
+    roomJoinEvent,
+    roomLeaveEvent,
+    pingEvent
+  } = createBuiltInConnectionHandlers({
+    heartbeat: opts?.heartbeat,
+    sys: opts.sys,
+    dbg,
+    config: socketConfig,
+    createCtx: createBaseHandlerCtx
+  });
   io.on("connection", builtInConnectionListener);
   const conn = {
     on(eventName, handler) {
@@ -646,20 +726,10 @@ function createSocketConnections(io, events, opts) {
         const wrapped = async (raw, maybeAck) => {
           const schema = getSchema(eventName);
           const parsed = schema.safeParse(raw);
+          const baseCtx = createBaseHandlerCtx(socket);
           const ctx = {
-            sentAt: /* @__PURE__ */ new Date(),
-            socket,
-            socketId: socket.id,
-            nsp: socket.nsp.name,
-            rooms: Array.from(socket.rooms),
-            user: socket.data?.user,
-            scopes: socket.data?.scopes,
-            ack: typeof maybeAck === "function" ? (d) => {
-              try {
-                maybeAck(d);
-              } catch {
-              }
-            } : void 0
+            ...baseCtx,
+            ack: maybeAck
           };
           dbg(String(eventName), {
             type: "handler",
@@ -668,7 +738,7 @@ function createSocketConnections(io, events, opts) {
             socketId: ctx.socketId,
             nsp: ctx.nsp,
             rooms: ctx.rooms,
-            raw: debug.verbose ? raw : void 0
+            raw: opts?.debug?.verbose ? raw : void 0
           });
           if (!parsed.success) {
             socket.emit(`${String(eventName)}:error`, {
@@ -698,7 +768,11 @@ function createSocketConnections(io, events, opts) {
               event: String(eventName),
               error
             });
-            throw error;
+            socket.emit(`${String(eventName)}:error`, {
+              eventName,
+              sentAt: ctx.sentAt,
+              error: normalizeError2(error, opts?.debug?.verbose)
+            });
           }
         };
         socketListeners.set(socket, wrapped);
@@ -745,7 +819,7 @@ function createSocketConnections(io, events, opts) {
       const check = schema.safeParse(payload);
       if (!check.success)
         throw new Error(`Invalid payload for "${String(eventName)}": ${check.error.message}`);
-      const targets = toArray(rooms);
+      const targets = toArray2(rooms);
       const envelope = {
         eventName,
         sentAt: /* @__PURE__ */ new Date(),
@@ -771,7 +845,7 @@ function createSocketConnections(io, events, opts) {
             type: "emit",
             event: String(eventName),
             rooms: targets,
-            envelope: debug.verbose ? envelope : void 0
+            envelope: opts?.debug?.verbose ? envelope : void 0
           });
           return;
         }
@@ -782,7 +856,7 @@ function createSocketConnections(io, events, opts) {
         type: "emit",
         event: String(eventName),
         rooms: targets,
-        envelope: debug.verbose ? envelope : void 0
+        envelope: opts?.debug?.verbose ? envelope : void 0
       });
     },
     destroy() {