chatly-sdk 0.0.5 → 0.0.6

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();

package/src/utils/mediaUtils.ts

@@ -0,0 +1,235 @@
+import { MediaType, MediaMetadata, MediaAttachment, SUPPORTED_MIME_TYPES, FILE_SIZE_LIMITS } from '../models/mediaTypes.js';
+import { ValidationError } from './errors.js';
+
+/**
+ * Convert File or Blob to base64 string
+ */
+export async function encodeFileToBase64(file: File | Blob): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      const result = reader.result as string;
+      if (!result) {
+        reject(new Error('Failed to read file: result is null'));
+        return;
+      }
+      const base64 = result.split(',')[1];
+      if (!base64) {
+        reject(new Error('Failed to extract base64 data'));
+        return;
+      }
+      resolve(base64);
+    };
+    reader.onerror = () => reject(new Error('Failed to read file'));
+    reader.readAsDataURL(file);
+  });
+}
+
+/**
+ * Convert base64 string to Blob
+ */
+export function decodeBase64ToBlob(base64: string, mimeType: string): Blob {
+  const byteCharacters = atob(base64);
+  const byteNumbers = new Array(byteCharacters.length);
+  
+  for (let i = 0; i < byteCharacters.length; i++) {
+    byteNumbers[i] = byteCharacters.charCodeAt(i);
+  }
+  
+  const byteArray = new Uint8Array(byteNumbers);
+  return new Blob([byteArray], { type: mimeType });
+}
+
+/**
+ * Detect media type from MIME type
+ */
+export function getMediaType(mimeType: string): MediaType {
+  if (SUPPORTED_MIME_TYPES.image.includes(mimeType)) {
+    return MediaType.IMAGE;
+  }
+  if (SUPPORTED_MIME_TYPES.audio.includes(mimeType)) {
+    return MediaType.AUDIO;
+  }
+  if (SUPPORTED_MIME_TYPES.video.includes(mimeType)) {
+    return MediaType.VIDEO;
+  }
+  if (SUPPORTED_MIME_TYPES.document.includes(mimeType)) {
+    return MediaType.DOCUMENT;
+  }
+  throw new ValidationError(`Unsupported MIME type: ${mimeType}`);
+}
+
+/**
+ * Validate media file
+ */
+export function validateMediaFile(file: File | Blob, filename?: string): void {
+  const mimeType = file.type;
+  
+  // Check if MIME type is supported
+  const mediaType = getMediaType(mimeType);
+  
+  // Check file size
+  const maxSize = FILE_SIZE_LIMITS[mediaType];
+  if (file.size > maxSize) {
+    throw new ValidationError(
+      `File size exceeds limit. Max size for ${mediaType}: ${maxSize / 1024 / 1024}MB`
+    );
+  }
+  
+  // Validate filename if provided
+  if (filename && filename.length > 255) {
+    throw new ValidationError('Filename too long (max 255 characters)');
+  }
+}
+
+/**
+ * Create media metadata from file
+ */
+export async function createMediaMetadata(
+  file: File | Blob,
+  filename?: string
+): Promise<MediaMetadata> {
+  const actualFilename = filename || (file instanceof File ? file.name : 'file');
+  
+  const metadata: MediaMetadata = {
+    filename: actualFilename,
+    mimeType: file.type,
+    size: file.size,
+  };
+  
+  // For images, try to get dimensions
+  if (file.type.startsWith('image/')) {
+    try {
+      const dimensions = await getImageDimensions(file);
+      metadata.width = dimensions.width;
+      metadata.height = dimensions.height;
+      
+      // Generate thumbnail for images
+      metadata.thumbnail = await generateThumbnail(file);
+    } catch (error) {
+      // Dimensions optional, continue without them
+    }
+  }
+  
+  // For audio/video, duration would need to be provided by the caller
+  // as we can't reliably get it in Node.js without external libraries
+  
+  return metadata;
+}
+
+/**
+ * Get image dimensions
+ */
+function getImageDimensions(file: Blob): Promise<{ width: number; height: number }> {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    const url = URL.createObjectURL(file);
+    
+    img.onload = () => {
+      URL.revokeObjectURL(url);
+      resolve({ width: img.width, height: img.height });
+    };
+    
+    img.onerror = () => {
+      URL.revokeObjectURL(url);
+      reject(new Error('Failed to load image'));
+    };
+    
+    img.src = url;
+  });
+}
+
+/**
+ * Generate thumbnail for image (max 200x200)
+ */
+async function generateThumbnail(file: Blob): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    const url = URL.createObjectURL(file);
+    
+    img.onload = () => {
+      URL.revokeObjectURL(url);
+      
+      // Calculate thumbnail size (max 200x200, maintain aspect ratio)
+      const maxSize = 200;
+      let width = img.width;
+      let height = img.height;
+      
+      if (width > height) {
+        if (width > maxSize) {
+          height = (height * maxSize) / width;
+          width = maxSize;
+        }
+      } else {
+        if (height > maxSize) {
+          width = (width * maxSize) / height;
+          height = maxSize;
+        }
+      }
+      
+      // Create canvas and draw thumbnail
+      const canvas = document.createElement('canvas');
+      canvas.width = width;
+      canvas.height = height;
+      const ctx = canvas.getContext('2d');
+      
+      if (!ctx) {
+        reject(new Error('Failed to get canvas context'));
+        return;
+      }
+      
+      ctx.drawImage(img, 0, 0, width, height);
+      
+      // Convert to base64
+      const dataUrl = canvas.toDataURL('image/jpeg', 0.7);
+      const thumbnail = dataUrl.split(',')[1];
+      if (!thumbnail) {
+        reject(new Error('Failed to generate thumbnail'));
+        return;
+      }
+      resolve(thumbnail);
+    };
+    
+    img.onerror = () => {
+      URL.revokeObjectURL(url);
+      reject(new Error('Failed to load image for thumbnail'));
+    };
+    
+    img.src = url;
+  });
+}
+
+/**
+ * Create media attachment from file
+ */
+export async function createMediaAttachment(
+  file: File | Blob,
+  filename?: string
+): Promise<MediaAttachment> {
+  // Validate file
+  validateMediaFile(file, filename);
+  
+  // Get media type
+  const mediaType = getMediaType(file.type);
+  
+  // Encode file to base64
+  const data = await encodeFileToBase64(file);
+  
+  // Create metadata
+  const metadata = await createMediaMetadata(file, filename);
+  
+  return {
+    type: mediaType,
+    data,
+    metadata,
+  };
+}
+
+/**
+ * Format file size for display
+ */
+export function formatFileSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}

package/src/utils/messageQueue.ts

@@ -0,0 +1,162 @@
+import { Message } from '../models/message.js';
+import { logger } from './logger.js';
+import { MAX_QUEUE_SIZE, MESSAGE_RETRY_ATTEMPTS, MESSAGE_RETRY_DELAY, MessageStatus } from '../constants.js';
+
+/**
+ * Queued message with retry metadata
+ */
+export interface QueuedMessage {
+  message: Message;
+  status: MessageStatus;
+  attempts: number;
+  lastAttempt?: number;
+  error?: Error;
+}
+
+/**
+ * Message queue for offline support and retry logic
+ */
+export class MessageQueue {
+  private queue: Map<string, QueuedMessage> = new Map();
+  private maxSize: number;
+  private maxRetries: number;
+  private retryDelay: number;
+
+  constructor(
+    maxSize: number = MAX_QUEUE_SIZE,
+    maxRetries: number = MESSAGE_RETRY_ATTEMPTS,
+    retryDelay: number = MESSAGE_RETRY_DELAY
+  ) {
+    this.maxSize = maxSize;
+    this.maxRetries = maxRetries;
+    this.retryDelay = retryDelay;
+  }
+
+  /**
+   * Add a message to the queue
+   */
+  enqueue(message: Message): void {
+    if (this.queue.size >= this.maxSize) {
+      logger.warn('Message queue is full, removing oldest message');
+      const firstKey = this.queue.keys().next().value;
+      if (firstKey) {
+        this.queue.delete(firstKey);
+      }
+    }
+
+    this.queue.set(message.id, {
+      message,
+      status: MessageStatus.PENDING,
+      attempts: 0,
+    });
+
+    logger.debug('Message enqueued', { messageId: message.id });
+  }
+
+  /**
+   * Mark a message as sent
+   */
+  markSent(messageId: string): void {
+    const queued = this.queue.get(messageId);
+    if (queued) {
+      queued.status = MessageStatus.SENT;
+      logger.debug('Message marked as sent', { messageId });
+      // Remove from queue after successful send
+      this.queue.delete(messageId);
+    }
+  }
+
+  /**
+   * Mark a message as failed
+   */
+  markFailed(messageId: string, error: Error): void {
+    const queued = this.queue.get(messageId);
+    if (queued) {
+      queued.status = MessageStatus.FAILED;
+      queued.error = error;
+      queued.attempts++;
+      queued.lastAttempt = Date.now();
+
+      logger.warn('Message failed', {
+        messageId,
+        attempts: queued.attempts,
+        error: error.message,
+      });
+
+      // Remove if max retries exceeded
+      if (queued.attempts >= this.maxRetries) {
+        logger.error('Message exceeded max retries, removing from queue', {
+          messageId,
+          attempts: queued.attempts,
+        });
+        this.queue.delete(messageId);
+      }
+    }
+  }
+
+  /**
+   * Get messages that need to be retried
+   */
+  getRetryableMessages(): QueuedMessage[] {
+    const now = Date.now();
+    const retryable: QueuedMessage[] = [];
+
+    for (const queued of this.queue.values()) {
+      if (
+        queued.status === MessageStatus.FAILED &&
+        queued.attempts < this.maxRetries &&
+        (!queued.lastAttempt || now - queued.lastAttempt >= this.retryDelay)
+      ) {
+        retryable.push(queued);
+      }
+    }
+
+    return retryable;
+  }
+
+  /**
+   * Get all pending messages
+   */
+  getPendingMessages(): QueuedMessage[] {
+    return Array.from(this.queue.values()).filter(
+      (q) => q.status === MessageStatus.PENDING
+    );
+  }
+
+  /**
+   * Get queue size
+   */
+  size(): number {
+    return this.queue.size;
+  }
+
+  /**
+   * Clear the queue
+   */
+  clear(): void {
+    this.queue.clear();
+    logger.debug('Message queue cleared');
+  }
+
+  /**
+   * Get message by ID
+   */
+  get(messageId: string): QueuedMessage | undefined {
+    return this.queue.get(messageId);
+  }
+
+  /**
+   * Remove message from queue
+   */
+  remove(messageId: string): void {
+    this.queue.delete(messageId);
+    logger.debug('Message removed from queue', { messageId });
+  }
+
+  /**
+   * Get all messages in queue
+   */
+  getAll(): QueuedMessage[] {
+    return Array.from(this.queue.values());
+  }
+}

package/src/utils/validation.ts

@@ -0,0 +1,99 @@
+import { ValidationError } from "./errors.js";
+
+/**
+ * Validation utilities
+ */
+
+const USERNAME_REGEX = /^[a-zA-Z0-9_-]{3,20}$/;
+const MAX_MESSAGE_LENGTH = 10000;
+const MIN_GROUP_MEMBERS = 2;
+const MAX_GROUP_MEMBERS = 256;
+const MAX_GROUP_NAME_LENGTH = 100;
+
+/**
+ * Validate username format
+ */
+export function validateUsername(username: string): void {
+  if (!username || typeof username !== 'string') {
+    throw new ValidationError('Username is required', { username });
+  }
+
+  if (!USERNAME_REGEX.test(username)) {
+    throw new ValidationError(
+      'Username must be 3-20 characters and contain only letters, numbers, underscores, and hyphens',
+      { username }
+    );
+  }
+}
+
+/**
+ * Validate message content
+ */
+export function validateMessage(message: string): void {
+  if (!message || typeof message !== 'string') {
+    throw new ValidationError('Message content is required');
+  }
+
+  if (message.length === 0) {
+    throw new ValidationError('Message cannot be empty');
+  }
+
+  if (message.length > MAX_MESSAGE_LENGTH) {
+    throw new ValidationError(
+      `Message exceeds maximum length of ${MAX_MESSAGE_LENGTH} characters`,
+      { length: message.length, max: MAX_MESSAGE_LENGTH }
+    );
+  }
+}
+
+/**
+ * Validate group name
+ */
+export function validateGroupName(name: string): void {
+  if (!name || typeof name !== 'string') {
+    throw new ValidationError('Group name is required');
+  }
+
+  if (name.trim().length === 0) {
+    throw new ValidationError('Group name cannot be empty');
+  }
+
+  if (name.length > MAX_GROUP_NAME_LENGTH) {
+    throw new ValidationError(
+      `Group name exceeds maximum length of ${MAX_GROUP_NAME_LENGTH} characters`,
+      { length: name.length, max: MAX_GROUP_NAME_LENGTH }
+    );
+  }
+}
+
+/**
+ * Validate group members count
+ */
+export function validateGroupMembers(memberCount: number): void {
+  if (memberCount < MIN_GROUP_MEMBERS) {
+    throw new ValidationError(
+      `Group must have at least ${MIN_GROUP_MEMBERS} members`,
+      { count: memberCount, min: MIN_GROUP_MEMBERS }
+    );
+  }
+
+  if (memberCount > MAX_GROUP_MEMBERS) {
+    throw new ValidationError(
+      `Group cannot have more than ${MAX_GROUP_MEMBERS} members`,
+      { count: memberCount, max: MAX_GROUP_MEMBERS }
+    );
+  }
+}
+
+/**
+ * Validate user ID format
+ */
+export function validateUserId(userId: string): void {
+  if (!userId || typeof userId !== 'string') {
+    throw new ValidationError('User ID is required');
+  }
+
+  if (userId.trim().length === 0) {
+    throw new ValidationError('User ID cannot be empty');
+  }
+}