@scalemule/chat 0.0.1

package/dist/chunk-NFOVLPF2.cjs

@@ -0,0 +1,741 @@
+'use strict';
+
+// src/core/EventEmitter.ts
+var EventEmitter = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  on(event, callback) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(callback);
+    return () => this.off(event, callback);
+  }
+  off(event, callback) {
+    this.listeners.get(event)?.delete(callback);
+  }
+  once(event, callback) {
+    const wrapper = ((data) => {
+      this.off(event, wrapper);
+      callback(data);
+    });
+    return this.on(event, wrapper);
+  }
+  emit(event, ...[data]) {
+    const listeners = this.listeners.get(event);
+    if (listeners) {
+      for (const listener of listeners) {
+        try {
+          listener(data);
+        } catch (err) {
+          console.error(`[ScaleMuleChat] Error in ${String(event)} listener:`, err);
+        }
+      }
+    }
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.clear();
+    }
+  }
+};
+
+// src/constants.ts
+var DEFAULT_API_BASE_URL = "https://api.scalemule.com";
+var DEFAULT_WS_RECONNECT_BASE_DELAY = 1e3;
+var DEFAULT_WS_RECONNECT_MAX_DELAY = 3e4;
+var DEFAULT_WS_RECONNECT_MAX_RETRIES = Infinity;
+var DEFAULT_WS_HEARTBEAT_INTERVAL = 3e4;
+var DEFAULT_MESSAGE_CACHE_SIZE = 200;
+var DEFAULT_MAX_CONVERSATIONS_CACHED = 50;
+var DEFAULT_REQUEST_TIMEOUT = 1e4;
+
+// src/core/MessageCache.ts
+var MessageCache = class {
+  constructor(maxMessages, maxConversations) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxMessages = maxMessages ?? DEFAULT_MESSAGE_CACHE_SIZE;
+    this.maxConversations = maxConversations ?? DEFAULT_MAX_CONVERSATIONS_CACHED;
+  }
+  getMessages(conversationId) {
+    return this.cache.get(conversationId) ?? [];
+  }
+  setMessages(conversationId, messages) {
+    this.cache.set(conversationId, messages.slice(0, this.maxMessages));
+    this.evictOldConversations();
+  }
+  addMessage(conversationId, message) {
+    const messages = this.cache.get(conversationId) ?? [];
+    if (messages.some((m) => m.id === message.id)) return;
+    messages.push(message);
+    messages.sort((a, b) => a.created_at.localeCompare(b.created_at));
+    if (messages.length > this.maxMessages) {
+      messages.splice(0, messages.length - this.maxMessages);
+    }
+    this.cache.set(conversationId, messages);
+  }
+  updateMessage(conversationId, message) {
+    const messages = this.cache.get(conversationId);
+    if (!messages) return;
+    const idx = messages.findIndex((m) => m.id === message.id);
+    if (idx >= 0) {
+      messages[idx] = message;
+    }
+  }
+  removeMessage(conversationId, messageId) {
+    const messages = this.cache.get(conversationId);
+    if (!messages) return;
+    const idx = messages.findIndex((m) => m.id === messageId);
+    if (idx >= 0) {
+      messages.splice(idx, 1);
+    }
+  }
+  clear(conversationId) {
+    if (conversationId) {
+      this.cache.delete(conversationId);
+    } else {
+      this.cache.clear();
+    }
+  }
+  evictOldConversations() {
+    while (this.cache.size > this.maxConversations) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) this.cache.delete(firstKey);
+    }
+  }
+};
+
+// src/core/OfflineQueue.ts
+var STORAGE_KEY = "scalemule_chat_offline_queue";
+var OfflineQueue = class {
+  constructor(enabled = true) {
+    this.queue = [];
+    this.enabled = enabled;
+    if (this.enabled) {
+      this.load();
+    }
+  }
+  enqueue(conversationId, content, messageType = "text", attachments) {
+    if (!this.enabled) return;
+    this.queue.push({
+      conversationId,
+      content,
+      message_type: messageType,
+      attachments,
+      timestamp: Date.now()
+    });
+    this.save();
+  }
+  drain() {
+    const items = [...this.queue];
+    this.queue = [];
+    this.save();
+    return items;
+  }
+  get size() {
+    return this.queue.length;
+  }
+  save() {
+    try {
+      if (typeof localStorage !== "undefined") {
+        localStorage.setItem(STORAGE_KEY, JSON.stringify(this.queue));
+      }
+    } catch {
+    }
+  }
+  load() {
+    try {
+      if (typeof localStorage !== "undefined") {
+        const stored = localStorage.getItem(STORAGE_KEY);
+        if (stored) {
+          this.queue = JSON.parse(stored);
+        }
+      }
+    } catch {
+      this.queue = [];
+    }
+  }
+};
+
+// src/transport/HttpTransport.ts
+var HttpTransport = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.apiKey = config.apiKey;
+    this.getToken = config.getToken;
+    this.timeout = config.timeout ?? DEFAULT_REQUEST_TIMEOUT;
+  }
+  async get(path) {
+    return this.request("GET", path);
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  async patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  async del(path) {
+    return this.request("DELETE", path);
+  }
+  async request(method, path, body) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.apiKey) {
+      headers["x-api-key"] = this.apiKey;
+    }
+    if (this.getToken) {
+      const token = await this.getToken();
+      if (token) {
+        headers["Authorization"] = `Bearer ${token}`;
+      }
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}${path}`, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal,
+        credentials: "include"
+      });
+      clearTimeout(timeoutId);
+      if (response.status === 204) {
+        return { data: null, error: null };
+      }
+      const json = await response.json().catch(() => null);
+      if (!response.ok) {
+        const error = {
+          code: json?.error?.code ?? json?.code ?? "unknown",
+          message: json?.error?.message ?? json?.message ?? response.statusText,
+          status: response.status,
+          details: json?.error?.details ?? json?.details
+        };
+        return { data: null, error };
+      }
+      const data = json?.data !== void 0 ? json.data : json;
+      return { data, error: null };
+    } catch (err) {
+      clearTimeout(timeoutId);
+      const message = err instanceof Error ? err.message : "Network error";
+      return {
+        data: null,
+        error: { code: "network_error", message, status: 0 }
+      };
+    }
+  }
+};
+
+// src/transport/WebSocketTransport.ts
+var WebSocketTransport = class extends EventEmitter {
+  constructor(config) {
+    super();
+    this.ws = null;
+    this.status = "disconnected";
+    this.subscriptions = /* @__PURE__ */ new Set();
+    this.presenceChannels = /* @__PURE__ */ new Map();
+    this.reconnectAttempt = 0;
+    this.reconnectTimer = null;
+    this.heartbeatTimer = null;
+    this.config = config;
+    this.maxRetries = config.reconnect?.maxRetries ?? DEFAULT_WS_RECONNECT_MAX_RETRIES;
+    this.baseDelay = config.reconnect?.baseDelay ?? DEFAULT_WS_RECONNECT_BASE_DELAY;
+    this.maxDelay = config.reconnect?.maxDelay ?? DEFAULT_WS_RECONNECT_MAX_DELAY;
+    const baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.ticketUrl = `${baseUrl}/v1/realtime/ws/ticket`;
+    this.wsBaseUrl = baseUrl.replace(/^http/, "ws") + "/v1/realtime/ws";
+  }
+  getStatus() {
+    return this.status;
+  }
+  async connect() {
+    if (this.status === "connected" || this.status === "connecting") return;
+    this.setStatus("connecting");
+    try {
+      const ticket = await this.obtainTicket();
+      if (!ticket) {
+        this.setStatus("disconnected");
+        this.emit("error", { message: "Failed to obtain WS ticket" });
+        return;
+      }
+      const wsUrl = `${this.wsBaseUrl}?ticket=${encodeURIComponent(ticket)}`;
+      this.ws = new WebSocket(wsUrl);
+      this.ws.onopen = () => {
+        this.setStatus("connected");
+        this.reconnectAttempt = 0;
+        this.startHeartbeat();
+        this.resubscribeAll();
+      };
+      this.ws.onmessage = (event) => {
+        this.handleMessage(event.data);
+      };
+      this.ws.onclose = () => {
+        this.stopHeartbeat();
+        if (this.status !== "disconnected") {
+          this.scheduleReconnect();
+        }
+      };
+      this.ws.onerror = () => {
+      };
+    } catch {
+      this.setStatus("disconnected");
+      this.scheduleReconnect();
+    }
+  }
+  disconnect() {
+    this.setStatus("disconnected");
+    this.stopHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.onclose = null;
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  subscribe(channel) {
+    this.subscriptions.add(channel);
+    if (this.status === "connected") {
+      this.send({ type: "subscribe", channel });
+    } else if (this.status === "disconnected") {
+      this.connect();
+    }
+    return () => this.unsubscribe(channel);
+  }
+  unsubscribe(channel) {
+    this.subscriptions.delete(channel);
+    if (this.status === "connected") {
+      this.send({ type: "unsubscribe", channel });
+    }
+  }
+  publish(channel, data) {
+    if (this.status === "connected") {
+      this.send({ type: "publish", channel, data });
+    }
+  }
+  joinPresence(channel, userData) {
+    this.presenceChannels.set(channel, userData);
+    if (this.status === "connected") {
+      this.send({ type: "presence_join", channel, user_data: userData ?? {} });
+    }
+  }
+  leavePresence(channel) {
+    this.presenceChannels.delete(channel);
+    if (this.status === "connected") {
+      this.send({ type: "presence_leave", channel });
+    }
+  }
+  async obtainTicket() {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.config.apiKey) {
+      headers["x-api-key"] = this.config.apiKey;
+    }
+    if (this.config.getToken) {
+      const token = await this.config.getToken();
+      if (token) {
+        headers["Authorization"] = `Bearer ${token}`;
+      }
+    }
+    try {
+      const response = await fetch(this.ticketUrl, {
+        method: "POST",
+        headers,
+        credentials: "include"
+      });
+      if (!response.ok) return null;
+      const json = await response.json();
+      return json.ticket ?? json.data?.ticket ?? null;
+    } catch {
+      return null;
+    }
+  }
+  send(data) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(data));
+    }
+  }
+  handleMessage(raw) {
+    if (raw === "pong") return;
+    try {
+      const msg = JSON.parse(raw);
+      switch (msg.type) {
+        case "auth_success":
+          break;
+        case "subscribed":
+          break;
+        case "message":
+          this.emit("message", { channel: msg.channel, data: msg.data });
+          break;
+        case "presence_state":
+          this.emit("presence:state", { channel: msg.channel, members: msg.members ?? [] });
+          break;
+        case "presence_join":
+          this.emit("presence:join", { channel: msg.channel, user: msg.user });
+          break;
+        case "presence_leave":
+          this.emit("presence:leave", { channel: msg.channel, userId: msg.user_id });
+          break;
+        case "presence_update":
+          this.emit("presence:update", {
+            channel: msg.channel,
+            userId: msg.user_id,
+            status: msg.status,
+            userData: msg.user_data
+          });
+          break;
+        case "error":
+          this.emit("error", { message: msg.message ?? "Unknown error" });
+          break;
+        case "token_expiring":
+          this.reconnectAttempt = 0;
+          this.scheduleReconnect();
+          break;
+      }
+    } catch {
+    }
+  }
+  resubscribeAll() {
+    for (const channel of this.subscriptions) {
+      this.send({ type: "subscribe", channel });
+    }
+    for (const [channel, userData] of this.presenceChannels) {
+      this.send({ type: "presence_join", channel, user_data: userData ?? {} });
+    }
+  }
+  startHeartbeat() {
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send("ping");
+      }
+    }, DEFAULT_WS_HEARTBEAT_INTERVAL);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempt >= this.maxRetries) {
+      this.setStatus("disconnected");
+      return;
+    }
+    this.setStatus("reconnecting");
+    this.emit("reconnecting", { attempt: this.reconnectAttempt + 1 });
+    const delay = Math.min(
+      this.baseDelay * Math.pow(2, this.reconnectAttempt) + Math.random() * this.baseDelay * 0.3,
+      this.maxDelay
+    );
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectAttempt++;
+      this.connect();
+    }, delay);
+  }
+  setStatus(status) {
+    if (this.status !== status) {
+      this.status = status;
+      this.emit("status", status);
+    }
+  }
+};
+
+// src/core/ChatClient.ts
+var ChatClient = class extends EventEmitter {
+  constructor(config) {
+    super();
+    this.conversationSubs = /* @__PURE__ */ new Map();
+    this.conversationTypes = /* @__PURE__ */ new Map();
+    const baseUrl = config.apiBaseUrl ?? DEFAULT_API_BASE_URL;
+    this.http = new HttpTransport({
+      baseUrl,
+      apiKey: config.apiKey,
+      getToken: config.getToken ?? (config.sessionToken ? () => Promise.resolve(config.sessionToken) : void 0)
+    });
+    this.ws = new WebSocketTransport({
+      baseUrl,
+      apiKey: config.apiKey,
+      getToken: config.getToken ?? (config.sessionToken ? () => Promise.resolve(config.sessionToken) : void 0),
+      reconnect: config.reconnect
+    });
+    this.cache = new MessageCache(
+      config.messageCache?.maxMessages,
+      config.messageCache?.maxConversations
+    );
+    this.offlineQueue = new OfflineQueue(config.offlineQueue ?? true);
+    this.ws.on("status", (status) => {
+      switch (status) {
+        case "connected":
+          this.emit("connected");
+          this.flushOfflineQueue();
+          break;
+        case "disconnected":
+          this.emit("disconnected");
+          break;
+      }
+    });
+    this.ws.on("reconnecting", (data) => {
+      this.emit("reconnecting", data);
+    });
+    this.ws.on("message", ({ channel, data }) => {
+      this.handleRealtimeMessage(channel, data);
+    });
+    this.ws.on("presence:state", ({ channel, members }) => {
+      const conversationId = channel.replace(/^conversation:(?:lr:|bc:)?/, "");
+      this.emit("presence:state", { conversationId, members });
+    });
+    this.ws.on("presence:join", ({ channel, user }) => {
+      const conversationId = channel.replace(/^conversation:(?:lr:|bc:)?/, "");
+      this.emit("presence:join", { userId: user.user_id, conversationId, userData: user.user_data });
+    });
+    this.ws.on("presence:leave", ({ channel, userId }) => {
+      const conversationId = channel.replace(/^conversation:(?:lr:|bc:)?/, "");
+      this.emit("presence:leave", { userId, conversationId });
+    });
+    this.ws.on("presence:update", ({ channel, userId, status, userData }) => {
+      const conversationId = channel.replace(/^conversation:(?:lr:|bc:)?/, "");
+      this.emit("presence:update", { userId, conversationId, status, userData });
+    });
+    this.ws.on("error", ({ message }) => {
+      this.emit("error", { code: "ws_error", message });
+    });
+  }
+  // ============ Connection ============
+  get status() {
+    return this.ws.getStatus();
+  }
+  connect() {
+    this.ws.connect();
+  }
+  disconnect() {
+    for (const unsub of this.conversationSubs.values()) {
+      unsub();
+    }
+    this.conversationSubs.clear();
+    this.ws.disconnect();
+  }
+  // ============ Conversations ============
+  async createConversation(options) {
+    const result = await this.http.post("/v1/chat/conversations", options);
+    if (result.data) this.trackConversationType(result.data);
+    return result;
+  }
+  async listConversations(options) {
+    const params = new URLSearchParams();
+    if (options?.page) params.set("page", String(options.page));
+    if (options?.per_page) params.set("per_page", String(options.per_page));
+    const qs = params.toString();
+    const result = await this.http.get(`/v1/chat/conversations${qs ? "?" + qs : ""}`);
+    if (result.data) result.data.forEach((c) => this.trackConversationType(c));
+    return result;
+  }
+  async getConversation(id) {
+    const result = await this.http.get(`/v1/chat/conversations/${id}`);
+    if (result.data) this.trackConversationType(result.data);
+    return result;
+  }
+  trackConversationType(conversation) {
+    if (conversation.conversation_type !== "direct" && conversation.conversation_type !== "group") {
+      this.conversationTypes.set(conversation.id, conversation.conversation_type);
+    }
+  }
+  // ============ Messages ============
+  async sendMessage(conversationId, options) {
+    const result = await this.http.post(
+      `/v1/chat/conversations/${conversationId}/messages`,
+      {
+        content: options.content,
+        message_type: options.message_type ?? "text",
+        attachments: options.attachments
+      }
+    );
+    if (result.data) {
+      this.cache.addMessage(conversationId, result.data);
+    } else if (result.error?.status === 0) {
+      this.offlineQueue.enqueue(conversationId, options.content, options.message_type ?? "text");
+    }
+    return result;
+  }
+  async getMessages(conversationId, options) {
+    const params = new URLSearchParams();
+    if (options?.limit) params.set("limit", String(options.limit));
+    if (options?.before) params.set("before", options.before);
+    if (options?.after) params.set("after", options.after);
+    const qs = params.toString();
+    const result = await this.http.get(
+      `/v1/chat/conversations/${conversationId}/messages${qs ? "?" + qs : ""}`
+    );
+    if (result.data?.messages) {
+      if (!options?.before && !options?.after) {
+        this.cache.setMessages(conversationId, result.data.messages);
+      }
+    }
+    return result;
+  }
+  async editMessage(messageId, content) {
+    return this.http.patch(`/v1/chat/messages/${messageId}`, { content });
+  }
+  async deleteMessage(messageId) {
+    return this.http.del(`/v1/chat/messages/${messageId}`);
+  }
+  getCachedMessages(conversationId) {
+    return this.cache.getMessages(conversationId);
+  }
+  // ============ Reactions ============
+  async addReaction(messageId, emoji) {
+    return this.http.post(`/v1/chat/messages/${messageId}/reactions`, { emoji });
+  }
+  // ============ Typing & Read Receipts ============
+  async sendTyping(conversationId, isTyping = true) {
+    await this.http.post(`/v1/chat/conversations/${conversationId}/typing`, { is_typing: isTyping });
+  }
+  async markRead(conversationId) {
+    await this.http.post(`/v1/chat/conversations/${conversationId}/read`);
+  }
+  async getReadStatus(conversationId) {
+    return this.http.get(`/v1/chat/conversations/${conversationId}/read-status`);
+  }
+  // ============ Participants ============
+  async addParticipant(conversationId, userId) {
+    return this.http.post(`/v1/chat/conversations/${conversationId}/participants`, {
+      user_id: userId
+    });
+  }
+  async removeParticipant(conversationId, userId) {
+    return this.http.del(`/v1/chat/conversations/${conversationId}/participants/${userId}`);
+  }
+  // ============ Presence ============
+  joinPresence(conversationId, userData) {
+    const channel = this.channelName(conversationId);
+    this.ws.joinPresence(channel, userData);
+  }
+  leavePresence(conversationId) {
+    const channel = this.channelName(conversationId);
+    this.ws.leavePresence(channel);
+  }
+  /** Update presence status (online/away/dnd) without leaving the channel. */
+  updatePresence(conversationId, status, userData) {
+    const channel = this.channelName(conversationId);
+    this.ws.send({ type: "presence_update", channel, status, user_data: userData });
+  }
+  // ============ Channel Types ============
+  async getChannelSettings(channelId) {
+    return this.http.get(`/v1/chat/channels/${channelId}/settings`);
+  }
+  /**
+   * Set the conversation type for channel name routing.
+   * Large rooms use `conversation:lr:` prefix to skip MySQL in the realtime service.
+   */
+  setConversationType(conversationId, type) {
+    this.conversationTypes.set(conversationId, type);
+  }
+  // ============ Realtime Subscriptions ============
+  subscribeToConversation(conversationId) {
+    if (this.conversationSubs.has(conversationId)) {
+      return this.conversationSubs.get(conversationId);
+    }
+    const channel = this.channelName(conversationId);
+    const unsub = this.ws.subscribe(channel);
+    this.conversationSubs.set(conversationId, unsub);
+    return () => {
+      this.conversationSubs.delete(conversationId);
+      unsub();
+    };
+  }
+  /** Build channel name with correct prefix based on conversation type. */
+  channelName(conversationId) {
+    const type = this.conversationTypes.get(conversationId);
+    switch (type) {
+      case "large_room":
+        return `conversation:lr:${conversationId}`;
+      case "broadcast":
+        return `conversation:bc:${conversationId}`;
+      default:
+        return `conversation:${conversationId}`;
+    }
+  }
+  // ============ Cleanup ============
+  destroy() {
+    this.disconnect();
+    this.cache.clear();
+    this.removeAllListeners();
+  }
+  // ============ Private ============
+  handleRealtimeMessage(channel, data) {
+    if (!channel.startsWith("conversation:")) return;
+    const conversationId = channel.replace(/^conversation:(?:lr:|bc:)?/, "");
+    const raw = data;
+    if (!raw) return;
+    const event = raw.event ?? raw.type;
+    const payload = raw.data ?? raw;
+    switch (event) {
+      case "new_message": {
+        const message = payload;
+        this.cache.addMessage(conversationId, message);
+        this.emit("message", { message, conversationId });
+        break;
+      }
+      case "message_edited": {
+        const message = payload;
+        this.cache.updateMessage(conversationId, message);
+        this.emit("message:updated", { message, conversationId });
+        break;
+      }
+      case "message_deleted": {
+        const messageId = payload.message_id ?? payload.id;
+        if (messageId) {
+          this.cache.removeMessage(conversationId, messageId);
+          this.emit("message:deleted", { messageId, conversationId });
+        }
+        break;
+      }
+      case "user_typing": {
+        const userId = payload.user_id;
+        if (userId) {
+          this.emit("typing", { userId, conversationId });
+        }
+        break;
+      }
+      case "user_stopped_typing": {
+        const userId = payload.user_id;
+        if (userId) {
+          this.emit("typing:stop", { userId, conversationId });
+        }
+        break;
+      }
+      case "typing_batch": {
+        const users = payload.users ?? [];
+        for (const userId of users) {
+          this.emit("typing", { userId, conversationId });
+        }
+        break;
+      }
+      case "messages_read": {
+        const userId = payload.user_id;
+        const lastReadAt = payload.last_read_at;
+        if (userId && lastReadAt) {
+          this.emit("read", { userId, conversationId, lastReadAt });
+        }
+        break;
+      }
+    }
+  }
+  async flushOfflineQueue() {
+    const queued = this.offlineQueue.drain();
+    for (const item of queued) {
+      await this.sendMessage(item.conversationId, {
+        content: item.content,
+        message_type: item.message_type
+      });
+    }
+  }
+};
+
+exports.ChatClient = ChatClient;