mezon-light-sdk 1.0.2 → 1.0.3

package/dist/session.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Copyright 2022 The Mezon Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/** A session authenticated for a user with Mezon server. */
+export interface ISession {
+    /** Claims */
+    /** The authorization token used to construct this session. */
+    token: string;
+    /** If the user account for this session was just created. */
+    created: boolean;
+    /** The UNIX timestamp when this session was created. */
+    readonly created_at: number;
+    /** The UNIX timestamp when this session will expire. */
+    expires_at?: number;
+    /** The UNIX timestamp when the refresh token will expire. */
+    refresh_expires_at?: number;
+    /** Refresh token that can be used for session token renewal. */
+    refresh_token: string;
+    /** The username of the user who owns this session. */
+    username?: string;
+    /** The ID of the user who owns this session. */
+    user_id?: string;
+    /** Any custom properties associated with this session. */
+    vars?: object;
+    /** Validate token */
+    /** If the session has expired. */
+    isexpired(currenttime: number): boolean;
+    /** If the refresh token has expired. */
+    isrefreshexpired(currenttime: number): boolean;
+}
+export declare class Session implements ISession {
+    readonly created: boolean;
+    readonly api_url: string;
+    readonly id_token: string;
+    token: string;
+    readonly created_at: number;
+    expires_at?: number;
+    refresh_expires_at?: number;
+    refresh_token: string;
+    username?: string;
+    user_id?: string;
+    vars?: {
+        [key: string]: any;
+    };
+    is_remember?: boolean;
+    constructor(token: string, refresh_token: string, created: boolean, api_url: string, id_token: string, is_remember: boolean);
+    isexpired(currenttime: number): boolean;
+    isrefreshexpired(currenttime: number): boolean;
+    update(token: string, refreshToken: string, isRemember: boolean): void;
+    static restore(token: string, refreshToken: string, api_url: string, isRemember: boolean): Session;
+}

package/dist/session.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * Copyright 2022 The Mezon Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Session = void 0;
+const base64 = __importStar(require("js-base64"));
+class Session {
+    constructor(token, refresh_token, created, api_url, id_token, is_remember) {
+        this.created = created;
+        this.api_url = api_url;
+        this.id_token = id_token;
+        this.token = token;
+        this.refresh_token = refresh_token;
+        this.id_token = id_token;
+        this.api_url = api_url;
+        this.created_at = Math.floor(new Date().getTime() / 1000);
+        this.is_remember = is_remember;
+        this.update(token, refresh_token, is_remember);
+    }
+    isexpired(currenttime) {
+        return this.expires_at - currenttime <= 0; // expired
+    }
+    isrefreshexpired(currenttime) {
+        return this.refresh_expires_at - currenttime <= 0;
+    }
+    update(token, refreshToken, isRemember) {
+        const tokenParts = token.split(".");
+        if (tokenParts.length != 3) {
+            throw "jwt is not valid.";
+        }
+        const tokenDecoded = JSON.parse(base64.atob(tokenParts[1]));
+        const tokenExpiresAt = Math.floor(parseInt(tokenDecoded["exp"]));
+        /** clients that have just updated to the refresh tokens */
+        /** client release will not have a cached refresh token */
+        if (refreshToken) {
+            const refreshTokenParts = refreshToken.split(".");
+            if (refreshTokenParts.length != 3) {
+                throw "refresh jwt is not valid.";
+            }
+            const refreshTokenDecoded = JSON.parse(base64.atob(refreshTokenParts[1]));
+            const refreshTokenExpiresAt = Math.floor(parseInt(refreshTokenDecoded["exp"]));
+            this.refresh_expires_at = refreshTokenExpiresAt;
+            this.refresh_token = refreshToken;
+            this.is_remember = isRemember;
+        }
+        this.token = token;
+        this.expires_at = tokenExpiresAt;
+        this.username = tokenDecoded["usn"];
+        this.user_id = tokenDecoded["uid"];
+        this.vars = tokenDecoded["vrs"];
+    }
+    static restore(token, refreshToken, api_url, isRemember) {
+        return new Session(token, refreshToken, false, api_url, "", isRemember);
+    }
+}
+exports.Session = Session;

package/dist/socket.d.ts

@@ -1,13 +1,135 @@
-import { Client, Session } from "mezon-js";
-import { ChannelMessage } from "./message";
+import { SendMessagePayload } from "./types";
+import { LightClient } from "./client";
+import { Socket } from "./socket.gen";
+import { Session } from "./session";
+import { ChannelMessage } from "./api.gen";
+/**
+ * Error thrown when socket operations fail.
+ */
+export declare class SocketError extends Error {
+    constructor(message: string);
+}
+/**
+ * Configuration options for socket connection.
+ */
+export interface SocketConnectOptions {
+    /** Callback for socket errors */
+    onError?: (error: unknown) => void;
+    /** Callback when socket disconnects */
+    onDisconnect?: () => void;
+    /** Whether to enable verbose logging */
+    verbose?: boolean;
+}
+/**
+ * Callback type for channel message events.
+ */
+export type ChannelMessageHandler = (message: ChannelMessage) => void;
+/**
+ * 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!' });
+ * ```
+ */
 export declare class LightSocket {
-    private client;
-    private session;
-    private socket;
-    onError?: (err: any) => void;
-    constructor(client: Client, session: Session);
-    connect(onError?: (err: any) => void): Promise<void>;
-    setChannelMessageHandler(cb: (msg: ChannelMessage) => void): void;
-    joinDMChannel(channel_id: string): Promise<void>;
-    sendDM(channelId: string, content: any, attachments?: any[]): Promise<void>;
+    private readonly _client;
+    private readonly _session;
+    private _socket;
+    private _isConnected;
+    private _messageHandlers;
+    private _errorHandler?;
+    private _disconnectHandler?;
+    constructor(_client: LightClient, _session: Session);
+    /**
+     * Gets whether the socket is currently connected.
+     */
+    get isConnected(): boolean;
+    /**
+     * Gets the underlying socket instance.
+     * @throws {SocketError} If socket is not connected
+     */
+    get socket(): Socket;
+    /**
+     * Connects to the Mezon real-time server.
+     *
+     * @param options - Connection options including error handlers
+     * @throws {SocketError} If already connected or connection fails
+     */
+    connect(options?: SocketConnectOptions): Promise<void>;
+    /**
+     * Disconnects from the Mezon server.
+     */
+    disconnect(): void;
+    /**
+     * 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: ChannelMessageHandler): void;
+    /**
+     * 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: ChannelMessageHandler): () => void;
+    /**
+    * 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
+    */
+    joinDMChannel(channelId: string): Promise<void>;
+    /**
+     * 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
+     */
+    joinGroupChannel(channelId: string): Promise<void>;
+    /**
+     * Leaves a DM channel.
+     *
+     * @param channelId - The DM channel ID to leave
+     */
+    leaveDMChannel(channelId: string): Promise<void>;
+    /**
+     * Leaves a group channel.
+     *
+     * @param channelId - The group channel ID to leave
+     */
+    leaveGroupChannel(channelId: string): Promise<void>;
+    /**
+     * Sends a direct message to a channel.
+     *
+     * @param options - Message options including channelId, content, and attachments
+     */
+    sendDM(payload: SendMessagePayload): Promise<void>;
+    /**
+     * Sends a direct message to a channel.
+     *
+     * @param options - Message options including channelId, content, and attachments
+     */
+    sendGroup(payload: SendMessagePayload): Promise<void>;
+    /**
+     * Sets the error handler for socket errors.
+     *
+     * @param handler - Error handler callback
+     */
+    setErrorHandler(handler: (error: unknown) => void): void;
 }

package/dist/socket.gen.d.ts

@@ -0,0 +1,136 @@
+import { Channel, ChannelMessageAck } from "./proto/realtime";
+import { WebSocketAdapter } from "./web_socket_adapter_pb";
+import { Session } from "./session";
+import { ApiMessageAttachment, ChannelMessage } from "./api.gen";
+/** A socket connection to Mezon server. */
+export interface Socket {
+    /** Connection is Open */
+    isOpen(): boolean;
+    /** Connect to the server. */
+    connect(session: Session, createStatus: boolean, platform: string, connectTimeoutMs?: number, signal?: AbortSignal): Promise<Session>;
+    /** Disconnect from the server. */
+    disconnect(fireDisconnectEvent: boolean): void;
+    /** Join a chat channel on the server. */
+    joinChat(clan_id: string, channel_id: string, channel_type: number, is_public: boolean): Promise<Channel>;
+    /** Leave a chat channel on the server. */
+    leaveChat(clan_id: string, channel_id: string, channel_type: number, is_public: boolean): Promise<void>;
+    /** Send a chat message to a chat channel on the server. */
+    writeChatMessage(clan_id: string, channel_id: string, mode: number, is_public: boolean, content?: any, attachments?: Array<ApiMessageAttachment>, anonymous_message?: boolean, mention_everyone?: boolean, avatar?: string, code?: number, topic_id?: string, id?: string): Promise<ChannelMessageAck>;
+    setHeartbeatTimeoutMs(ms: number): void;
+    getHeartbeatTimeoutMs(): number;
+    onreconnect: (evt: Event) => void;
+    /** Handle disconnect events received from the socket. */
+    ondisconnect: (evt: Event) => void;
+    /** Handle error events received from the socket. */
+    onerror: (evt: Event) => void;
+    /**
+     * An application-level heartbeat timeout that fires after the client does not receive a pong from the server after the heartbeat interval.
+     * Most browsers maintain an internal heartbeat, in which case its unlikely you'll need to use this callback. However, Chrome does not implement an internal heartbeat.
+     * We fire this separately from `onclose` because heartbeats fail when there's no connectivity, and many browsers don't fire `onclose` until the closing handshake either succeeds or fails.
+     * In any case, be aware that `onclose` will still fire if there is a heartbeat timeout in a potentially delayed manner.
+     */
+    onheartbeattimeout: () => void;
+    /** Receive channel message. */
+    onchannelmessage: (channelMessage: ChannelMessage) => void;
+}
+/** Represents an error returned from the socket. */
+export interface SocketError {
+    /** The error code. */
+    code: number;
+    /** A message in English to help developers debug the response. */
+    message: string;
+}
+export declare const ConnectionState: {
+    readonly DISCONNECTED: "disconnected";
+    readonly CONNECTING: "connecting";
+    readonly CONNECTED: "connected";
+};
+export type ConnectionStateType = (typeof ConnectionState)[keyof typeof ConnectionState];
+/** Application-level heartbeat ping. */
+interface Ping {
+}
+/** Send a message to a realtime chat channel. */
+interface ChannelMessageSend {
+    channel_message_send: {
+        /** Clan Id */
+        clan_id: string;
+        /** The server-assigned channel ID. */
+        channel_id: string;
+        mode: number;
+        channel_label: string;
+        /** The content payload. */
+        content: any;
+        attachments?: Array<ApiMessageAttachment>;
+        anonymous_message?: boolean;
+        mention_everyone?: boolean;
+        avatar: string;
+        is_public: boolean;
+        code: number;
+        topic_id?: string;
+    };
+}
+/** Join a realtime chat channel. */
+interface ChannelJoin {
+    channel_join: {
+        /** The id of the channel to join. */
+        channel_id: string;
+        /** The name of the channel to join. */
+        channel_label: string;
+        /** The channel type: 1 = Channel, 2 = Direct Message, 3 = Group. */
+        type: number;
+        /** Whether channel messages are persisted in the database. */
+        persistence: boolean;
+        /** Whether the user's channel presence is hidden when joining. */
+        hidden: boolean;
+        is_public: boolean;
+    };
+}
+/** Leave a realtime chat channel. */
+interface ChannelLeave {
+    channel_leave: {
+        /** The id of the channel to leave. */
+        channel_id: string;
+        mode: number;
+        channel_label: string;
+        is_public: boolean;
+    };
+}
+export declare class DefaultSocket implements Socket {
+    readonly host: string;
+    readonly port: string;
+    readonly useSSL: boolean;
+    verbose: boolean;
+    readonly adapter: WebSocketAdapter;
+    readonly sendTimeoutMs: number;
+    static readonly DefaultHeartbeatTimeoutMs = 10000;
+    static readonly DefaultSendTimeoutMs = 10000;
+    static readonly DefaultConnectTimeoutMs = 30000;
+    private readonly cIds;
+    private nextCid;
+    private _heartbeatTimeoutMs;
+    private _connectionState;
+    private _heartbeatTimer?;
+    private _connectTimeoutTimer?;
+    private _connectPromise?;
+    constructor(host: string, port: string, useSSL?: boolean, verbose?: boolean, adapter?: WebSocketAdapter, sendTimeoutMs?: number);
+    generatecid(): string;
+    isOpen(): boolean;
+    connect(session: Session, createStatus?: boolean, platform?: string, connectTimeoutMs?: number, signal?: AbortSignal): Promise<Session>;
+    disconnect(fireDisconnectEvent?: boolean): void;
+    setHeartbeatTimeoutMs(ms: number): void;
+    getHeartbeatTimeoutMs(): number;
+    onreconnect(evt: Event): void;
+    ondisconnect(evt: Event): void;
+    onerror(evt: Event): void;
+    onheartbeattimeout(): void;
+    onchannelmessage(channelMessage: ChannelMessage): void;
+    send(message: ChannelJoin | ChannelLeave | ChannelMessageSend | Ping, sendTimeout?: number): Promise<any>;
+    joinChat(clan_id: string, channel_id: string, channel_type: number, is_public: boolean): Promise<Channel>;
+    leaveChat(clan_id: string, channel_id: string, channel_type: number, is_public: boolean): Promise<void>;
+    writeChatMessage(clan_id: string, channel_id: string, mode: number, is_public: boolean, content: any, attachments?: Array<ApiMessageAttachment>, anonymous_message?: boolean, mention_everyone?: Boolean, avatar?: string, code?: number, topic_id?: string): Promise<ChannelMessageAck>;
+    private pingPong;
+    private startHeartbeatLoop;
+    private stopHeartbeatLoop;
+    private clearConnectTimeout;
+}
+export {};