@onebun/core 0.1.0 → 0.1.2

package/src/ws-storage-memory.test.ts

@@ -0,0 +1,246 @@
+/**
+ * In-Memory WebSocket Storage Tests
+ */
+
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+} from 'bun:test';
+
+import type { WsClientData, WsRoom } from './ws.types';
+
+import { InMemoryWsStorage } from './ws-storage-memory';
+
+describe('InMemoryWsStorage', () => {
+  let storage: InMemoryWsStorage;
+
+  beforeEach(async () => {
+    storage = new InMemoryWsStorage();
+    await storage.clear();
+  });
+
+  describe('client operations', () => {
+    const createClient = (id: string): WsClientData => ({
+      id,
+      rooms: [],
+      connectedAt: Date.now(),
+      auth: null,
+      metadata: {},
+    });
+
+    it('should add and retrieve a client', async () => {
+      const client = createClient('client1');
+      await storage.addClient(client);
+
+      const retrieved = await storage.getClient('client1');
+      expect(retrieved).not.toBeNull();
+      expect(retrieved?.id).toBe('client1');
+    });
+
+    it('should return null for non-existent client', async () => {
+      const result = await storage.getClient('non-existent');
+      expect(result).toBeNull();
+    });
+
+    it('should update client data', async () => {
+      const client = createClient('client1');
+      await storage.addClient(client);
+
+      await storage.updateClient('client1', { metadata: { custom: 'value' } });
+
+      const updated = await storage.getClient('client1');
+      expect(updated?.metadata).toEqual({ custom: 'value' });
+    });
+
+    it('should remove a client', async () => {
+      const client = createClient('client1');
+      await storage.addClient(client);
+
+      await storage.removeClient('client1');
+
+      const result = await storage.getClient('client1');
+      expect(result).toBeNull();
+    });
+
+    it('should get all clients', async () => {
+      await storage.addClient(createClient('client1'));
+      await storage.addClient(createClient('client2'));
+
+      const clients = await storage.getAllClients();
+      expect(clients).toHaveLength(2);
+    });
+
+    it('should get client count', async () => {
+      await storage.addClient(createClient('client1'));
+      await storage.addClient(createClient('client2'));
+
+      const count = await storage.getClientCount();
+      expect(count).toBe(2);
+    });
+  });
+
+  describe('room operations', () => {
+    it('should create and retrieve a room', async () => {
+      const room: WsRoom = { name: 'test-room', clientIds: [] };
+      await storage.createRoom(room);
+
+      const retrieved = await storage.getRoom('test-room');
+      expect(retrieved).not.toBeNull();
+      expect(retrieved?.name).toBe('test-room');
+    });
+
+    it('should delete a room', async () => {
+      const room: WsRoom = { name: 'test-room', clientIds: [] };
+      await storage.createRoom(room);
+
+      await storage.deleteRoom('test-room');
+
+      const result = await storage.getRoom('test-room');
+      expect(result).toBeNull();
+    });
+
+    it('should get all rooms', async () => {
+      await storage.createRoom({ name: 'room1', clientIds: [] });
+      await storage.createRoom({ name: 'room2', clientIds: [] });
+
+      const rooms = await storage.getAllRooms();
+      expect(rooms).toHaveLength(2);
+    });
+
+    it('should get rooms by pattern', async () => {
+      await storage.createRoom({ name: 'chat:general', clientIds: [] });
+      await storage.createRoom({ name: 'chat:private', clientIds: [] });
+      await storage.createRoom({ name: 'game:lobby', clientIds: [] });
+
+      const chatRooms = await storage.getRoomsByPattern('chat:*');
+      expect(chatRooms).toHaveLength(2);
+    });
+
+    it('should update room metadata', async () => {
+      await storage.createRoom({ name: 'test-room', clientIds: [] });
+
+      await storage.updateRoomMetadata('test-room', { topic: 'General Discussion' });
+
+      const room = await storage.getRoom('test-room');
+      expect(room?.metadata).toEqual({ topic: 'General Discussion' });
+    });
+  });
+
+  describe('room membership', () => {
+    const createClient = (id: string): WsClientData => ({
+      id,
+      rooms: [],
+      connectedAt: Date.now(),
+      auth: null,
+      metadata: {},
+    });
+
+    it('should add client to room', async () => {
+      await storage.addClient(createClient('client1'));
+      await storage.addClientToRoom('client1', 'test-room');
+
+      const clientIds = await storage.getClientsInRoom('test-room');
+      expect(clientIds).toContain('client1');
+    });
+
+    it('should create room automatically when adding client', async () => {
+      await storage.addClient(createClient('client1'));
+      await storage.addClientToRoom('client1', 'auto-room');
+
+      const room = await storage.getRoom('auto-room');
+      expect(room).not.toBeNull();
+    });
+
+    it('should update client rooms list', async () => {
+      await storage.addClient(createClient('client1'));
+      await storage.addClientToRoom('client1', 'room1');
+      await storage.addClientToRoom('client1', 'room2');
+
+      const client = await storage.getClient('client1');
+      expect(client?.rooms).toContain('room1');
+      expect(client?.rooms).toContain('room2');
+    });
+
+    it('should remove client from room', async () => {
+      await storage.addClient(createClient('client1'));
+      await storage.addClientToRoom('client1', 'test-room');
+
+      await storage.removeClientFromRoom('client1', 'test-room');
+
+      const clientIds = await storage.getClientsInRoom('test-room');
+      expect(clientIds).not.toContain('client1');
+    });
+
+    it('should delete empty room after client leaves', async () => {
+      await storage.addClient(createClient('client1'));
+      await storage.addClientToRoom('client1', 'temp-room');
+
+      await storage.removeClientFromRoom('client1', 'temp-room');
+
+      const room = await storage.getRoom('temp-room');
+      expect(room).toBeNull();
+    });
+
+    it('should get rooms for a client', async () => {
+      await storage.addClient(createClient('client1'));
+      await storage.addClientToRoom('client1', 'room1');
+      await storage.addClientToRoom('client1', 'room2');
+
+      const rooms = await storage.getRoomsForClient('client1');
+      expect(rooms).toHaveLength(2);
+      expect(rooms).toContain('room1');
+      expect(rooms).toContain('room2');
+    });
+
+    it('should remove client from all rooms', async () => {
+      await storage.addClient(createClient('client1'));
+      await storage.addClientToRoom('client1', 'room1');
+      await storage.addClientToRoom('client1', 'room2');
+
+      await storage.removeClientFromAllRooms('client1');
+
+      const rooms = await storage.getRoomsForClient('client1');
+      expect(rooms).toHaveLength(0);
+    });
+
+    it('should remove client from all rooms when client is removed', async () => {
+      await storage.addClient(createClient('client1'));
+      await storage.addClient(createClient('client2'));
+      await storage.addClientToRoom('client1', 'shared-room');
+      await storage.addClientToRoom('client2', 'shared-room');
+
+      await storage.removeClient('client1');
+
+      const clientIds = await storage.getClientsInRoom('shared-room');
+      expect(clientIds).not.toContain('client1');
+      expect(clientIds).toContain('client2');
+    });
+  });
+
+  describe('lifecycle', () => {
+    it('should clear all data', async () => {
+      const client: WsClientData = {
+        id: 'client1',
+        rooms: [],
+        connectedAt: Date.now(),
+        auth: null,
+        metadata: {},
+      };
+      await storage.addClient(client);
+      await storage.createRoom({ name: 'test-room', clientIds: [] });
+
+      await storage.clear();
+
+      expect(await storage.getClientCount()).toBe(0);
+      expect(await storage.getAllRooms()).toHaveLength(0);
+    });
+
+    it('should return stats', () => {
+      const stats = storage.getStats();
+      expect(stats).toHaveProperty('clientCount');
+      expect(stats).toHaveProperty('roomCount');
+    });
+  });
+});

package/src/ws-storage-memory.ts

@@ -0,0 +1,222 @@
+/**
+ * In-Memory WebSocket Storage
+ *
+ * Simple in-memory implementation of WsStorageAdapter.
+ * Suitable for single-instance deployments.
+ */
+
+import type { WsStorageAdapter } from './ws-storage';
+import type { WsClientData, WsRoom } from './ws.types';
+
+import { isPatternMatch } from './ws-pattern-matcher';
+
+/**
+ * In-memory storage for WebSocket clients and rooms
+ */
+export class InMemoryWsStorage implements WsStorageAdapter {
+  private clients = new Map<string, WsClientData>();
+  private rooms = new Map<string, WsRoom>();
+
+  // ============================================================================
+  // Client Operations
+  // ============================================================================
+
+  async addClient(client: WsClientData): Promise<void> {
+    this.clients.set(client.id, { ...client });
+  }
+
+  async removeClient(clientId: string): Promise<void> {
+    // Remove from all rooms first
+    await this.removeClientFromAllRooms(clientId);
+    // Then remove the client
+    this.clients.delete(clientId);
+  }
+
+  async getClient(clientId: string): Promise<WsClientData | null> {
+    const client = this.clients.get(clientId);
+
+    return client ? { ...client } : null;
+  }
+
+  async getAllClients(): Promise<WsClientData[]> {
+    return Array.from(this.clients.values()).map((c) => ({ ...c }));
+  }
+
+  async updateClient(clientId: string, data: Partial<WsClientData>): Promise<void> {
+    const client = this.clients.get(clientId);
+    if (client) {
+      this.clients.set(clientId, { ...client, ...data });
+    }
+  }
+
+  async getClientCount(): Promise<number> {
+    return this.clients.size;
+  }
+
+  // ============================================================================
+  // Room Operations
+  // ============================================================================
+
+  async createRoom(room: WsRoom): Promise<void> {
+    this.rooms.set(room.name, { ...room, clientIds: [...room.clientIds] });
+  }
+
+  async deleteRoom(name: string): Promise<void> {
+    const room = this.rooms.get(name);
+    if (room) {
+      // Remove room from all clients' room lists
+      for (const clientId of room.clientIds) {
+        const client = this.clients.get(clientId);
+        if (client) {
+          client.rooms = client.rooms.filter((r) => r !== name);
+        }
+      }
+      this.rooms.delete(name);
+    }
+  }
+
+  async getRoom(name: string): Promise<WsRoom | null> {
+    const room = this.rooms.get(name);
+
+    return room ? { ...room, clientIds: [...room.clientIds] } : null;
+  }
+
+  async getAllRooms(): Promise<WsRoom[]> {
+    return Array.from(this.rooms.values()).map((r) => ({
+      ...r,
+      clientIds: [...r.clientIds],
+    }));
+  }
+
+  async getRoomsByPattern(pattern: string): Promise<WsRoom[]> {
+    const matchingRooms: WsRoom[] = [];
+
+    for (const [name, room] of this.rooms) {
+      if (isPatternMatch(pattern, name)) {
+        matchingRooms.push({ ...room, clientIds: [...room.clientIds] });
+      }
+    }
+
+    return matchingRooms;
+  }
+
+  async updateRoomMetadata(name: string, metadata: Record<string, unknown>): Promise<void> {
+    const room = this.rooms.get(name);
+    if (room) {
+      room.metadata = { ...room.metadata, ...metadata };
+    }
+  }
+
+  // ============================================================================
+  // Room Membership Operations
+  // ============================================================================
+
+  async addClientToRoom(clientId: string, roomName: string): Promise<void> {
+    // Get or create room
+    let room = this.rooms.get(roomName);
+    if (!room) {
+      room = { name: roomName, clientIds: [] };
+      this.rooms.set(roomName, room);
+    }
+
+    // Add client to room if not already there
+    if (!room.clientIds.includes(clientId)) {
+      room.clientIds.push(clientId);
+    }
+
+    // Update client's room list
+    const client = this.clients.get(clientId);
+    if (client && !client.rooms.includes(roomName)) {
+      client.rooms.push(roomName);
+    }
+  }
+
+  async removeClientFromRoom(clientId: string, roomName: string): Promise<void> {
+    // Remove from room
+    const room = this.rooms.get(roomName);
+    if (room) {
+      room.clientIds = room.clientIds.filter((id) => id !== clientId);
+
+      // Delete room if empty
+      if (room.clientIds.length === 0) {
+        this.rooms.delete(roomName);
+      }
+    }
+
+    // Update client's room list
+    const client = this.clients.get(clientId);
+    if (client) {
+      client.rooms = client.rooms.filter((r) => r !== roomName);
+    }
+  }
+
+  async getClientsInRoom(roomName: string): Promise<string[]> {
+    const room = this.rooms.get(roomName);
+
+    return room ? [...room.clientIds] : [];
+  }
+
+  async getRoomsForClient(clientId: string): Promise<string[]> {
+    const client = this.clients.get(clientId);
+
+    return client ? [...client.rooms] : [];
+  }
+
+  async removeClientFromAllRooms(clientId: string): Promise<void> {
+    const client = this.clients.get(clientId);
+    if (!client) {
+      return;
+    }
+
+    // Remove from all rooms
+    for (const roomName of client.rooms) {
+      const room = this.rooms.get(roomName);
+      if (room) {
+        room.clientIds = room.clientIds.filter((id) => id !== clientId);
+
+        // Delete room if empty
+        if (room.clientIds.length === 0) {
+          this.rooms.delete(roomName);
+        }
+      }
+    }
+
+    // Clear client's room list
+    client.rooms = [];
+  }
+
+  // ============================================================================
+  // Lifecycle Operations
+  // ============================================================================
+
+  async clear(): Promise<void> {
+    this.clients.clear();
+    this.rooms.clear();
+  }
+
+  async close(): Promise<void> {
+    // No-op for in-memory storage
+    await this.clear();
+  }
+
+  // ============================================================================
+  // Debug/Stats Methods
+  // ============================================================================
+
+  /**
+   * Get storage statistics (for debugging)
+   */
+  getStats(): { clientCount: number; roomCount: number } {
+    return {
+      clientCount: this.clients.size,
+      roomCount: this.rooms.size,
+    };
+  }
+}
+
+/**
+ * Create a new in-memory WebSocket storage instance
+ */
+export function createInMemoryWsStorage(): WsStorageAdapter {
+  return new InMemoryWsStorage();
+}