chatly-sdk 1.0.0 → 2.0.0

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);
+  }
+}

package/src/utils/logger.ts

@@ -0,0 +1,96 @@
+/**
+ * Log levels
+ */
+export enum LogLevel {
+  DEBUG = 0,
+  INFO = 1,
+  WARN = 2,
+  ERROR = 3,
+  NONE = 4,
+}
+
+/**
+ * Logger configuration
+ */
+export interface LoggerConfig {
+  level: LogLevel;
+  prefix?: string;
+  timestamp?: boolean;
+}
+
+/**
+ * Simple structured logger
+ */
+export class Logger {
+  private config: LoggerConfig;
+
+  constructor(config: Partial<LoggerConfig> = {}) {
+    this.config = {
+      level: config.level ?? LogLevel.INFO,
+      prefix: config.prefix ?? '[ChatSDK]',
+      timestamp: config.timestamp ?? true,
+    };
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    return level >= this.config.level;
+  }
+
+  private formatMessage(level: string, message: string, data?: unknown): string {
+    const parts: string[] = [];
+    
+    if (this.config.timestamp) {
+      parts.push(new Date().toISOString());
+    }
+    
+    parts.push(this.config.prefix!);
+    parts.push(`[${level}]`);
+    parts.push(message);
+    
+    let formatted = parts.join(' ');
+    
+    if (data !== undefined) {
+      formatted += ' ' + JSON.stringify(data, null, 2);
+    }
+    
+    return formatted;
+  }
+
+  debug(message: string, data?: unknown): void {
+    if (this.shouldLog(LogLevel.DEBUG)) {
+      console.debug(this.formatMessage('DEBUG', message, data));
+    }
+  }
+
+  info(message: string, data?: unknown): void {
+    if (this.shouldLog(LogLevel.INFO)) {
+      console.info(this.formatMessage('INFO', message, data));
+    }
+  }
+
+  warn(message: string, data?: unknown): void {
+    if (this.shouldLog(LogLevel.WARN)) {
+      console.warn(this.formatMessage('WARN', message, data));
+    }
+  }
+
+  error(message: string, error?: Error | unknown): void {
+    if (this.shouldLog(LogLevel.ERROR)) {
+      const errorData = error instanceof Error 
+        ? { message: error.message, stack: error.stack }
+        : error;
+      console.error(this.formatMessage('ERROR', message, errorData));
+    }
+  }
+
+  setLevel(level: LogLevel): void {
+    this.config.level = level;
+  }
+
+  getLevel(): LogLevel {
+    return this.config.level;
+  }
+}
+
+// Default logger instance
+export const logger = new Logger();