chatly-sdk 0.0.4 → 0.0.6

package/src/models/mediaTypes.ts

@@ -0,0 +1,58 @@
+/**
+ * Media types supported by the SDK
+ */
+export enum MediaType {
+  IMAGE = 'image',
+  AUDIO = 'audio',
+  VIDEO = 'video',
+  DOCUMENT = 'document',
+}
+
+/**
+ * Media metadata
+ */
+export interface MediaMetadata {
+  filename: string;
+  mimeType: string;
+  size: number;
+  width?: number;  // For images/videos
+  height?: number; // For images/videos
+  duration?: number; // For audio/video (in seconds)
+  thumbnail?: string; // Base64 thumbnail for images/videos
+}
+
+/**
+ * Media attachment
+ */
+export interface MediaAttachment {
+  type: MediaType;
+  data: string; // Base64 encoded file data
+  metadata: MediaMetadata;
+}
+
+/**
+ * Supported MIME types
+ */
+export const SUPPORTED_MIME_TYPES = {
+  image: ['image/jpeg', 'image/png', 'image/gif', 'image/webp'],
+  audio: ['audio/mpeg', 'audio/mp4', 'audio/ogg', 'audio/wav', 'audio/webm'],
+  video: ['video/mp4', 'video/webm', 'video/ogg'],
+  document: [
+    'application/pdf',
+    'application/msword',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    'application/vnd.ms-excel',
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    'text/plain',
+  ],
+};
+
+/**
+ * File size limits (in bytes)
+ */
+export const FILE_SIZE_LIMITS = {
+  image: 10 * 1024 * 1024,    // 10 MB
+  audio: 16 * 1024 * 1024,    // 16 MB
+  video: 100 * 1024 * 1024,   // 100 MB
+  document: 100 * 1024 * 1024, // 100 MB
+};

package/src/models/message.ts

@@ -1,4 +1,6 @@
-export type MessageType = "text" | "system";
+import type { MediaAttachment } from './mediaTypes.js';
+
+export type MessageType = "text" | "media" | "system";
 
 export interface Message {
   id: string;
@@ -9,5 +11,6 @@ export interface Message {
   iv: string;
   timestamp: number;
   type: MessageType;
+  media?: MediaAttachment; // Optional media attachment
 }
 

package/src/transport/adapters.ts

@@ -1,7 +1,57 @@
-import type { Message } from "../models/message.js";
+import { Message } from "../models/message.js";
+import { ConnectionState } from "../constants.js";
 
+/**
+ * Transport adapter interface for network communication
+ */
 export interface TransportAdapter {
+  /**
+   * Connect to the transport
+   * @param userId - User ID to connect as
+   */
   connect(userId: string): Promise<void>;
+
+  /**
+   * Disconnect from the transport
+   */
+  disconnect(): Promise<void>;
+
+  /**
+   * Reconnect to the transport
+   */
+  reconnect(): Promise<void>;
+
+  /**
+   * Send a message
+   * @param message - Message to send
+   */
   send(message: Message): Promise<void>;
+
+  /**
+   * Register a message handler
+   * @param handler - Function to call when a message is received
+   */
   onMessage(handler: (message: Message) => void): void;
+
+  /**
+   * Register a connection state change handler
+   * @param handler - Function to call when connection state changes
+   */
+  onConnectionStateChange?(handler: (state: ConnectionState) => void): void;
+
+  /**
+   * Register an error handler
+   * @param handler - Function to call when an error occurs
+   */
+  onError?(handler: (error: Error) => void): void;
+
+  /**
+   * Get the current connection state
+   */
+  getConnectionState(): ConnectionState;
+
+  /**
+   * Check if transport is connected
+   */
+  isConnected(): boolean;
 }

package/src/transport/memoryTransport.ts

@@ -1,24 +1,86 @@
-import type { Message } from "../models/message.js";
-import type { TransportAdapter } from "./adapters.js";
-
-type MessageHandler = (message: Message) => void;
+import { Message } from "../models/message.js";
+import { TransportAdapter } from "./adapters.js";
+import { ConnectionState } from "../constants.js";
 
+/**
+ * In-memory transport for testing (no actual network communication)
+ */
 export class InMemoryTransport implements TransportAdapter {
-  private handler?: MessageHandler;
-  private connected = false;
+  private messageHandler: ((message: Message) => void) | null = null;
+  private connectionState: ConnectionState = ConnectionState.DISCONNECTED;
+  private stateHandler: ((state: ConnectionState) => void) | null = null;
+  private errorHandler: ((error: Error) => void) | null = null;
+
+  async connect(userId: string): Promise<void> {
+    this.connectionState = ConnectionState.CONNECTED;
+    if (this.stateHandler) {
+      this.stateHandler(this.connectionState);
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    this.connectionState = ConnectionState.DISCONNECTED;
+    if (this.stateHandler) {
+      this.stateHandler(this.connectionState);
+    }
+  }
 
-  async connect(_userId: string): Promise<void> {
-    this.connected = true;
+  async reconnect(): Promise<void> {
+    this.connectionState = ConnectionState.CONNECTING;
+    if (this.stateHandler) {
+      this.stateHandler(this.connectionState);
+    }
+    
+    // Simulate reconnection delay
+    await new Promise(resolve => setTimeout(resolve, 100));
+    
+    this.connectionState = ConnectionState.CONNECTED;
+    if (this.stateHandler) {
+      this.stateHandler(this.connectionState);
+    }
   }
 
   async send(message: Message): Promise<void> {
-    if (!this.connected) {
-      throw new Error("Transport not connected");
+    // In-memory transport just echoes back the message
+    if (this.messageHandler) {
+      // Simulate async delivery
+      setTimeout(() => {
+        this.messageHandler!(message);
+      }, 10);
     }
-    this.handler?.(message);
   }
 
-  onMessage(handler: MessageHandler): void {
-    this.handler = handler;
+  onMessage(handler: (message: Message) => void): void {
+    this.messageHandler = handler;
+  }
+
+  onConnectionStateChange(handler: (state: ConnectionState) => void): void {
+    this.stateHandler = handler;
+  }
+
+  onError(handler: (error: Error) => void): void {
+    this.errorHandler = handler;
+  }
+
+  getConnectionState(): ConnectionState {
+    return this.connectionState;
+  }
+
+  isConnected(): boolean {
+    return this.connectionState === ConnectionState.CONNECTED;
+  }
+
+  // Test helper to simulate receiving a message
+  simulateReceive(message: Message): void {
+    if (this.messageHandler) {
+      this.messageHandler(message);
+    }
+  }
+
+  // Test helper to simulate an error
+  simulateError(error: Error): void {
+    if (this.errorHandler) {
+      this.errorHandler(error);
+    }
   }
 }

package/src/transport/websocketClient.ts

@@ -1,37 +1,285 @@
+import { Message } from "../models/message.js";
+import { TransportAdapter } from "./adapters.js";
+import {
+  ConnectionState,
+  RECONNECT_MAX_ATTEMPTS,
+  RECONNECT_BASE_DELAY,
+  RECONNECT_MAX_DELAY,
+  HEARTBEAT_INTERVAL,
+  CONNECTION_TIMEOUT,
+} from "../constants.js";
+import { NetworkError, TransportError } from "../utils/errors.js";
+import { logger } from "../utils/logger.js";
 
-import WebSocket from 'ws';
-
-export class ChatClient {
+export class WebSocketClient implements TransportAdapter {
   private ws: WebSocket | null = null;
-  private messageHandlers: ((message: Buffer) => void)[] = [];
+  private url: string;
+  private messageHandler: ((message: Message) => void) | null = null;
+  private stateHandler: ((state: ConnectionState) => void) | null = null;
+  private errorHandler: ((error: Error) => void) | null = null;
+  private connectionState: ConnectionState = ConnectionState.DISCONNECTED;
+  private reconnectAttempts: number = 0;
+  private reconnectTimer: NodeJS.Timeout | null = null;
+  private heartbeatTimer: NodeJS.Timeout | null = null;
+  private currentUserId: string | null = null;
+  private shouldReconnect: boolean = true;
 
-  constructor(private url: string) {}
+  constructor(url: string) {
+    this.url = url;
+  }
 
-  connect(): void {
-    this.ws = new WebSocket(this.url);
+  async connect(userId: string): Promise<void> {
+    this.currentUserId = userId;
+    this.shouldReconnect = true;
+    return this.doConnect();
+  }
 
-    this.ws.on('open', () => {
-      console.log('Connected to WebSocket server');
-    });
+  private async doConnect(): Promise<void> {
+    if (this.connectionState === ConnectionState.CONNECTING) {
+      logger.warn('Already connecting, skipping duplicate connect attempt');
+      return;
+    }
 
-    this.ws.on('message', (message: Buffer) => {
-      this.messageHandlers.forEach(handler => handler(message));
-    });
+    this.updateState(ConnectionState.CONNECTING);
+    logger.info('Connecting to WebSocket', { url: this.url, userId: this.currentUserId });
+
+    return new Promise((resolve, reject) => {
+      try {
+        const wsUrl = this.currentUserId 
+          ? `${this.url}?userId=${this.currentUserId}`
+          : this.url;
+        
+        this.ws = new WebSocket(wsUrl);
+
+        const connectionTimeout = setTimeout(() => {
+          if (this.connectionState === ConnectionState.CONNECTING) {
+            this.ws?.close();
+            const error = new NetworkError('Connection timeout');
+            this.handleError(error);
+            reject(error);
+          }
+        }, CONNECTION_TIMEOUT);
+
+        this.ws.onopen = () => {
+          clearTimeout(connectionTimeout);
+          this.reconnectAttempts = 0;
+          this.updateState(ConnectionState.CONNECTED);
+          logger.info('WebSocket connected');
+          this.startHeartbeat();
+          resolve();
+        };
+
+        this.ws.onmessage = (event) => {
+          try {
+            const message = JSON.parse(event.data);
+            
+            // Handle pong response
+            if (message.type === 'pong') {
+              logger.debug('Received pong');
+              return;
+            }
+
+            if (this.messageHandler) {
+              this.messageHandler(message);
+            }
+          } catch (error) {
+            const parseError = new TransportError(
+              'Failed to parse message',
+              false,
+              { error: error instanceof Error ? error.message : String(error) }
+            );
+            logger.error('Message parse error', parseError);
+            this.handleError(parseError);
+          }
+        };
+
+        this.ws.onerror = (event) => {
+          clearTimeout(connectionTimeout);
+          const error = new NetworkError('WebSocket error', {
+            event: event.type,
+          });
+          logger.error('WebSocket error', error);
+          this.handleError(error);
+          reject(error);
+        };
+
+        this.ws.onclose = (event) => {
+          clearTimeout(connectionTimeout);
+          this.stopHeartbeat();
+          logger.info('WebSocket closed', {
+            code: event.code,
+            reason: event.reason,
+            wasClean: event.wasClean,
+          });
 
-    this.ws.on('close', () => {
-      console.log('Disconnected from WebSocket server');
+          if (this.connectionState !== ConnectionState.DISCONNECTED) {
+            this.updateState(ConnectionState.DISCONNECTED);
+            
+            // Attempt reconnection if not manually disconnected
+            if (this.shouldReconnect && this.reconnectAttempts < RECONNECT_MAX_ATTEMPTS) {
+              this.scheduleReconnect();
+            } else if (this.reconnectAttempts >= RECONNECT_MAX_ATTEMPTS) {
+              this.updateState(ConnectionState.FAILED);
+              const error = new NetworkError('Max reconnection attempts exceeded');
+              this.handleError(error);
+            }
+          }
+        };
+      } catch (error) {
+        const connectError = new NetworkError(
+          'Failed to create WebSocket connection',
+          { error: error instanceof Error ? error.message : String(error) }
+        );
+        logger.error('Connection error', connectError);
+        this.handleError(connectError);
+        reject(connectError);
+      }
     });
   }
 
-  sendMessage(message: string | Buffer): void {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      this.ws.send(message);
+  async disconnect(): Promise<void> {
+    logger.info('Disconnecting WebSocket');
+    this.shouldReconnect = false;
+    this.clearReconnectTimer();
+    this.stopHeartbeat();
+
+    if (this.ws) {
+      this.ws.close(1000, 'Client disconnect');
+      this.ws = null;
+    }
+
+    this.updateState(ConnectionState.DISCONNECTED);
+  }
+
+  async reconnect(): Promise<void> {
+    logger.info('Manual reconnect requested');
+    this.reconnectAttempts = 0;
+    this.shouldReconnect = true;
+    await this.disconnect();
+    
+    if (this.currentUserId) {
+      await this.doConnect();
     } else {
-      console.error('WebSocket is not connected.');
+      throw new TransportError('Cannot reconnect: no user ID set');
     }
   }
 
-  onMessage(handler: (message: Buffer) => void): void {
-    this.messageHandlers.push(handler);
+  private scheduleReconnect(): void {
+    this.clearReconnectTimer();
+    this.reconnectAttempts++;
+    
+    // Exponential backoff with jitter
+    const delay = Math.min(
+      RECONNECT_BASE_DELAY * Math.pow(2, this.reconnectAttempts - 1),
+      RECONNECT_MAX_DELAY
+    );
+    const jitter = Math.random() * 1000;
+    const totalDelay = delay + jitter;
+
+    logger.info('Scheduling reconnect', {
+      attempt: this.reconnectAttempts,
+      delay: totalDelay,
+    });
+
+    this.updateState(ConnectionState.RECONNECTING);
+
+    this.reconnectTimer = setTimeout(async () => {
+      try {
+        await this.doConnect();
+      } catch (error) {
+        logger.error('Reconnect failed', error);
+      }
+    }, totalDelay);
+  }
+
+  private clearReconnectTimer(): void {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+
+  private startHeartbeat(): void {
+    this.stopHeartbeat();
+    
+    this.heartbeatTimer = setInterval(() => {
+      if (this.isConnected()) {
+        try {
+          this.ws?.send(JSON.stringify({ type: 'ping' }));
+          logger.debug('Sent ping');
+        } catch (error) {
+          logger.error('Failed to send heartbeat', error);
+        }
+      }
+    }, HEARTBEAT_INTERVAL);
+  }
+
+  private stopHeartbeat(): void {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+
+  async send(message: Message): Promise<void> {
+    if (!this.isConnected() || !this.ws) {
+      throw new NetworkError('WebSocket not connected');
+    }
+
+    try {
+      this.ws.send(JSON.stringify(message));
+      logger.debug('Message sent', { messageId: message.id });
+    } catch (error) {
+      const sendError = new NetworkError(
+        'Failed to send message',
+        { error: error instanceof Error ? error.message : String(error) }
+      );
+      logger.error('Send error', sendError);
+      throw sendError;
+    }
+  }
+
+  onMessage(handler: (message: Message) => void): void {
+    this.messageHandler = handler;
+  }
+
+  onConnectionStateChange(handler: (state: ConnectionState) => void): void {
+    this.stateHandler = handler;
+  }
+
+  onError(handler: (error: Error) => void): void {
+    this.errorHandler = handler;
+  }
+
+  getConnectionState(): ConnectionState {
+    return this.connectionState;
+  }
+
+  isConnected(): boolean {
+    return (
+      this.connectionState === ConnectionState.CONNECTED &&
+      this.ws?.readyState === WebSocket.OPEN
+    );
+  }
+
+  private updateState(newState: ConnectionState): void {
+    if (this.connectionState !== newState) {
+      const oldState = this.connectionState;
+      this.connectionState = newState;
+      logger.info('Connection state changed', {
+        from: oldState,
+        to: newState,
+      });
+      
+      if (this.stateHandler) {
+        this.stateHandler(newState);
+      }
+    }
+  }
+
+  private handleError(error: Error): void {
+    if (this.errorHandler) {
+      this.errorHandler(error);
+    }
   }
 }

package/src/transport/websocketServer.ts

@@ -1,33 +1,33 @@
 
-import { WebSocketServer, WebSocket } from 'ws';
+// import { WebSocketServer, WebSocket } from 'ws';
 
-export class ChatServer {
-  private wss: WebSocketServer;
+// export class ChatServer {
+//   private wss: WebSocketServer;
 
-  constructor(port: number) {
-    this.wss = new WebSocketServer({ port });
-    this.initialize();
-  }
+//   constructor(port: number) {
+//     this.wss = new WebSocketServer({ port });
+//     this.initialize();
+//   }
 
-  private initialize(): void {
-    this.wss.on('connection', (ws: WebSocket) => {
-      console.log('Client connected');
+//   private initialize(): void {
+//     this.wss.on('connection', (ws: WebSocket) => {
+//       console.log('Client connected');
 
-      ws.on('message', (message: Buffer) => {
-        console.log('Received message:', message.toString());
-        // Broadcast the message to all other clients
-        this.wss.clients.forEach((client) => {
-          if (client !== ws && client.readyState === WebSocket.OPEN) {
-            client.send(message);
-          }
-        });
-      });
+//       ws.on('message', (message: Buffer) => {
+//         console.log('Received message:', message.toString());
+//         // Broadcast the message to all other clients
+//         this.wss.clients.forEach((client) => {
+//           if (client !== ws && client.readyState === WebSocket.OPEN) {
+//             client.send(message);
+//           }
+//         });
+//       });
 
-      ws.on('close', () => {
-        console.log('Client disconnected');
-      });
-    });
+//       ws.on('close', () => {
+//         console.log('Client disconnected');
+//       });
+//     });
 
-    console.log(`WebSocket server started on port ${this.wss.options.port}`);
-  }
-}
+//     console.log(`WebSocket server started on port ${this.wss.options.port}`);
+//   }
+// }

package/src/utils/errors.ts

@@ -0,0 +1,97 @@
+/**
+ * Base SDK Error class
+ */
+export class SDKError extends Error {
+  constructor(
+    message: string,
+    public readonly code: string,
+    public readonly retryable: boolean = false,
+    public readonly details?: Record<string, unknown>
+  ) {
+    super(message);
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      retryable: this.retryable,
+      details: this.details,
+    };
+  }
+}
+
+/**
+ * Network-related errors (connection, timeout, etc.)
+ */
+export class NetworkError extends SDKError {
+  constructor(message: string, details?: Record<string, unknown>) {
+    super(message, 'NETWORK_ERROR', true, details);
+  }
+}
+
+/**
+ * Encryption/Decryption errors
+ */
+export class EncryptionError extends SDKError {
+  constructor(message: string, details?: Record<string, unknown>) {
+    super(message, 'ENCRYPTION_ERROR', false, details);
+  }
+}
+
+/**
+ * Authentication/Authorization errors
+ */
+export class AuthError extends SDKError {
+  constructor(message: string, details?: Record<string, unknown>) {
+    super(message, 'AUTH_ERROR', false, details);
+  }
+}
+
+/**
+ * Validation errors (invalid input)
+ */
+export class ValidationError extends SDKError {
+  constructor(message: string, details?: Record<string, unknown>) {
+    super(message, 'VALIDATION_ERROR', false, details);
+  }
+}
+
+/**
+ * Storage-related errors
+ */
+export class StorageError extends SDKError {
+  constructor(message: string, retryable: boolean = true, details?: Record<string, unknown>) {
+    super(message, 'STORAGE_ERROR', retryable, details);
+  }
+}
+
+/**
+ * Session-related errors
+ */
+export class SessionError extends SDKError {
+  constructor(message: string, details?: Record<string, unknown>) {
+    super(message, 'SESSION_ERROR', false, details);
+  }
+}
+
+/**
+ * Transport-related errors
+ */
+export class TransportError extends SDKError {
+  constructor(message: string, retryable: boolean = true, details?: Record<string, unknown>) {
+    super(message, 'TRANSPORT_ERROR', retryable, details);
+  }
+}
+
+/**
+ * Configuration errors
+ */
+export class ConfigError extends SDKError {
+  constructor(message: string, details?: Record<string, unknown>) {
+    super(message, 'CONFIG_ERROR', false, details);
+  }
+}