sonamu 0.11.16 → 0.12.0

package/src/stream/ws-frame.ts

@@ -0,0 +1,39 @@
+import { type z } from "zod";
+
+export type WebSocketFrameEncoding =
+  | { status: "encoded"; frame: string }
+  | { status: "unknownEvent" }
+  | { status: "invalidPayload" };
+
+/**
+ * outEvents 스키마로 payload를 검증하고 `{event, data}` frame 문자열로 인코딩한다.
+ * 같은 스키마로 인코딩한 frame은 로컬·원격 수신자 모두에게 같은 바이트로 전달된다.
+ */
+export function encodeWebSocketFrame<Data>(
+  outEvents: z.ZodObject,
+  event: string,
+  data: Data,
+): WebSocketFrameEncoding {
+  const schema = getEventSchema(outEvents, event);
+  if (!schema) {
+    return { status: "unknownEvent" };
+  }
+
+  const parsed = schema.safeParse(data);
+  if (!parsed.success) {
+    return { status: "invalidPayload" };
+  }
+
+  return {
+    status: "encoded",
+    frame: JSON.stringify({
+      event,
+      data: parsed.data,
+    }),
+  };
+}
+
+function getEventSchema(outEvents: z.ZodObject, event: string): z.ZodType | undefined {
+  const eventSchemas: Record<string, z.ZodType> = outEvents["shape"];
+  return Object.hasOwn(eventSchemas, event) ? eventSchemas[event] : undefined;
+}

package/src/stream/ws-local-connection-store.ts

@@ -1,14 +1,14 @@
 import { isFunctionValue } from "../utils/runtime-value";
-import { type ManagedWebSocketConnection } from "./ws-core";
+import { type WebSocketFrameConnection } from "./ws-core";
 import {
   type WebSocketTelemetryConnectionSnapshot,
   type TelemetryInspectableConnection,
 } from "./ws-telemetry";
 
 export class WebSocketLocalConnectionStore {
-  private readonly connections = new Map<string, ManagedWebSocketConnection>();
+  private readonly connections = new Map<string, WebSocketFrameConnection>();
 
-  register(connection: ManagedWebSocketConnection): void {
+  register(connection: WebSocketFrameConnection): void {
     this.connections.set(connection.id, connection);
   }
 
@@ -16,12 +16,12 @@ export class WebSocketLocalConnectionStore {
     this.connections.delete(connectionId);
   }
 
-  getConnection(connectionId: string): ManagedWebSocketConnection | undefined {
+  getConnection(connectionId: string): WebSocketFrameConnection | undefined {
     return this.connections.get(connectionId);
   }
 
-  getConnections(connectionIds: string[]): ManagedWebSocketConnection[] {
-    const targets: ManagedWebSocketConnection[] = [];
+  getConnections(connectionIds: string[]): WebSocketFrameConnection[] {
+    const targets: WebSocketFrameConnection[] = [];
     const seen = new Set<string>();
 
     for (const connectionId of connectionIds) {
@@ -63,14 +63,15 @@ export class WebSocketLocalConnectionStore {
   }
 
   closeAll(code?: number, reason?: string): void {
-    for (const connection of this.connections.values()) {
+    // close 도중 unregister가 Map을 바꾸므로 복사본을 순회한다
+    for (const connection of Array.from(this.connections.values())) {
       connection.close(code, reason);
     }
   }
 }
 
 function isTelemetryInspectableConnection(
-  connection: ManagedWebSocketConnection,
-): connection is ManagedWebSocketConnection & TelemetryInspectableConnection {
+  connection: WebSocketFrameConnection,
+): connection is WebSocketFrameConnection & TelemetryInspectableConnection {
   return "getTelemetrySnapshot" in connection && isFunctionValue(connection.getTelemetrySnapshot);
 }

package/src/stream/ws-presence-index.ts

@@ -0,0 +1,273 @@
+import { type WebSocketAudience } from "./ws-audience";
+import { type WebSocketRegistryStats, type WebSocketRoomId, type WebSocketUserId } from "./ws-core";
+import {
+  type WebSocketPresenceRegistration,
+  type WebSocketSessionPresence,
+} from "./ws-presence-store";
+
+type PresenceRecord = WebSocketSessionPresence;
+// namespace → 바인딩 id → 세션 ID 집합. userId는 Map 키로 그대로 써서 1과 "1"을 구분한다
+type BindingIndex<Id> = Map<string, Map<Id, Set<string>>>;
+
+/**
+ * 동기 presence 인덱스. registry의 노드 로컬 메모리와 in-memory store가 함께 쓴다.
+ * 외부로 내보내는 presence는 항상 복사본이다.
+ */
+export class WebSocketPresenceIndex {
+  private readonly sessions = new Map<string, PresenceRecord>();
+  private readonly rooms: BindingIndex<WebSocketRoomId> = new Map();
+  private readonly users: BindingIndex<WebSocketUserId> = new Map();
+
+  has(sessionId: string): boolean {
+    return this.sessions.has(sessionId);
+  }
+
+  register(input: WebSocketPresenceRegistration): void {
+    // 같은 세션을 다시 등록하면 이전 바인딩을 먼저 정리해 고아 바인딩이 남지 않게 한다
+    this.unregister(input.sessionId);
+    this.sessions.set(input.sessionId, {
+      sessionId: input.sessionId,
+      nodeId: input.nodeId,
+      namespace: input.namespace,
+      active: input.active,
+      rooms: new Set(),
+      connectedAt: new Date(input.connectedAt.getTime()),
+      lastSeenAt: new Date(input.connectedAt.getTime()),
+    });
+  }
+
+  activate(sessionId: string): void {
+    const record = this.sessions.get(sessionId);
+    if (record) {
+      record.active = true;
+    }
+  }
+
+  unregister(sessionId: string): WebSocketSessionPresence | undefined {
+    const record = this.sessions.get(sessionId);
+    if (!record) {
+      return undefined;
+    }
+
+    if (record.userId !== undefined) {
+      removeBinding(this.users, record.namespace, record.userId, sessionId);
+    }
+    for (const roomId of record.rooms) {
+      removeBinding(this.rooms, record.namespace, roomId, sessionId);
+    }
+    this.sessions.delete(sessionId);
+    return copyPresence(record);
+  }
+
+  touch(sessionId: string): void {
+    const record = this.sessions.get(sessionId);
+    if (record) {
+      record.lastSeenAt = new Date();
+    }
+  }
+
+  setUserId(sessionId: string, userId: WebSocketUserId): void {
+    const record = this.sessions.get(sessionId);
+    if (!record) {
+      return;
+    }
+
+    if (record.userId !== undefined) {
+      removeBinding(this.users, record.namespace, record.userId, sessionId);
+    }
+    record.userId = userId;
+    addBinding(this.users, record.namespace, userId, sessionId);
+  }
+
+  clearUserId(sessionId: string): void {
+    const record = this.sessions.get(sessionId);
+    if (!record || record.userId === undefined) {
+      return;
+    }
+
+    removeBinding(this.users, record.namespace, record.userId, sessionId);
+    delete record.userId;
+  }
+
+  join(sessionId: string, roomId: WebSocketRoomId): void {
+    const record = this.sessions.get(sessionId);
+    if (!record) {
+      return;
+    }
+
+    record.rooms.add(roomId);
+    addBinding(this.rooms, record.namespace, roomId, sessionId);
+  }
+
+  leave(sessionId: string, roomId: WebSocketRoomId): void {
+    const record = this.sessions.get(sessionId);
+    if (!record) {
+      return;
+    }
+
+    record.rooms.delete(roomId);
+    removeBinding(this.rooms, record.namespace, roomId, sessionId);
+  }
+
+  getConnection(sessionId: string): WebSocketSessionPresence | undefined {
+    const record = this.sessions.get(sessionId);
+    return record ? copyPresence(record) : undefined;
+  }
+
+  getConnectionCount(namespace?: string): number {
+    let count = 0;
+    for (const record of this.sessions.values()) {
+      if (record.active && matchesNamespace(record, namespace)) {
+        count += 1;
+      }
+    }
+    return count;
+  }
+
+  getRoomMembers(roomId: WebSocketRoomId, namespace?: string): WebSocketSessionPresence[] {
+    return this.getBoundSessions(this.rooms, roomId, namespace).map(copyPresence);
+  }
+
+  getRoomMemberCount(roomId: WebSocketRoomId, namespace?: string): number {
+    return this.getBoundSessions(this.rooms, roomId, namespace).length;
+  }
+
+  getStats(): WebSocketRegistryStats {
+    const byNamespace: Record<string, number> = {};
+    let totalConnections = 0;
+
+    for (const record of this.sessions.values()) {
+      if (!record.active) {
+        continue;
+      }
+      byNamespace[record.namespace] = (byNamespace[record.namespace] ?? 0) + 1;
+      totalConnections += 1;
+    }
+
+    let totalRooms = 0;
+    for (const bindings of this.rooms.values()) {
+      totalRooms += bindings.size;
+    }
+
+    return { totalConnections, totalRooms, byNamespace };
+  }
+
+  /**
+   * audience에 해당하는 활성 세션을 중복 없이 반환한다. 반환값은 내부 상태를 노출하지 않도록 ID와 노드 ID만 담는다.
+   */
+  queryAudience(audience: WebSocketAudience): Array<{ sessionId: string; nodeId: string }> {
+    const seen = new Set<string>();
+    const results: Array<{ sessionId: string; nodeId: string }> = [];
+
+    for (const record of this.collectAudience(audience)) {
+      if (seen.has(record.sessionId)) {
+        continue;
+      }
+      seen.add(record.sessionId);
+      results.push({ sessionId: record.sessionId, nodeId: record.nodeId });
+    }
+
+    return results;
+  }
+
+  private collectAudience(audience: WebSocketAudience): PresenceRecord[] {
+    switch (audience.type) {
+      case "all":
+        return [...this.sessions.values()].filter(
+          (record) => record.active && matchesNamespace(record, audience.namespace),
+        );
+      case "room":
+        return this.getBoundSessions(this.rooms, audience.roomId, audience.namespace);
+      case "user":
+        return this.getBoundSessions(this.users, audience.userId, audience.namespace);
+      case "connections": {
+        const records: PresenceRecord[] = [];
+        for (const sessionId of audience.connectionIds) {
+          const record = this.sessions.get(sessionId);
+          if (record?.active && matchesNamespace(record, audience.namespace)) {
+            records.push(record);
+          }
+        }
+        return records;
+      }
+      case "union":
+        return audience.audiences.flatMap((item) => this.collectAudience(item));
+    }
+  }
+
+  private getBoundSessions<Id>(
+    index: BindingIndex<Id>,
+    id: Id,
+    namespace?: string,
+  ): PresenceRecord[] {
+    // namespace가 없으면(빈 문자열 포함) 모든 namespace의 바인딩을 본다
+    const namespaces = namespace ? [index.get(namespace)] : [...index.values()];
+    const seen = new Set<string>();
+    const records: PresenceRecord[] = [];
+
+    for (const bindings of namespaces) {
+      for (const sessionId of bindings?.get(id) ?? []) {
+        if (seen.has(sessionId)) {
+          continue;
+        }
+        seen.add(sessionId);
+
+        const record = this.sessions.get(sessionId);
+        if (record?.active) {
+          records.push(record);
+        }
+      }
+    }
+
+    return records;
+  }
+}
+
+function matchesNamespace(record: PresenceRecord, namespace: string | undefined): boolean {
+  return namespace === undefined || namespace === "" || record.namespace === namespace;
+}
+
+function copyPresence(record: PresenceRecord): WebSocketSessionPresence {
+  const copy: WebSocketSessionPresence = {
+    sessionId: record.sessionId,
+    nodeId: record.nodeId,
+    namespace: record.namespace,
+    active: record.active,
+    rooms: new Set(record.rooms),
+    connectedAt: new Date(record.connectedAt.getTime()),
+    lastSeenAt: new Date(record.lastSeenAt.getTime()),
+  };
+  if (record.userId !== undefined) {
+    copy.userId = record.userId;
+  }
+  return copy;
+}
+
+function addBinding<Id>(index: BindingIndex<Id>, namespace: string, id: Id, sessionId: string) {
+  const bindings = index.get(namespace) ?? new Map<Id, Set<string>>();
+  const members = bindings.get(id) ?? new Set<string>();
+  members.add(sessionId);
+  bindings.set(id, members);
+  index.set(namespace, bindings);
+}
+
+function removeBinding<Id>(
+  index: BindingIndex<Id>,
+  namespace: string,
+  id: Id,
+  sessionId: string,
+): void {
+  const bindings = index.get(namespace);
+  const members = bindings?.get(id);
+  if (!bindings || !members) {
+    return;
+  }
+
+  members.delete(sessionId);
+  if (members.size === 0) {
+    bindings.delete(id);
+  }
+  if (bindings.size === 0) {
+    index.delete(namespace);
+  }
+}