alepha 0.20.6 → 0.20.8

package/src/websocket/__tests__/$websocket-new.spec.ts

@@ -1,195 +0,0 @@
-import { Alepha, t } from "alepha";
-import { NodeHttpServerProvider } from "alepha/server";
-import { test } from "vitest";
-import WebSocket from "ws";
-import { AlephaWebSocket } from "../index.ts";
-import { $channel } from "../primitives/$channel.ts";
-import { $websocket } from "../primitives/$websocket.ts";
-
-test("$websocket with channel-based architecture", async ({ expect }) => {
-  const alepha = Alepha.create().with(AlephaWebSocket);
-
-  const messages: any[] = [];
-
-  class ChatController {
-    // Define channel inside the class
-    chatChannel = $channel({
-      path: "/ws/chat",
-      schema: {
-        // Server → Client messages
-        in: t.union([
-          t.object({
-            type: t.const("append"),
-            content: t.text(),
-            username: t.text(),
-          }),
-          t.object({
-            type: t.const("system"),
-            message: t.text(),
-          }),
-        ]),
-        // Client → Server messages
-        out: t.object({
-          content: t.text(),
-        }),
-      },
-    });
-
-    chat = $websocket({
-      channel: this.chatChannel,
-      handler: async ({ connectionId, roomId, message, reply }) => {
-        // Broadcast to all in room except sender
-        await reply({
-          message: {
-            type: "append",
-            content: message.content,
-            username: connectionId,
-          },
-          exceptSelf: true,
-        });
-      },
-    });
-  }
-
-  const controller = alepha.inject(ChatController);
-  await alepha.start();
-
-  const httpServer = alepha.inject(NodeHttpServerProvider);
-  const hostname = httpServer.hostname.replace("http://", "ws://");
-
-  // Connect two clients to the same room
-  const ws1 = new WebSocket(`${hostname}/ws/chat?roomId=room-1`);
-  const ws2 = new WebSocket(`${hostname}/ws/chat?roomId=room-1`);
-
-  await Promise.all([
-    new Promise((resolve) => ws1.on("open", resolve)),
-    new Promise((resolve) => ws2.on("open", resolve)),
-  ]);
-
-  // Listen for messages on ws2
-  ws2.on("message", (data) => {
-    const message = JSON.parse(data.toString());
-    messages.push(message);
-  });
-
-  // Wait a bit for connections to be established
-  await new Promise((resolve) => setTimeout(resolve, 100));
-
-  // Send message from ws1
-  ws1.send(
-    JSON.stringify({
-      roomId: "room-1",
-      message: {
-        content: "Hello from client 1!",
-      },
-    }),
-  );
-
-  // Wait for message to be received
-  await new Promise((resolve) => setTimeout(resolve, 200));
-
-  // ws2 should receive the message, but not ws1 (exceptSelf)
-  expect(messages.length).toBe(1);
-  expect(messages[0].type).toBe("append");
-  expect(messages[0].content).toBe("Hello from client 1!");
-  expect(messages[0].username).toContain("ws-");
-
-  // Test emit API from server
-  await controller.chat.emit({
-    roomId: "room-1",
-    message: {
-      type: "system",
-      message: "Server announcement",
-    },
-  });
-
-  await new Promise((resolve) => setTimeout(resolve, 200));
-
-  // Both clients should receive the system message
-  expect(messages.length).toBe(2);
-  expect(messages[1].type).toBe("system");
-  expect(messages[1].message).toBe("Server announcement");
-
-  ws1.close();
-  ws2.close();
-  await alepha.stop();
-});
-
-test("$websocket room isolation", async ({ expect }) => {
-  const alepha = Alepha.create().with(AlephaWebSocket);
-
-  class ChatController {
-    chatChannel = $channel({
-      path: "/ws/chat",
-      schema: {
-        in: t.object({
-          type: t.const("message"),
-          content: t.text(),
-        }),
-        out: t.object({
-          content: t.text(),
-        }),
-      },
-    });
-
-    chat = $websocket({
-      channel: this.chatChannel,
-      handler: async ({ roomId, message, reply }) => {
-        await reply({
-          message: {
-            type: "message",
-            content: message.content,
-          },
-        });
-      },
-    });
-  }
-
-  const controller = alepha.inject(ChatController);
-  await alepha.start();
-
-  const httpServer = alepha.inject(NodeHttpServerProvider);
-  const hostname = httpServer.hostname.replace("http://", "ws://");
-
-  // Connect clients to different rooms
-  const room1Client = new WebSocket(`${hostname}/ws/chat?roomId=room-1`);
-  const room2Client = new WebSocket(`${hostname}/ws/chat?roomId=room-2`);
-
-  await Promise.all([
-    new Promise((resolve) => room1Client.on("open", resolve)),
-    new Promise((resolve) => room2Client.on("open", resolve)),
-  ]);
-
-  const room1Messages: any[] = [];
-  const room2Messages: any[] = [];
-
-  room1Client.on("message", (data) => {
-    room1Messages.push(JSON.parse(data.toString()));
-  });
-
-  room2Client.on("message", (data) => {
-    room2Messages.push(JSON.parse(data.toString()));
-  });
-
-  await new Promise((resolve) => setTimeout(resolve, 100));
-
-  // Send to room-1 only
-  await controller.chat.emit({
-    roomId: "room-1",
-    message: {
-      type: "message",
-      content: "Message for room 1",
-    },
-  });
-
-  await new Promise((resolve) => setTimeout(resolve, 200));
-
-  // Only room1Client should receive the message
-  expect(room1Messages.length).toBe(1);
-  expect(room1Messages[0].content).toBe("Message for room 1");
-  expect(room2Messages.length).toBe(0);
-
-  room1Client.close();
-  room2Client.close();
-  await alepha.stop();
-});

package/src/websocket/__tests__/RoomManager.spec.ts

@@ -1,146 +0,0 @@
-import { Alepha } from "alepha";
-import { describe, expect, it } from "vitest";
-import { AlephaWebSocket } from "../index.ts";
-import { RoomManager } from "../services/RoomManager.ts";
-
-describe("RoomManager", () => {
-  const createRoomManager = () => {
-    const alepha = Alepha.create().with(AlephaWebSocket);
-    return alepha.inject(RoomManager);
-  };
-
-  describe("joinRoom / joinRooms", () => {
-    it("should add connection to a room", () => {
-      const rm = createRoomManager();
-      rm.joinRoom("conn-1", "room-a");
-
-      expect(rm.getRoomConnections("room-a")).toEqual(["conn-1"]);
-      expect(rm.getConnectionRooms("conn-1")).toEqual(["room-a"]);
-    });
-
-    it("should add connection to multiple rooms", () => {
-      const rm = createRoomManager();
-      rm.joinRooms("conn-1", ["room-a", "room-b", "room-c"]);
-
-      expect(rm.getConnectionRooms("conn-1")).toEqual(
-        expect.arrayContaining(["room-a", "room-b", "room-c"]),
-      );
-      expect(rm.getRoomConnections("room-a")).toEqual(["conn-1"]);
-      expect(rm.getRoomConnections("room-b")).toEqual(["conn-1"]);
-    });
-
-    it("should allow multiple connections in the same room", () => {
-      const rm = createRoomManager();
-      rm.joinRoom("conn-1", "room-a");
-      rm.joinRoom("conn-2", "room-a");
-      rm.joinRoom("conn-3", "room-a");
-
-      expect(rm.getRoomConnections("room-a")).toHaveLength(3);
-    });
-  });
-
-  describe("leaveRoom", () => {
-    it("should remove connection from room", () => {
-      const rm = createRoomManager();
-      rm.joinRoom("conn-1", "room-a");
-      rm.leaveRoom("conn-1", "room-a");
-
-      expect(rm.getRoomConnections("room-a")).toEqual([]);
-      expect(rm.getConnectionRooms("conn-1")).toEqual([]);
-    });
-
-    it("should clean up empty rooms", () => {
-      const rm = createRoomManager();
-      rm.joinRoom("conn-1", "room-a");
-      rm.leaveRoom("conn-1", "room-a");
-
-      expect(rm.getAllRooms()).toEqual([]);
-    });
-
-    it("should not affect other connections in the same room", () => {
-      const rm = createRoomManager();
-      rm.joinRoom("conn-1", "room-a");
-      rm.joinRoom("conn-2", "room-a");
-      rm.leaveRoom("conn-1", "room-a");
-
-      expect(rm.getRoomConnections("room-a")).toEqual(["conn-2"]);
-    });
-
-    it("should handle leaving a room the connection is not in", () => {
-      const rm = createRoomManager();
-      rm.leaveRoom("conn-1", "room-a");
-
-      expect(rm.getAllRooms()).toEqual([]);
-    });
-  });
-
-  describe("leaveAllRooms", () => {
-    it("should remove connection from all rooms", () => {
-      const rm = createRoomManager();
-      rm.joinRooms("conn-1", ["room-a", "room-b", "room-c"]);
-      rm.leaveAllRooms("conn-1");
-
-      expect(rm.getConnectionRooms("conn-1")).toEqual([]);
-      expect(rm.getAllRooms()).toEqual([]);
-    });
-
-    it("should not affect other connections", () => {
-      const rm = createRoomManager();
-      rm.joinRoom("conn-1", "room-a");
-      rm.joinRoom("conn-2", "room-a");
-      rm.joinRoom("conn-1", "room-b");
-      rm.leaveAllRooms("conn-1");
-
-      expect(rm.getRoomConnections("room-a")).toEqual(["conn-2"]);
-      expect(rm.getConnectionRooms("conn-2")).toEqual(["room-a"]);
-    });
-
-    it("should be a no-op for unknown connection", () => {
-      const rm = createRoomManager();
-      rm.leaveAllRooms("unknown");
-      expect(rm.getTotalConnections()).toBe(0);
-    });
-  });
-
-  describe("isInRoom", () => {
-    it("should return true when connection is in room", () => {
-      const rm = createRoomManager();
-      rm.joinRoom("conn-1", "room-a");
-      expect(rm.isInRoom("conn-1", "room-a")).toBe(true);
-    });
-
-    it("should return false when connection is not in room", () => {
-      const rm = createRoomManager();
-      rm.joinRoom("conn-1", "room-a");
-      expect(rm.isInRoom("conn-1", "room-b")).toBe(false);
-    });
-
-    it("should return false for unknown connection", () => {
-      const rm = createRoomManager();
-      expect(rm.isInRoom("unknown", "room-a")).toBe(false);
-    });
-  });
-
-  describe("getStats", () => {
-    it("should return correct statistics", () => {
-      const rm = createRoomManager();
-      rm.joinRooms("conn-1", ["room-a", "room-b"]);
-      rm.joinRoom("conn-2", "room-a");
-      rm.joinRoom("conn-3", "room-b");
-
-      const stats = rm.getStats();
-      expect(stats.totalRooms).toBe(2);
-      expect(stats.totalConnections).toBe(3);
-      expect(stats.roomSizes.get("room-a")).toBe(2);
-      expect(stats.roomSizes.get("room-b")).toBe(2);
-    });
-
-    it("should return empty stats when no connections", () => {
-      const rm = createRoomManager();
-      const stats = rm.getStats();
-      expect(stats.totalRooms).toBe(0);
-      expect(stats.totalConnections).toBe(0);
-      expect(stats.roomSizes.size).toBe(0);
-    });
-  });
-});