chatly-sdk 1.0.0 → 2.0.0

package/test/sdk.test.ts

@@ -0,0 +1,276 @@
+import { ChatSDK } from '../src/index';
+import { InMemoryUserStore } from '../src/stores/memory/userStore';
+import { InMemoryMessageStore } from '../src/stores/memory/messageStore';
+import { InMemoryGroupStore } from '../src/stores/memory/groupStore';
+import { EVENTS } from '../src/constants';
+import { ValidationError, SessionError } from '../src/utils/errors';
+
+describe('ChatSDK', () => {
+  let sdk: ChatSDK;
+
+  beforeEach(() => {
+    sdk = new ChatSDK({
+      userStore: new InMemoryUserStore(),
+      messageStore: new InMemoryMessageStore(),
+      groupStore: new InMemoryGroupStore(),
+    });
+  });
+
+  describe('User Management', () => {
+    it('should create a user with valid username', async () => {
+      const user = await sdk.createUser('alice');
+      
+      expect(user).toHaveProperty('id');
+      expect(user).toHaveProperty('username', 'alice');
+      expect(user).toHaveProperty('publicKey');
+      expect(user).toHaveProperty('privateKey');
+      expect(user).toHaveProperty('identityKey');
+    });
+
+    it('should reject invalid usernames', async () => {
+      await expect(sdk.createUser('')).rejects.toThrow(ValidationError);
+      await expect(sdk.createUser('ab')).rejects.toThrow(ValidationError); // Too short
+      await expect(sdk.createUser('a'.repeat(21))).rejects.toThrow(ValidationError); // Too long
+      await expect(sdk.createUser('user@name')).rejects.toThrow(ValidationError); // Invalid chars
+    });
+
+    it('should emit user:created event', async () => {
+      const handler = jest.fn();
+      sdk.on(EVENTS.USER_CREATED, handler);
+      
+      const user = await sdk.createUser('bob');
+      
+      expect(handler).toHaveBeenCalledWith(user);
+    });
+
+    it('should list all users', async () => {
+      await sdk.createUser('alice');
+      await sdk.createUser('bob');
+      
+      const users = await sdk.listUsers();
+      
+      expect(users).toHaveLength(2);
+      expect(users.map(u => u.username)).toContain('alice');
+      expect(users.map(u => u.username)).toContain('bob');
+    });
+
+    it('should get user by ID', async () => {
+      const alice = await sdk.createUser('alice');
+      
+      const retrieved = await sdk.getUserById(alice.id);
+      
+      expect(retrieved).toBeDefined();
+      expect(retrieved?.id).toBe(alice.id);
+      expect(retrieved?.username).toBe('alice');
+    });
+  });
+
+  describe('Session Management', () => {
+    it('should create a 1:1 chat session', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      
+      const session = await sdk.startSession(alice, bob);
+      
+      expect(session).toBeDefined();
+      expect(session.id).toBeDefined();
+    });
+
+    it('should emit session:created event', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      const handler = jest.fn();
+      sdk.on(EVENTS.SESSION_CREATED, handler);
+      
+      const session = await sdk.startSession(alice, bob);
+      
+      expect(handler).toHaveBeenCalledWith(session);
+    });
+
+    it('should create consistent session IDs regardless of user order', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      
+      const session1 = await sdk.startSession(alice, bob);
+      const session2 = await sdk.startSession(bob, alice);
+      
+      expect(session1.id).toBe(session2.id);
+    });
+  });
+
+  describe('Group Management', () => {
+    it('should create a group with valid members', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      
+      const group = await sdk.createGroup('Team Chat', [alice, bob]);
+      
+      expect(group).toBeDefined();
+      expect(group.group.name).toBe('Team Chat');
+      expect(group.group.members).toHaveLength(2);
+    });
+
+    it('should reject groups with less than 2 members', async () => {
+      const alice = await sdk.createUser('alice');
+      
+      await expect(
+        sdk.createGroup('Solo Chat', [alice])
+      ).rejects.toThrow(ValidationError);
+    });
+
+    it('should reject invalid group names', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      
+      await expect(
+        sdk.createGroup('', [alice, bob])
+      ).rejects.toThrow(ValidationError);
+      
+      await expect(
+        sdk.createGroup('   ', [alice, bob])
+      ).rejects.toThrow(ValidationError);
+    });
+
+    it('should emit group:created event', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      const handler = jest.fn();
+      sdk.on(EVENTS.GROUP_CREATED, handler);
+      
+      const group = await sdk.createGroup('Team', [alice, bob]);
+      
+      expect(handler).toHaveBeenCalledWith(group);
+    });
+
+    it('should list all groups', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      
+      await sdk.createGroup('Group 1', [alice, bob]);
+      await sdk.createGroup('Group 2', [alice, bob]);
+      
+      const groups = await sdk.listGroups();
+      
+      expect(groups).toHaveLength(2);
+    });
+
+    it('should load an existing group', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      const created = await sdk.createGroup('Team', [alice, bob]);
+      
+      const loaded = await sdk.loadGroup(created.group.id);
+      
+      expect(loaded.group.id).toBe(created.group.id);
+      expect(loaded.group.name).toBe('Team');
+    });
+  });
+
+  describe('Messaging', () => {
+    it('should send and decrypt a 1:1 message', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      const session = await sdk.startSession(alice, bob);
+      
+      sdk.setCurrentUser(alice);
+      const message = await sdk.sendMessage(session, 'Hello Bob!');
+      
+      expect(message).toBeDefined();
+      expect(message.senderId).toBe(alice.id);
+      expect(message.receiverId).toBe(bob.id);
+      
+      const decrypted = await sdk.decryptMessage(message, bob);
+      expect(decrypted).toBe('Hello Bob!');
+    });
+
+    it('should reject messages without current user', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      const session = await sdk.startSession(alice, bob);
+      
+      await expect(
+        sdk.sendMessage(session, 'Hello')
+      ).rejects.toThrow(SessionError);
+    });
+
+    it('should reject invalid messages', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      const session = await sdk.startSession(alice, bob);
+      
+      sdk.setCurrentUser(alice);
+      
+      await expect(
+        sdk.sendMessage(session, '')
+      ).rejects.toThrow(ValidationError);
+      
+      await expect(
+        sdk.sendMessage(session, 'A'.repeat(10001))
+      ).rejects.toThrow(ValidationError);
+    });
+
+    it('should send and decrypt a group message', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      const charlie = await sdk.createUser('charlie');
+      const group = await sdk.createGroup('Team', [alice, bob, charlie]);
+      
+      sdk.setCurrentUser(alice);
+      const message = await sdk.sendMessage(group, 'Hello team!');
+      
+      expect(message.groupId).toBe(group.group.id);
+      
+      const decryptedByBob = await sdk.decryptMessage(message, bob);
+      const decryptedByCharlie = await sdk.decryptMessage(message, charlie);
+      
+      expect(decryptedByBob).toBe('Hello team!');
+      expect(decryptedByCharlie).toBe('Hello team!');
+    });
+
+    it('should get messages for a user', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      const session = await sdk.startSession(alice, bob);
+      
+      sdk.setCurrentUser(alice);
+      await sdk.sendMessage(session, 'Message 1');
+      await sdk.sendMessage(session, 'Message 2');
+      
+      const messages = await sdk.getMessagesForUser(bob.id);
+      
+      expect(messages).toHaveLength(2);
+    });
+
+    it('should get messages for a group', async () => {
+      const alice = await sdk.createUser('alice');
+      const bob = await sdk.createUser('bob');
+      const group = await sdk.createGroup('Team', [alice, bob]);
+      
+      sdk.setCurrentUser(alice);
+      await sdk.sendMessage(group, 'Message 1');
+      await sdk.sendMessage(group, 'Message 2');
+      
+      const messages = await sdk.getMessagesForGroup(group.group.id);
+      
+      expect(messages).toHaveLength(2);
+    });
+  });
+
+  describe('Connection State', () => {
+    it('should return disconnected when no transport', () => {
+      expect(sdk.isConnected()).toBe(false);
+      expect(sdk.getConnectionState()).toBe('disconnected');
+    });
+  });
+
+  describe('Queue Status', () => {
+    it('should return queue status', () => {
+      const status = sdk.getQueueStatus();
+      
+      expect(status).toHaveProperty('size');
+      expect(status).toHaveProperty('pending');
+      expect(status).toHaveProperty('retryable');
+      expect(status.size).toBe(0);
+    });
+  });
+});

package/test/validation.test.ts

@@ -0,0 +1,64 @@
+import { validateUsername, validateMessage, validateGroupName, validateGroupMembers } from '../src/utils/validation';
+import { ValidationError } from '../src/utils/errors';
+
+describe('Validation Utilities', () => {
+  describe('validateUsername', () => {
+    it('should accept valid usernames', () => {
+      expect(() => validateUsername('alice')).not.toThrow();
+      expect(() => validateUsername('bob123')).not.toThrow();
+      expect(() => validateUsername('user_name')).not.toThrow();
+      expect(() => validateUsername('user-name')).not.toThrow();
+      expect(() => validateUsername('ABC')).not.toThrow();
+    });
+
+    it('should reject invalid usernames', () => {
+      expect(() => validateUsername('')).toThrow(ValidationError);
+      expect(() => validateUsername('ab')).toThrow(ValidationError); // Too short
+      expect(() => validateUsername('a'.repeat(21))).toThrow(ValidationError); // Too long
+      expect(() => validateUsername('user@name')).toThrow(ValidationError); // Invalid char
+      expect(() => validateUsername('user name')).toThrow(ValidationError); // Space
+      expect(() => validateUsername('user.name')).toThrow(ValidationError); // Dot
+    });
+  });
+
+  describe('validateMessage', () => {
+    it('should accept valid messages', () => {
+      expect(() => validateMessage('Hello')).not.toThrow();
+      expect(() => validateMessage('A'.repeat(10000))).not.toThrow();
+      expect(() => validateMessage('Message with emojis 👋🌍')).not.toThrow();
+    });
+
+    it('should reject invalid messages', () => {
+      expect(() => validateMessage('')).toThrow(ValidationError);
+      expect(() => validateMessage('A'.repeat(10001))).toThrow(ValidationError); // Too long
+    });
+  });
+
+  describe('validateGroupName', () => {
+    it('should accept valid group names', () => {
+      expect(() => validateGroupName('Team Chat')).not.toThrow();
+      expect(() => validateGroupName('Project 2024')).not.toThrow();
+      expect(() => validateGroupName('A'.repeat(100))).not.toThrow();
+    });
+
+    it('should reject invalid group names', () => {
+      expect(() => validateGroupName('')).toThrow(ValidationError);
+      expect(() => validateGroupName('   ')).toThrow(ValidationError);
+      expect(() => validateGroupName('A'.repeat(101))).toThrow(ValidationError); // Too long
+    });
+  });
+
+  describe('validateGroupMembers', () => {
+    it('should accept valid member counts', () => {
+      expect(() => validateGroupMembers(2)).not.toThrow();
+      expect(() => validateGroupMembers(10)).not.toThrow();
+      expect(() => validateGroupMembers(256)).not.toThrow();
+    });
+
+    it('should reject invalid member counts', () => {
+      expect(() => validateGroupMembers(0)).toThrow(ValidationError);
+      expect(() => validateGroupMembers(1)).toThrow(ValidationError); // Too few
+      expect(() => validateGroupMembers(257)).toThrow(ValidationError); // Too many
+    });
+  });
+});

package/tsconfig.json

@@ -4,26 +4,24 @@
     // File Layout
     // "rootDir": "./src",
     // "outDir": "./dist",
-
     // Environment Settings
     // See also https://aka.ms/tsconfig/module
     "module": "nodenext",
     "target": "esnext",
- 
     // For nodejs:
     // "lib": ["esnext"],
-    "types": ["node"],
+    "types": [
+      "node",
+      "jest"
+    ],
     // and npm install -D @types/node
-
     // Other Outputs
     "sourceMap": true,
     "declaration": true,
     "declarationMap": true,
-
     // Stricter Typechecking Options
     "noUncheckedIndexedAccess": true,
     "exactOptionalPropertyTypes": true,
-
     // Style Options
     // "noImplicitReturns": true,
     // "noImplicitOverride": true,
@@ -31,7 +29,6 @@
     // "noUnusedParameters": true,
     // "noFallthroughCasesInSwitch": true,
     // "noPropertyAccessFromIndexSignature": true,
-
     // Recommended Options
     "strict": true,
     "jsx": "react-jsx",
@@ -39,6 +36,10 @@
     "isolatedModules": true,
     "noUncheckedSideEffectImports": true,
     "moduleDetection": "force",
-    "skipLibCheck": true,
-  }
-}
+    "skipLibCheck": true
+  },
+  "exclude": [
+    "dist",
+    "node_modules"
+  ]
+}

package/tsconfig.test.json

@@ -0,0 +1,11 @@
+{
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "module": "commonjs",
+        "esModuleInterop": true
+    },
+    "include": [
+        "test/**/*.ts",
+        "src/**/*.ts"
+    ]
+}

package/src/ChatManager.ts

@@ -1,103 +0,0 @@
-
-import { KeyManager, KeyPair } from './crypto/keyManager';
-import { encrypt } from './crypto/encrypt';
-import { decrypt } from './crypto/decrypt';
-import { ChatClient } from './transport/websocketClient';
-import { Message } from './models/Message';
-
-export class ChatManager {
-  private keyManager: KeyManager;
-  private chatClient: ChatClient;
-  private contacts: { [id: string]: Uint8Array } = {}; // Maps user ID to public key
-
-  constructor(websocketUrl: string) {
-    this.keyManager = new KeyManager();
-    this.chatClient = new ChatClient(websocketUrl);
-  }
-
-  async initialize(): Promise<void> {
-    await this.keyManager.generateKeys();
-    this.chatClient.connect();
-    this.chatClient.onMessage(this.handleIncomingMessage.bind(this));
-  }
-
-  addContact(userId: string, publicKey: Uint8Array): void {
-    this.contacts[userId] = publicKey;
-  }
-
-  async sendMessage(recipientId: string, content: string): Promise<void> {
-    const recipientPublicKey = this.contacts[recipientId];
-    if (!recipientPublicKey) {
-      throw new Error(`Contact not found: ${recipientId}`);
-    }
-
-    const senderPrivateKey = this.keyManager.getPrivateKey();
-    if (!senderPrivateKey) {
-      throw new Error('Sender keys not generated.');
-    }
-
-    const message: Message = {
-      id: Date.now().toString(),
-      senderId: this.getOwnUserId(),
-      recipientId,
-      content,
-      timestamp: Date.now(),
-    };
-
-    const encryptedMessage = await encrypt(
-      JSON.stringify(message),
-      recipientPublicKey,
-      senderPrivateKey
-    );
-
-    this.chatClient.sendMessage(Buffer.from(encryptedMessage));
-  }
-
-  private async handleIncomingMessage(encryptedMessage: Buffer): Promise<void> {
-    // In a real application, you would need a way to identify the sender
-    // and get their public key. For this example, we'll assume the sender
-    // is the only other contact.
-    const senderId = Object.keys(this.contacts)[0];
-    if (!senderId) {
-      console.error('Received message but no contacts are known.');
-      return;
-    }
-    const senderPublicKey = this.contacts[senderId];
-
-    if (!senderPublicKey) {
-      console.error('Received message from unknown sender.');
-      return;
-    }
-
-    const recipientPrivateKey = this.keyManager.getPrivateKey();
-    if (!recipientPrivateKey) {
-      throw new Error('Recipient keys not generated.');
-    }
-
-    try {
-      const decryptedMessageJson = await decrypt(
-        encryptedMessage,
-        senderPublicKey,
-        recipientPrivateKey
-      );
-      const message: Message = JSON.parse(decryptedMessageJson);
-      console.log('Decrypted message:', message);
-    } catch (error) {
-      console.error('Failed to decrypt message:', error);
-    }
-  }
-
-  getOwnUserId(): string {
-    // In a real app, this would be a unique user ID.
-    // For this example, we'll use a hash of the public key.
-    const publicKey = this.keyManager.getPublicKey();
-    if (!publicKey) {
-      throw new Error('Keys not generated.');
-    }
-    return Buffer.from(publicKey).toString('hex');
-  }
-
-  getOwnPublicKey(): Uint8Array | null {
-    return this.keyManager.getPublicKey();
-  }
-}

package/src/crypto/keyManager.ts

@@ -1,28 +0,0 @@
-
-import sodium from 'libsodium-wrappers';
-
-export interface KeyPair {
-  publicKey: Uint8Array;
-  privateKey: Uint8Array;
-}
-
-export class KeyManager {
-  private keyPair: KeyPair | null = null;
-
-  async generateKeys(): Promise<void> {
-    await sodium.ready;
-    const keys = sodium.crypto_box_keypair();
-    this.keyPair = {
-      publicKey: keys.publicKey,
-      privateKey: keys.privateKey,
-    };
-  }
-
-  getPublicKey(): Uint8Array | null {
-    return this.keyPair ? this.keyPair.publicKey : null;
-  }
-
-  getPrivateKey(): Uint8Array | null {
-    return this.keyPair ? this.keyPair.privateKey : null;
-  }
-}