@typexim/web-sdk 0.0.6 → 0.0.8-alpha.1

package/dist-test/modules/ChatSDK.js

@@ -0,0 +1,698 @@
+import { Bool, HttpClientResponseCode, MessageKind, MessageOperation, MessageType, RequestDirection, RESOURCE_AUTH_DOMAINS, } from '../enums/index.js';
+import { CHAT_SDK_EVENT } from '../events.js';
+import { getCurrentISOString } from '../utils/date.js';
+import { createErrorResponse, createOkResponse } from '../utils/http.js';
+import { appendQueryParam, createDomainUrlRegex, makePositions, parseCustomMessageContent, replaceDomainUrlsInContent, stringifyCustomMessageContent, } from '../utils/message.js';
+import Base from './Base.js';
+import BusinessWebsocket from './BusinessWebsocket.js';
+import FeedCache from './FeedCache.js';
+import HttpClient from './HttpClient.js';
+import Logger from './Logger.js';
+import PushMessageProcessor from './PushMessageProcessor.js';
+import Storage from './Storage.js';
+import TabSessionCoordinator from './TabSessionCoordinator.js';
+import Version from './Version.js';
+const LOGIN_SESSION_TRANSFER_TIMEOUT_MS = 500;
+export default class ChatSDK extends Base {
+    constructor(config) {
+        super();
+        Object.defineProperty(this, "context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "version", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tabSessionCoordinator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "restoreLoginPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "logger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "httpClient", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "feedCache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ws", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pushMessageProcessor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "handlePageHide", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: () => {
+                this.ws.disconnect();
+            }
+        });
+        Object.defineProperty(this, "handlePageShow", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (event) => {
+                // bfcache restore: open a fresh socket if still logged in.
+                if (event.persisted && this.context.isLogin) {
+                    this.ws.connect();
+                }
+            }
+        });
+        this.context = {
+            isLogin: false,
+            loginUser: null,
+            isReady: false,
+            deviceId: null,
+        };
+        this.version = new Version();
+        this.logger = new Logger();
+        this.restoreLoginPromise = null;
+        this.tabSessionCoordinator = new TabSessionCoordinator({
+            logger: this.logger,
+            getCurrentSession: () => this.getTransferableLoginSession(),
+            onLogoutBroadcast: () => {
+                this.afterLogout();
+            },
+            onLoginBroadcast: (session) => {
+                void this.applySharedLoginSession(session);
+            },
+        });
+        this.httpClient = new HttpClient({
+            host: config.httpHost,
+            context: this.context,
+            logger: this.logger,
+            developer: config.developer,
+        });
+        this.feedCache = new FeedCache();
+        this.ws = new BusinessWebsocket({
+            host: config.websocketHost,
+            context: this.context,
+            logger: this.logger,
+        });
+        this.pushMessageProcessor = new PushMessageProcessor({
+            context: this.context,
+            logger: this.logger,
+            emitter: this,
+            feedCache: this.feedCache,
+            onKickoff: () => {
+                this.afterLogout();
+            },
+        });
+        this.init();
+    }
+    init() {
+        this.loadContext();
+        this.ws.on('message', (message) => {
+            this.pushMessageProcessor.process(message);
+        });
+        this.ws.on('kickoff', () => {
+            this.afterLogout();
+        });
+        if (typeof window !== 'undefined') {
+            // Close the push socket on unload/refresh so the tab never leaves a stale connection.
+            window.addEventListener('pagehide', this.handlePageHide);
+            window.addEventListener('pageshow', this.handlePageShow);
+        }
+        setTimeout(() => {
+            void this.restoreLoginFromActiveTab();
+        }, 0);
+    }
+    getTransferableLoginSession() {
+        if (!this.context.isLogin || this.context.loginUser === null) {
+            return null;
+        }
+        return {
+            deviceId: this.context.deviceId,
+            loginUser: {
+                ...this.context.loginUser,
+            },
+        };
+    }
+    async restoreLoginFromActiveTab() {
+        if (this.restoreLoginPromise) {
+            return this.restoreLoginPromise;
+        }
+        this.restoreLoginPromise = this.doRestoreLoginFromActiveTab();
+        try {
+            return await this.restoreLoginPromise;
+        }
+        finally {
+            this.restoreLoginPromise = null;
+        }
+    }
+    async doRestoreLoginFromActiveTab() {
+        if (this.context.isLogin) {
+            return true;
+        }
+        const session = await this.tabSessionCoordinator.requestCurrentSession(LOGIN_SESSION_TRANSFER_TIMEOUT_MS);
+        if (!session || this.context.isLogin) {
+            return this.context.isLogin;
+        }
+        return this.applySharedLoginSession(session);
+    }
+    async applySharedLoginSession(session) {
+        if (this.context.isLogin) {
+            return true;
+        }
+        this.context.isLogin = true;
+        this.context.loginUser = session.loginUser;
+        if (session.deviceId) {
+            this.context.deviceId = session.deviceId;
+        }
+        // ws_route is derived from deviceId; ensure it exists before connecting.
+        await this.requestDeviceId();
+        this.applyLoginStatus();
+        return true;
+    }
+    async requestDeviceId() {
+        if (this.context.deviceId) {
+            return true;
+        }
+        const resp = await this.httpClient.post('/device_api/device_id', {
+            platform: 'web',
+            hash_str: '',
+        }, {
+            needSign: false,
+        });
+        if (!resp.ok) {
+            return false;
+        }
+        this.context.deviceId = resp.data;
+        this.saveContext();
+        return true;
+    }
+    saveContext() {
+        const { context } = this;
+        Storage.set({
+            deviceId: context.deviceId,
+        });
+    }
+    loadContext() {
+        const localData = Storage.get();
+        if (!localData || !localData.deviceId) {
+            return;
+        }
+        this.context.deviceId = localData.deviceId;
+    }
+    applyLoginStatus() {
+        this.version.increment();
+        this.saveContext();
+        if (this.context.isLogin) {
+            this.ws.connect();
+            this.loadFeedList();
+            this.context.isReady = true;
+            this.emit(CHAT_SDK_EVENT.SDK_READY);
+        }
+        else {
+            this.ws.disconnect();
+            this.feedCache.reset();
+            this.context.isReady = false;
+            this.emit(CHAT_SDK_EVENT.SDK_NOT_READY);
+        }
+    }
+    async loadFeedList() {
+        const version = this.version.get();
+        const last = {
+            refresh_at: null,
+            feed_id: null,
+        };
+        while (true) {
+            const res = await this.httpClient.get('/feed', {
+                limit: 500,
+                last_refresh_at: last.refresh_at ?? undefined,
+                last_feed_id: last.feed_id ?? undefined,
+            });
+            if (!this.version.check(version)) {
+                break;
+            }
+            // 当未查出数据时，res.data === null
+            if (res.ok && res.data !== null) {
+                last.refresh_at = res.data.refresh_at;
+                last.feed_id = res.data.last_feed_id;
+                (res.data.feed_list ?? []).forEach((feed) => {
+                    this.feedCache.push(feed);
+                });
+                if (!res.data.has_more) {
+                    break;
+                }
+            }
+            else {
+                break;
+            }
+        }
+        if (this.version.check(version)) {
+            this.feedCache.markSyncComplete();
+            this.emit(CHAT_SDK_EVENT.FEED_LIST_UPDATED, {
+                list: this.feedCache.getAll(),
+                is_sync_completed: true,
+            });
+        }
+    }
+    /**
+     * SDK 是否已就绪（登录成功且 WebSocket 已连接）。
+     * @returns {boolean} true 表示可用，false 表示未就绪
+     */
+    isReady() {
+        return this.context.isReady;
+    }
+    /**
+     * 设置 SDK 的日志级别。
+     * @param {LogLevel} level 要设置的日志级别
+     */
+    setLogLevel(level) {
+        this.logger.setLogLevel(level);
+    }
+    /**
+     * 使用user_code登录，建立会话并连接WebSocket，成功后会触发事件：SDK_READY
+     * @param req
+     * @returns
+     */
+    async login(req) {
+        if (this.context.isLogin) {
+            return createOkResponse(null);
+        }
+        const restored = await this.restoreLoginFromActiveTab();
+        if (restored || this.context.isLogin) {
+            return createOkResponse(null);
+        }
+        await this.requestDeviceId();
+        if (!this.context.deviceId) {
+            this.logger.error('Get deviceId failed');
+            return createErrorResponse(HttpClientResponseCode.SDK_ERROR, 'Get deviceId failed');
+        }
+        const resp = await this.httpClient.post('/user/session/login', {
+            userCode: req.user_code,
+            device_id: this.context.deviceId,
+        }, {
+            needSign: false,
+        });
+        if (!resp.ok) {
+            return resp;
+        }
+        this.context.isLogin = true;
+        this.context.loginUser = {
+            userId: resp.data.id,
+            secretKey: resp.data.key,
+            sessionId: req.user_code,
+        };
+        this.applyLoginStatus();
+        const transferableSession = this.getTransferableLoginSession();
+        if (transferableSession) {
+            // Notify already-open sibling tabs that were waiting without a session.
+            this.tabSessionCoordinator.publishLogin(transferableSession);
+        }
+        return createOkResponse(null);
+    }
+    /**
+     * 退出当前登录用户并断开WebSocket，成功后会触发事件：SDK_NOT_READY
+     * 注意，登出后user_code便会失效
+     * @returns
+     */
+    async logout() {
+        if (!this.context.isLogin) {
+            return createOkResponse(null);
+        }
+        const resp = await this.httpClient.get('/user/logout');
+        if (!resp.ok) {
+            return resp;
+        }
+        // Notify sibling tabs to clear local login state without calling logout again.
+        this.tabSessionCoordinator.publishLogout();
+        this.afterLogout();
+        return createOkResponse(null);
+    }
+    afterLogout() {
+        if (!this.context.isLogin && !this.context.isReady) {
+            return;
+        }
+        this.context.isLogin = false;
+        this.context.loginUser = null;
+        this.applyLoginStatus();
+    }
+    /**
+     * 获取当前登录用户的user_id
+     * @returns
+     */
+    getLoginUser() {
+        if (this.context.loginUser === null) {
+            return null;
+        }
+        return this.context.loginUser.userId;
+    }
+    /**
+     *  创建单聊feed，如果已创建就返回已创建的feed
+     * @param user_id
+     * @returns
+     */
+    async createSingleChatFeed(user_id) {
+        return await this.httpClient.post('/chat/single', {
+            receiver_id: user_id,
+        });
+    }
+    /**
+     * 删除指定feed
+     * @param feed_id
+     * @returns
+     */
+    async deleteFeed(feed_id) {
+        return await this.httpClient.post('/feed/delete', {
+            feed_id_list: [feed_id],
+            delete_peer: true,
+        });
+    }
+    /**
+     * 获取当前用户的 Feed 列表
+     * @returns
+     */
+    async getFeedList() {
+        return createOkResponse({
+            list: this.feedCache.getAll(),
+            is_sync_completed: this.feedCache.isSyncCompleted(),
+        });
+    }
+    /**
+     * 根据 Feed ID 获取详情
+     * @param feed_id
+     * @returns
+     */
+    async getFeedDetail(feed_id) {
+        const feed = await this.feedCache.waitFor(feed_id);
+        return createOkResponse(feed);
+    }
+    /**
+     * 根据 Feed ID 获取Feed的成员列表
+     * @param feed_id
+     * @returns
+     */
+    async getFeedMemberList(feed_id) {
+        const feed = await this.feedCache.get(feed_id);
+        if (feed !== null && feed.chat_member.length > 0) {
+            return await this.httpClient.post('/chat/chatter_info', {
+                chatters: {
+                    [feed.chat_id]: feed.chat_member,
+                },
+            });
+        }
+        return createOkResponse([]);
+    }
+    /**
+     * 根据 user_ids 或 uids 批量获取用户信息
+     * @param params
+     * @returns
+     */
+    async getUserByUids(params) {
+        const resp = await this.httpClient.post('/user/users_info', params);
+        if (!resp.ok) {
+            return resp;
+        }
+        return createOkResponse(resp.data.map((user) => ({ id: user.id })));
+    }
+    getDomain(messages) {
+        const [domain, testDomain] = RESOURCE_AUTH_DOMAINS;
+        const regex = createDomainUrlRegex(domain);
+        const testRegex = createDomainUrlRegex(testDomain);
+        for (const item of messages) {
+            if (regex.test(item.content)) {
+                return domain;
+            }
+            if (testRegex.test(item.content)) {
+                return testDomain;
+            }
+        }
+    }
+    /**
+     * 检测链接域名并为需要鉴权的域名添加x-sid参数
+     * @param messages
+     */
+    appendXsid(messages) {
+        if (!this.context.loginUser?.sessionId) {
+            return messages;
+        }
+        const sessionId = this.context.loginUser.sessionId;
+        const domain = this.getDomain(messages);
+        if (!domain) {
+            return messages;
+        }
+        return messages.map((item) => {
+            const content = replaceDomainUrlsInContent(item.content, domain, (url) => appendQueryParam(url, 'xsid', sessionId));
+            return {
+                ...item,
+                content,
+            };
+        });
+    }
+    /**
+     * 标记Feed的所有消息为已读
+     * @param feedId
+     * @returns
+     */
+    async markFeedMessageAsRead(feedId) {
+        const feed = this.feedCache.get(feedId);
+        if (!feed) {
+            return createOkResponse(false);
+        }
+        const resp = await this.httpClient.post('/feed/update', {
+            id: feed.id,
+            mark_unread: Bool.yes,
+        });
+        if (!resp.ok) {
+            return createOkResponse(false);
+        }
+        const res = await this.httpClient.post('/message/read', {
+            chat_id: feed.chat_id,
+            thread_id: feed.thread_id,
+        });
+        if (!res.ok) {
+            return createOkResponse(false);
+        }
+        return createOkResponse(true);
+    }
+    /**
+     * 获取Feed的消息
+     * @param feedId
+     * @param messageIds
+     * @returns
+     */
+    async getMessagesByIds(feedId, messageIds) {
+        const feed = this.feedCache.get(feedId);
+        if (!feed || !Array.isArray(messageIds) || messageIds.length === 0) {
+            return createOkResponse([]);
+        }
+        const res = await this.httpClient.post('/message/get_by_msgid', {
+            chat_msg_id_map: { [feed.chat_id]: messageIds },
+        });
+        if (res.ok) {
+            const list = this.appendXsid(res.data[feed.chat_id]);
+            return createOkResponse(list);
+        }
+        return createOkResponse([]);
+    }
+    /**
+     * 获取某个 Feed 的消息列表
+     * @param req
+     * @returns
+     */
+    async getFeedMessageList(req) {
+        const feedResp = await this.getFeedDetail(req.feed_id);
+        if (feedResp.ok && feedResp.data) {
+            const feed = feedResp.data;
+            const { chat_id, first_position, last_message_position } = feed;
+            const { positions, nextPosition, hasMore } = makePositions({
+                maxPosition: last_message_position,
+                minPosition: first_position,
+                startPosition: req.message_position,
+                limit: req.limit,
+                direction: req.direction ?? RequestDirection.up,
+            });
+            if (positions.length > 0) {
+                const res = await this.httpClient.post('/message/get_by_position', {
+                    chat_position: {
+                        [chat_id]: positions,
+                    },
+                }, {
+                    needSign: false,
+                });
+                if (res.ok && res.data[chat_id]) {
+                    // 因为结果是position倒序，所以要reverse
+                    const list = this.appendXsid(res.data[chat_id].reverse());
+                    // TODO将所有消息里的域名图片都拼接上x-sid
+                    return createOkResponse({
+                        has_more: hasMore,
+                        list: list,
+                        next_message_position: nextPosition,
+                    });
+                }
+            }
+        }
+        return createOkResponse({
+            has_more: false,
+            list: [],
+        });
+    }
+    /**
+     * 本地创建一条 Feed 自定义消息
+     * @param req
+     * @returns
+     */
+    createCustomMessage(req) {
+        if (this.context.loginUser === null) {
+            return createErrorResponse(HttpClientResponseCode.SDK_ERROR, 'not login');
+        }
+        const feed = this.feedCache.get(req.feed_id);
+        if (feed === null) {
+            return createErrorResponse(HttpClientResponseCode.SDK_ERROR, 'not found feed');
+        }
+        const currentIsoString = getCurrentISOString();
+        const message = {
+            id: '',
+            chat_id: feed.chat_id,
+            thread_id: feed.thread_id,
+            position: feed.last_message_position,
+            sender_id: this.context.loginUser.userId,
+            message_kind_id: MessageKind.text,
+            message_type_id: MessageType.custom,
+            send_at: currentIsoString,
+            edited_at: currentIsoString,
+            reader_ids: [],
+            unreader_ids: [],
+            hide_ids: [],
+            operation: MessageOperation.normal,
+            operation_user_id: '0',
+            content: stringifyCustomMessageContent({
+                client_msg_id: req.client_msg_id,
+                content: req.content,
+            }),
+            reactions: [],
+        };
+        return createOkResponse(message);
+    }
+    /**
+     * 发送一条消息到指定 Feed。
+     */
+    async sendMessageToFeed(message) {
+        if (message.message_type_id === MessageType.custom) {
+            const content = parseCustomMessageContent(message.content);
+            return this.httpClient.post('/message/send_custom', {
+                chat_id: message.chat_id,
+                thread_id: message.thread_id,
+                client_id: content.client_msg_id,
+                content: content.content == null ? undefined : JSON.stringify(content.content),
+            });
+        }
+        return createErrorResponse(HttpClientResponseCode.SDK_ERROR, 'not support');
+    }
+    /**
+     * 发送消息已读回执
+     * @param req
+     * @returns
+     */
+    async sendMessageReadReceipt(req) {
+        const feed = this.feedCache.get(req.feed_id);
+        if (feed === null) {
+            return createErrorResponse(HttpClientResponseCode.SDK_ERROR, 'not found feed');
+        }
+        return await this.httpClient.post('/message/read', {
+            chat_id: feed.chat_id,
+            message_ids: req.message_ids,
+        });
+    }
+    /**
+     * 加入直播间
+     * @param {string} room_id 直播间id
+     * @returns {Promise<HttpClientResponse>} 请求结果
+     */
+    async joinRoom(room_id) {
+        return await this.httpClient.post('/liveshow/join', {
+            room_id,
+        });
+    }
+    /**
+     * 设置 Feed 是否静言
+     * @param feedId Feed id
+     * @param isMute 是否静言
+     * @returns
+     */
+    async setMute(params) {
+        const res = await this.httpClient.post('/feed/update', {
+            id: params.feedId,
+            is_mute: params.isMute ? Bool.yes : Bool.no,
+        });
+        if (res.ok) {
+            return res.data;
+        }
+        return null;
+    }
+    /**
+     * 离开直播间
+     * @param {string} room_id 直播间id
+     * @returns {Promise<HttpClientResponse>} 请求结果
+     */
+    async leaveRoom(room_id) {
+        return await this.httpClient.post('/liveshow/leave', {
+            room_id,
+        });
+    }
+    /**
+     * 获取已加入的直播间
+     * @returns {Promise<HttpClientResponse>} 请求结果
+     */
+    async getJoinedRooms() {
+        return await this.httpClient.get('/liveshow/joined_rooms');
+    }
+    /**
+     * 获取直播间的最近50条消息
+     * @param room_id 直播间id
+     * @returns
+     */
+    async getRoomRecentMessageList(room_id) {
+        const resp = await this.httpClient.get('/liveshow/get_recent_message', {
+            room_id,
+        });
+        if (!resp.ok) {
+            return resp;
+        }
+        return createOkResponse(resp.data);
+    }
+    /**
+     * 向直播间发送一条消息。
+     * @param req
+     * @returns
+     */
+    async sendMessageToRoom(req) {
+        return await this.httpClient.post('/liveshow/send_message', {
+            room_id: req.room_id,
+            content: req.content,
+        });
+    }
+}