mezon-light-sdk 1.0.2 → 1.0.3

package/dist/socket.gen.js

@@ -0,0 +1,327 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultSocket = exports.ConnectionState = void 0;
+const utils_1 = require("./utils");
+const web_socket_adapter_pb_1 = require("./web_socket_adapter_pb");
+/** A socket connection to Mezon server implemented with the DOM's WebSocket API. */
+let __hasConnectedOnce = false;
+exports.ConnectionState = {
+    DISCONNECTED: "disconnected",
+    CONNECTING: "connecting",
+    CONNECTED: "connected",
+};
+class DefaultSocket {
+    constructor(host, port, useSSL = false, verbose = false, adapter = new web_socket_adapter_pb_1.WebSocketAdapterPb(), sendTimeoutMs = DefaultSocket.DefaultSendTimeoutMs) {
+        this.host = host;
+        this.port = port;
+        this.useSSL = useSSL;
+        this.verbose = verbose;
+        this.adapter = adapter;
+        this.sendTimeoutMs = sendTimeoutMs;
+        this.cIds = {};
+        this.nextCid = 1;
+        this._heartbeatTimeoutMs = DefaultSocket.DefaultHeartbeatTimeoutMs;
+        this._connectionState = exports.ConnectionState.DISCONNECTED;
+    }
+    generatecid() {
+        const cid = this.nextCid.toString();
+        ++this.nextCid;
+        return cid;
+    }
+    isOpen() {
+        return this._connectionState === exports.ConnectionState.CONNECTED;
+    }
+    connect(session, createStatus = false, platform = "", connectTimeoutMs = DefaultSocket.DefaultConnectTimeoutMs, signal) {
+        if (this._connectionState === exports.ConnectionState.CONNECTED) {
+            return Promise.resolve(session);
+        }
+        if (this._connectionState === exports.ConnectionState.CONNECTING && this._connectPromise) {
+            return this._connectPromise;
+        }
+        this.clearConnectTimeout();
+        this._connectionState = exports.ConnectionState.CONNECTING;
+        const scheme = this.useSSL ? "wss://" : "ws://";
+        this.adapter.connect(scheme, this.host, this.port, createStatus, session.token, platform, signal);
+        this.adapter.onClose = (evt) => {
+            this._connectionState = exports.ConnectionState.DISCONNECTED;
+            this.stopHeartbeatLoop();
+            this.clearConnectTimeout();
+            this.ondisconnect(evt);
+        };
+        this.adapter.onMessage = async (message) => {
+            if (this.verbose && window && window.console) {
+                console.log("Response: %o", JSON.stringify(message));
+            }
+            /** Inbound message from server. */
+            if (!message.cid) {
+                if (message.channel_message) {
+                    const channelMessage = createChannelMessageFromEvent(message);
+                    this.onchannelmessage(channelMessage);
+                }
+                else {
+                    if (this.verbose && window && window.console) {
+                        console.log("Unrecognized message received: %o", message);
+                    }
+                }
+            }
+            else {
+                const executor = this.cIds[message.cid];
+                if (!executor) {
+                    if (this.verbose && window && window.console) {
+                        console.error("No promise executor for message: %o", message);
+                    }
+                    return;
+                }
+                delete this.cIds[message.cid];
+                if (message.error) {
+                    executor.reject(message.error);
+                }
+                else {
+                    executor.resolve(message);
+                }
+            }
+        };
+        const connectPromise = new Promise((resolve, reject) => {
+            this.adapter.onOpen = (evt) => {
+                if (this.verbose && window && window.console) {
+                    console.log(evt);
+                }
+                const isReconnect = __hasConnectedOnce;
+                __hasConnectedOnce = true;
+                this.clearConnectTimeout();
+                this._connectionState = exports.ConnectionState.CONNECTED;
+                this.startHeartbeatLoop();
+                this._connectPromise = undefined;
+                resolve(session);
+                if (isReconnect) {
+                    this.onreconnect(evt);
+                }
+            };
+            this.adapter.onError = (evt) => {
+                this._connectionState = exports.ConnectionState.DISCONNECTED;
+                this.stopHeartbeatLoop();
+                this.clearConnectTimeout();
+                this.onerror(evt);
+                this._connectPromise = undefined;
+                this.adapter.close();
+                reject(evt);
+            };
+            this._connectTimeoutTimer = setTimeout(() => {
+                // if promise has resolved by now, the reject() is a no-op
+                this._connectionState = exports.ConnectionState.DISCONNECTED;
+                this.stopHeartbeatLoop();
+                this.adapter.close();
+                this._connectPromise = undefined;
+                reject("The socket timed out when trying to connect.");
+                this._connectTimeoutTimer = undefined;
+            }, connectTimeoutMs);
+        });
+        this._connectPromise = connectPromise;
+        return this._connectPromise;
+    }
+    disconnect(fireDisconnectEvent = true) {
+        this._connectionState = exports.ConnectionState.DISCONNECTED;
+        this.stopHeartbeatLoop();
+        if (this.adapter.isOpen()) {
+            this.adapter.close();
+        }
+        if (fireDisconnectEvent) {
+            this.ondisconnect({});
+        }
+    }
+    setHeartbeatTimeoutMs(ms) {
+        this._heartbeatTimeoutMs = ms;
+    }
+    getHeartbeatTimeoutMs() {
+        return this._heartbeatTimeoutMs;
+    }
+    onreconnect(evt) {
+        if (this.verbose && window && window.console) {
+            console.log(evt);
+        }
+    }
+    ondisconnect(evt) {
+        if (this.verbose && window && window.console) {
+            console.log(evt);
+        }
+    }
+    onerror(evt) {
+        this._connectionState = exports.ConnectionState.DISCONNECTED;
+        this.stopHeartbeatLoop();
+        if (this.verbose && window && window.console) {
+            console.log(evt);
+        }
+    }
+    onheartbeattimeout() {
+        if (this.verbose && window && window.console) {
+            console.log("Heartbeat timeout.");
+        }
+    }
+    onchannelmessage(channelMessage) {
+        if (this.verbose && window && window.console) {
+            console.log(channelMessage);
+        }
+    }
+    // onuserchanneladded(user: UserChannelAddedEvent) {
+    //   if (this.verbose && window && window.console) {
+    //     console.log(user);
+    //   }
+    // }
+    send(message, sendTimeout = DefaultSocket.DefaultSendTimeoutMs) {
+        const untypedMessage = message;
+        return new Promise((resolve, reject) => {
+            if (!this.adapter.isOpen()) {
+                reject("Socket connection has not been established yet.");
+            }
+            else {
+                if (untypedMessage.channel_message_send) {
+                    untypedMessage.channel_message_send.content = JSON.stringify(untypedMessage.channel_message_send.content);
+                }
+                else if (untypedMessage.channel_message_update) {
+                    untypedMessage.channel_message_update.content = JSON.stringify(untypedMessage.channel_message_update.content);
+                }
+                else if (untypedMessage.ephemeral_message_send) {
+                    untypedMessage.ephemeral_message_send.message.content = JSON.stringify(untypedMessage.ephemeral_message_send.message?.content);
+                }
+                else if (untypedMessage.quick_menu_event) {
+                    untypedMessage.quick_menu_event.message.content = JSON.stringify(untypedMessage.quick_menu_event.message?.content);
+                }
+                const cid = this.generatecid();
+                this.cIds[cid] = { resolve, reject };
+                if (sendTimeout !== Infinity && sendTimeout > 0) {
+                    setTimeout(() => {
+                        reject("The socket timed out while waiting for a response.");
+                    }, sendTimeout);
+                }
+                untypedMessage.cid = cid;
+                this.adapter.send(untypedMessage);
+            }
+        });
+    }
+    async joinChat(clan_id, channel_id, channel_type, is_public) {
+        const response = await this.send({
+            channel_join: {
+                clan_id: clan_id,
+                channel_id: channel_id,
+                channel_type: channel_type,
+                is_public: is_public,
+            },
+        });
+        return response.channel;
+    }
+    async leaveChat(clan_id, channel_id, channel_type, is_public) {
+        return this.send({
+            channel_leave: {
+                clan_id: clan_id,
+                channel_id: channel_id,
+                channel_type: channel_type,
+                is_public: is_public,
+            },
+        });
+    }
+    async writeChatMessage(clan_id, channel_id, mode, is_public, content, attachments, anonymous_message, mention_everyone, avatar, code, topic_id) {
+        const response = await this.send({
+            channel_message_send: {
+                clan_id: clan_id,
+                channel_id: channel_id,
+                mode: mode,
+                is_public: is_public,
+                content: content,
+                reactions: [],
+                mentions: [],
+                attachments: attachments,
+                references: [],
+                anonymous_message: anonymous_message,
+                mention_everyone: mention_everyone,
+                avatar: avatar,
+                code: code,
+                topic_id: topic_id,
+            },
+        }, Infinity);
+        return response.channel_message_ack;
+    }
+    async pingPong() {
+        if (!this.isOpen()) {
+            this._connectionState = exports.ConnectionState.DISCONNECTED;
+            this.stopHeartbeatLoop();
+            return;
+        }
+        try {
+            await this.send({ ping: {} }, this._heartbeatTimeoutMs);
+        }
+        catch {
+            this._connectionState = exports.ConnectionState.DISCONNECTED;
+            this.stopHeartbeatLoop();
+            if (this.adapter.isOpen()) {
+                if (window && window.console) {
+                    console.error("Server unreachable from heartbeat.");
+                }
+                this.onheartbeattimeout();
+                this.adapter.close();
+            }
+            return;
+        }
+        this.startHeartbeatLoop();
+    }
+    startHeartbeatLoop() {
+        this.stopHeartbeatLoop();
+        this._heartbeatTimer = setTimeout(() => this.pingPong(), this._heartbeatTimeoutMs);
+    }
+    stopHeartbeatLoop() {
+        if (this._heartbeatTimer !== undefined) {
+            clearTimeout(this._heartbeatTimer);
+            this._heartbeatTimer = undefined;
+        }
+    }
+    clearConnectTimeout() {
+        if (this._connectTimeoutTimer !== undefined) {
+            clearTimeout(this._connectTimeoutTimer);
+            this._connectTimeoutTimer = undefined;
+        }
+    }
+}
+exports.DefaultSocket = DefaultSocket;
+DefaultSocket.DefaultHeartbeatTimeoutMs = 10000;
+DefaultSocket.DefaultSendTimeoutMs = 10000;
+DefaultSocket.DefaultConnectTimeoutMs = 30000;
+function createChannelMessageFromEvent(message) {
+    var content, attachments;
+    try {
+        content = (0, utils_1.safeJSONParse)(message.channel_message.content);
+    }
+    catch (e) {
+        console.log("content is invalid", e);
+    }
+    try {
+        attachments = (0, utils_1.decodeAttachments)(message.channel_message.attachments);
+    }
+    catch (e) {
+        console.log("attachments is invalid", e);
+    }
+    var e = {
+        id: message.id || message.channel_message.message_id,
+        avatar: message.channel_message.avatar,
+        channel_id: message.channel_message.channel_id,
+        mode: message.channel_message.mode,
+        channel_label: message.channel_message.channel_label,
+        clan_id: message.channel_message.clan_id,
+        code: message.channel_message.code,
+        message_id: message.channel_message.message_id,
+        sender_id: message.channel_message.sender_id,
+        update_time: message.channel_message.update_time,
+        clan_logo: message.channel_message.clan_logo,
+        category_name: message.channel_message.category_name,
+        username: message.channel_message.username,
+        clan_nick: message.channel_message.clan_nick,
+        clan_avatar: message.channel_message.clan_avatar,
+        display_name: message.channel_message.display_name,
+        content: content,
+        attachments: attachments?.attachments,
+        hide_editted: message.channel_message.hide_editted,
+        is_public: message.channel_message.is_public,
+        create_time_seconds: message.channel_message.create_time_seconds,
+        update_time_seconds: message.channel_message.update_time_seconds,
+        topic_id: message.channel_message.topic_id,
+    };
+    return e;
+}

package/dist/socket.js

@@ -1,65 +1,249 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LightSocket = void 0;
-const mezon_js_protobuf_1 = require("mezon-js-protobuf");
-const mezon_js_1 = require("mezon-js");
+exports.LightSocket = exports.SocketError = void 0;
+const web_socket_adapter_pb_1 = require("./web_socket_adapter_pb");
 const constants_1 = require("./constants");
+/**
+ * Error thrown when socket operations fail.
+ */
+class SocketError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SocketError";
+    }
+}
+exports.SocketError = SocketError;
+/**
+ * Maps raw socket message data to a ChannelMessage interface.
+ */
+function mapToChannelMessage(message) {
+    return {
+        ...message,
+        clan_id: String(message.clan_id ?? ""),
+        channel_id: String(message.channel_id ?? ""),
+        message_id: String(message.message_id ?? ""),
+        sender_id: String(message.sender_id ?? ""),
+        content: String(message.content ?? ""),
+        // reactions: [],
+        // mentions: [],
+        // attachments: Array.isArray(message.attachments) ? message.attachments : [],
+        // references: Array.isArray(message.references) ? message.references : [],
+        create_time_seconds: Number(message.create_time_seconds ?? 0),
+        update_time_seconds: Number(message.update_time_seconds ?? 0),
+        hide_editted: Boolean(message.hide_editted),
+    };
+}
+/**
+ * Waits for a socket to be in a ready state with exponential backoff.
+ *
+ * @param socket - The socket to wait for
+ * @param maxRetries - Maximum number of retry attempts
+ * @param initialDelay - Initial delay in milliseconds
+ * @throws {SocketError} If socket doesn't become ready within retry limit
+ */
+async function waitForSocketReady(socket, maxRetries = constants_1.SOCKET_READY_MAX_RETRY, initialDelay = constants_1.SOCKET_READY_RETRY_DELAY) {
+    let retryCount = 0;
+    let delay = initialDelay;
+    // Type assertion to access internal adapter
+    const socketWithAdapter = socket;
+    while (retryCount < maxRetries) {
+        if (socketWithAdapter.adapter?.isOpen()) {
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        delay *= 2; // Exponential backoff
+        retryCount++;
+    }
+    throw new SocketError(`Socket failed to connect after ${maxRetries} attempts (total wait: ~${Math.pow(2, maxRetries) * initialDelay}ms)`);
+}
+/**
+ * LightSocket provides a simplified interface for Mezon real-time messaging.
+ *
+ * @example
+ * ```typescript
+ * const socket = new LightSocket(client.client, client.session);
+ *
+ * await socket.connect({
+ *   onError: (err) => console.error('Socket error:', err),
+ *   onDisconnect: () => console.log('Disconnected')
+ * });
+ *
+ * socket.onChannelMessage((msg) => {
+ *   console.log('Received message:', msg.content);
+ * });
+ *
+ * await socket.joinDMChannel('channel-123');
+ * await socket.sendDM({ channelId: 'channel-123', content: 'Hello!' });
+ * ```
+ */
 class LightSocket {
-    constructor(client, session) {
-        this.client = client;
-        this.session = session;
+    constructor(_client, _session) {
+        this._client = _client;
+        this._session = _session;
+        this._socket = null;
+        this._isConnected = false;
+        this._messageHandlers = [];
     }
-    async connect(onError) {
-        this.socket = this.client.createSocket(this.client.useSSL, false, new mezon_js_protobuf_1.WebSocketAdapterPb());
-        this.socket.onerror = onError || (() => { });
-        await this.socket.connect(this.session, true, "0");
+    /**
+     * Gets whether the socket is currently connected.
+     */
+    get isConnected() {
+        return this._isConnected;
     }
-    setChannelMessageHandler(cb) {
-        this.socket.onchannelmessage = (msg) => {
-            if (msg && msg.error) {
-                if (this.onError)
-                    this.onError(msg.error);
+    /**
+     * Gets the underlying socket instance.
+     * @throws {SocketError} If socket is not connected
+     */
+    get socket() {
+        if (!this._socket) {
+            throw new SocketError("Socket is not connected. Call connect() first.");
+        }
+        return this._socket;
+    }
+    /**
+     * Connects to the Mezon real-time server.
+     *
+     * @param options - Connection options including error handlers
+     * @throws {SocketError} If already connected or connection fails
+     */
+    async connect(options = {}) {
+        if (this._isConnected) {
+            throw new SocketError("Socket is already connected. Call disconnect() first.");
+        }
+        const { onError, onDisconnect, verbose = false } = options;
+        this._errorHandler = onError;
+        this._disconnectHandler = onDisconnect;
+        this._socket = this._client.createSocket(verbose, new web_socket_adapter_pb_1.WebSocketAdapterPb());
+        // Set up error handler
+        this._socket.onerror = (error) => {
+            this._errorHandler?.(error);
+        };
+        // Set up disconnect handler
+        this._socket.ondisconnect = () => {
+            this._isConnected = false;
+            this._disconnectHandler?.();
+        };
+        // Set up message handler that dispatches to all registered handlers
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this._socket.onchannelmessage = (channelMessage) => {
+            if (!channelMessage) {
+                this._errorHandler?.(new SocketError("Received null or undefined channel message"));
                 return;
             }
-            cb({
-                clan_id: msg.clan_id,
-                channel_id: msg.channel_id,
-                message_id: msg.message_id || msg.id,
-                code: msg.code,
-                sender_id: msg.sender_id,
-                username: msg.username,
-                avatar: msg.avatar,
-                content: msg.content,
-                create_time: msg.create_time,
-                update_time: msg.update_time,
-                display_name: msg.display_name,
-                mentions: msg.mentions || [],
-                attachments: msg.attachments || [],
-                references: msg.references || [],
-                create_time_seconds: msg.create_time_seconds,
-                update_time_seconds: msg.update_time_seconds,
-                hide_editted: msg.hide_editted,
+            this._messageHandlers.forEach((handler) => {
+                try {
+                    handler(channelMessage);
+                }
+                catch (error) {
+                    console.error("Error in message handler:", error);
+                }
             });
         };
+        await this._socket.connect(this._session, true, "0");
+        this._isConnected = true;
+    }
+    /**
+     * Disconnects from the Mezon server.
+     */
+    disconnect() {
+        if (this._socket) {
+            this._socket.disconnect(true);
+            this._socket = null;
+            this._isConnected = false;
+        }
+    }
+    /**
+     * Registers a handler for incoming channel messages.
+     * Multiple handlers can be registered and will all receive messages.
+     *
+     * @param handler - Callback function to handle messages
+     */
+    setChannelMessageHandler(cb) {
+        this.onChannelMessage(cb);
+    }
+    /**
+     * Registers a handler for incoming channel messages.
+     * Multiple handlers can be registered and will all receive messages.
+     *
+     * @param handler - Callback function to handle messages
+     * @returns A function to unsubscribe the handler
+     */
+    onChannelMessage(handler) {
+        this._messageHandlers.push(handler);
+        // Return unsubscribe function
+        return () => {
+            const index = this._messageHandlers.indexOf(handler);
+            if (index !== -1) {
+                this._messageHandlers.splice(index, 1);
+            }
+        };
+    }
+    /**
+    * Joins a DM channel to receive messages from it.
+    *
+    * @param channelId - The DM channel ID to join
+    * @throws {SocketError} If socket is not ready or join fails
+    */
+    async joinDMChannel(channelId) {
+        await waitForSocketReady(this.socket);
+        await this.socket.joinChat(constants_1.CLAN_DM, channelId, constants_1.CHANNEL_TYPE_DM, false);
     }
-    async joinDMChannel(channel_id) {
+    /**
+     * Joins a group channel to receive messages from it.
+     *
+     * @param channelId - The group channel ID to join
+     * @throws {SocketError} If socket is not ready or join fails
+     */
+    async joinGroupChannel(channelId) {
         await waitForSocketReady(this.socket);
-        await this.socket.joinChat(constants_1.CLAN_DM, channel_id, mezon_js_1.ChannelType.CHANNEL_TYPE_DM, false);
+        await this.socket.joinChat(constants_1.CLAN_DM, channelId, constants_1.CHANNEL_TYPE_GROUP, false);
     }
-    async sendDM(channelId, content, attachments = []) {
-        this.socket.writeChatMessage(constants_1.CLAN_DM, channelId, mezon_js_1.ChannelStreamMode.STREAM_MODE_DM, false, content, attachments, [], [], false, false, "", 0);
+    /**
+     * Leaves a DM channel.
+     *
+     * @param channelId - The DM channel ID to leave
+     */
+    async leaveDMChannel(channelId) {
+        await this.socket.leaveChat(constants_1.CLAN_DM, channelId, constants_1.CHANNEL_TYPE_DM, false);
+    }
+    /**
+     * Leaves a group channel.
+     *
+     * @param channelId - The group channel ID to leave
+     */
+    async leaveGroupChannel(channelId) {
+        await this.socket.leaveChat(constants_1.CLAN_DM, channelId, constants_1.CHANNEL_TYPE_GROUP, false);
+    }
+    /**
+     * Sends a direct message to a channel.
+     *
+     * @param options - Message options including channelId, content, and attachments
+     */
+    async sendDM(payload) {
+        const { channelId, content, attachments, hideLink = false } = payload;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        await this.socket.writeChatMessage(constants_1.CLAN_DM, channelId, constants_1.STREAM_MODE_DM, false, content, attachments, false, hideLink, "", 0);
+    }
+    /**
+     * Sends a direct message to a channel.
+     *
+     * @param options - Message options including channelId, content, and attachments
+     */
+    async sendGroup(payload) {
+        const { channelId, content, attachments, hideLink = false } = payload;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        await this.socket.writeChatMessage(constants_1.CLAN_DM, channelId, constants_1.STREAM_MODE_GROUP, false, content, attachments, false, hideLink, "", 0);
+    }
+    /**
+     * Sets the error handler for socket errors.
+     *
+     * @param handler - Error handler callback
+     */
+    setErrorHandler(handler) {
+        this._errorHandler = handler;
+        if (this._socket) {
+            this._socket.onerror = handler;
+        }
     }
 }
 exports.LightSocket = LightSocket;
-async function waitForSocketReady(socket) {
-    let count = 0;
-    let delay = constants_1.SOCKET_READY_RETRY_DELAY;
-    while (!(socket.adapter && socket.adapter.isOpen()) &&
-        count < constants_1.SOCKET_READY_MAX_RETRY) {
-        await new Promise((r) => setTimeout(r, delay));
-        delay *= 2;
-        count++;
-    }
-    if (!(socket.adapter && socket.adapter.isOpen()))
-        throw new Error("Socket not open");
-}

package/dist/types.d.ts

@@ -0,0 +1,44 @@
+import { ApiMessageAttachment } from "./api.gen";
+/**
+ * Configuration for initializing a LightClient from existing tokens.
+ */
+export interface ClientInitConfig {
+    /** Authentication token */
+    token: string;
+    /** Refresh token for session renewal */
+    refresh_token: string;
+    /** API URL for the Mezon server */
+    api_url: string;
+    /** User ID associated with the session */
+    user_id: string;
+    /** Server key for authentication (optional, uses default if not provided) */
+    serverkey?: string;
+}
+/**
+ * Configuration for authenticating a new user.
+ */
+export interface AuthenticateConfig {
+    /** ID token from identity provider */
+    id_token: string;
+    /** User ID to associate with the account */
+    user_id: string;
+    /** Username for the account */
+    username: string;
+    /** Server key for authentication (optional, uses default if not provided) */
+    serverkey?: string;
+    /** Custom gateway URL (optional, uses default if not provided) */
+    gateway_url?: string;
+}
+/**
+ * Options for sending a message.
+ */
+export interface SendMessagePayload {
+    /** The channel ID to send the message to */
+    channelId: string;
+    /** Message content */
+    content: unknown;
+    /** File/media attachments (optional) */
+    attachments?: ApiMessageAttachment[];
+    /** Whether to hide link previews (optional) */
+    hideLink?: boolean;
+}

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function buildFetchOptions(method: string, options: any, bodyJson: string): any;
+export declare function safeJSONParse(raw: any): any;
+export declare function decodeAttachments(data: any): any;