chatly-sdk 1.0.0 → 2.0.0

package/src/models/mediaTypes.ts

@@ -0,0 +1,62 @@
+/**
+ * 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 | undefined; // Base64 encoded file data (optional if stored remotely)
+  iv?: string | undefined;   // Separate IV for media data encryption
+  metadata: MediaMetadata;
+  storage?: 'local' | 's3' | undefined; // Storage provider used
+  storageKey?: string | undefined;      // Key/path in the storage provider
+  url?: string | undefined;             // Public URL if available
+}
+
+/**
+ * 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/storage/adapters.ts

@@ -0,0 +1,36 @@
+export interface StorageUploadResult {
+  storageKey: string;
+  url?: string;
+}
+
+export interface StorageProvider {
+  /**
+   * Name of the storage provider (e.g., 'local', 's3')
+   */
+  readonly name: string;
+
+  /**
+   * Upload data to storage
+   * @param data Base64 encoded data or Buffer
+   * @param filename Desired filename or path
+   * @param mimeType MIME type of the file
+   */
+  upload(
+    data: string | Buffer,
+    filename: string,
+    mimeType: string
+  ): Promise<StorageUploadResult>;
+
+  /**
+   * Download data from storage
+   * @param storageKey Key/path of the file in storage
+   * @returns Base64 encoded data
+   */
+  download(storageKey: string): Promise<string>;
+
+  /**
+   * Delete data from storage
+   * @param storageKey Key/path of the file in storage
+   */
+  delete(storageKey: string): Promise<void>;
+}

package/src/storage/localStorage.ts

@@ -0,0 +1,49 @@
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import { StorageProvider, StorageUploadResult } from './adapters.js';
+
+export class LocalStorageProvider implements StorageProvider {
+  public readonly name = 'local';
+  private storageDir: string;
+
+  constructor(storageDir: string = './storage') {
+    this.storageDir = path.resolve(storageDir);
+    // Ensure storage directory exists
+    fs.mkdir(this.storageDir, { recursive: true }).catch(() => {});
+  }
+
+  async upload(
+    data: string | Buffer,
+    filename: string,
+    mimeType: string
+  ): Promise<StorageUploadResult> {
+    const buffer = typeof data === 'string' ? Buffer.from(data, 'base64') : data;
+    const filePath = path.join(this.storageDir, filename);
+    
+    // Ensure parent directories exist
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, buffer);
+
+    return {
+      storageKey: filename,
+      url: `file://${filePath}`,
+    };
+  }
+
+  async download(storageKey: string): Promise<string> {
+    const filePath = path.join(this.storageDir, storageKey);
+    const buffer = await fs.readFile(filePath);
+    return buffer.toString('base64');
+  }
+
+  async delete(storageKey: string): Promise<void> {
+    const filePath = path.join(this.storageDir, storageKey);
+    try {
+      await fs.unlink(filePath);
+    } catch (error: any) {
+      if (error.code !== 'ENOENT') {
+        throw error;
+      }
+    }
+  }
+}

package/src/storage/s3Storage.ts

@@ -0,0 +1,84 @@
+import { S3Client, PutObjectCommand, GetObjectCommand, DeleteObjectCommand } from '@aws-sdk/client-s3';
+import { StorageProvider, StorageUploadResult } from './adapters.js';
+
+export interface S3Config {
+  region: string;
+  bucket: string;
+  credentials?: {
+    accessKeyId: string;
+    secretAccessKey: string;
+  };
+  endpoint?: string;
+  forcePathStyle?: boolean;
+}
+
+export class S3StorageProvider implements StorageProvider {
+  public readonly name = 's3';
+  private client: S3Client;
+  private bucket: string;
+
+  constructor(config: S3Config) {
+    const s3Config: any = {
+      region: config.region,
+      forcePathStyle: config.forcePathStyle,
+    };
+
+    if (config.credentials) {
+      s3Config.credentials = config.credentials;
+    }
+
+    if (config.endpoint) {
+      s3Config.endpoint = config.endpoint;
+    }
+
+    this.client = new S3Client(s3Config);
+    this.bucket = config.bucket;
+  }
+
+  async upload(
+    data: string | Buffer,
+    filename: string,
+    mimeType: string
+  ): Promise<StorageUploadResult> {
+    const body = typeof data === 'string' ? Buffer.from(data, 'base64') : data;
+    
+    await this.client.send(
+      new PutObjectCommand({
+        Bucket: this.bucket,
+        Key: filename,
+        Body: body,
+        ContentType: mimeType,
+      })
+    );
+
+    return {
+      storageKey: filename,
+      url: `https://${this.bucket}.s3.amazonaws.com/${filename}`,
+    };
+  }
+
+  async download(storageKey: string): Promise<string> {
+    const response = await this.client.send(
+      new GetObjectCommand({
+        Bucket: this.bucket,
+        Key: storageKey,
+      })
+    );
+
+    if (!response.Body) {
+      throw new Error('S3 download failed: empty body');
+    }
+
+    const bytes = await response.Body.transformToByteArray();
+    return Buffer.from(bytes).toString('base64');
+  }
+
+  async delete(storageKey: string): Promise<void> {
+    await this.client.send(
+      new DeleteObjectCommand({
+        Bucket: this.bucket,
+        Key: storageKey,
+      })
+    );
+  }
+}

package/src/stores/adapters.ts

@@ -11,8 +11,10 @@ export interface UserStoreAdapter {
 
 export interface MessageStoreAdapter {
   create(message: Message): Promise<Message>;
+  findById(id: string): Promise<Message | undefined>;
   listByUser(userId: string): Promise<Message[]>;
   listByGroup(groupId: string): Promise<Message[]>;
+  delete(id: string): Promise<void>;
 }
 
 export interface GroupStoreAdapter {

package/src/stores/memory/messageStore.ts

@@ -9,6 +9,10 @@ export class InMemoryMessageStore implements MessageStoreAdapter {
     return message;
   }
 
+  async findById(id: string): Promise<Message | undefined> {
+    return this.messages.find((msg) => msg.id === id);
+  }
+
   async listByUser(userId: string): Promise<Message[]> {
     return this.messages.filter(
       (msg) => msg.senderId === userId || msg.receiverId === userId
@@ -18,4 +22,8 @@ export class InMemoryMessageStore implements MessageStoreAdapter {
   async listByGroup(groupId: string): Promise<Message[]> {
     return this.messages.filter((msg) => msg.groupId === groupId);
   }
+
+  async delete(id: string): Promise<void> {
+    this.messages = this.messages.filter((msg) => msg.id !== id);
+  }
 }

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