kucoin-universal-sdk/dist/internal/infra/default_ws_token_provider.js

Official KuCoin Universal SDK.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DefaultWsTokenProvider = exports.TokenResponseImpl = void 0;
const PATH_PRIVATE = '/api/v1/bullet-private';
const PATH_PUBLIC = '/api/v1/bullet-public';
/**
 * Implementation of TokenResponse with validation and serialization methods
 */
class TokenResponseImpl {
    constructor(data) {
        if (data) {
            this.commonResponse = data.commonResponse;
            this.token = data.token;
            this.instanceServers = data.instanceServers;
        }
    }
    /**
     * Sets the common response for the token response
     * @param response - RestResponse object to set
     */
    setCommonResponse(response) {
        this.commonResponse = response;
    }
    /**
     * Creates a TokenResponse instance from a JSON string
     * @param jsonStr - JSON string to parse
     * @returns TokenResponseImpl instance or null if parsing fails
     */
    static fromJSON(jsonStr) {
        try {
            return TokenResponseImpl.fromDict(JSON.parse(jsonStr));
        }
        catch {
            return null;
        }
    }
    /**
     * Creates a TokenResponse instance from a dictionary object
     * @param obj - Object to convert to TokenResponse
     * @returns TokenResponseImpl instance or null if conversion fails
     */
    static fromDict(obj) {
        if (!obj)
            return null;
        return new TokenResponseImpl({
            token: obj.token,
            instanceServers: Array.isArray(obj.instanceServers)
                ? obj.instanceServers.map((item) => ({
                    token: item.token || '',
                    pingInterval: item.pingInterval || 0,
                    endpoint: item.endpoint || '',
                    protocol: item.protocol || '',
                    encrypt: item.encrypt || false,
                    pingTimeout: item.pingTimeout || 0,
                }))
                : undefined,
        });
    }
    fromJson(input) {
        const jsonObject = JSON.parse(input);
        return this.fromObject(jsonObject);
    }
    toJson() {
        return JSON.stringify({
            token: this.token,
            instanceServers: this.instanceServers,
        });
    }
    fromObject(jsonObject) {
        const data = jsonObject;
        return new TokenResponseImpl(data);
    }
}
exports.TokenResponseImpl = TokenResponseImpl;
/**
 * Default implementation of the WebSocket token provider
 * Handles token retrieval and management for WebSocket connections
 */
class DefaultWsTokenProvider {
    constructor(transport, domain, isPrivate) {
        this.transport = transport;
        this.domain = domain;
        this.isPrivate = isPrivate;
    }
    /**
     * Retrieves WebSocket tokens from the server
     * @returns Promise resolving to array of WsToken objects
     * @throws Error if token retrieval fails
     */
    async getToken() {
        const path = this.isPrivate ? PATH_PRIVATE : PATH_PUBLIC;
        try {
            const response = new TokenResponseImpl();
            const result = (await this.transport.call(this.domain, false, 'POST', path, null, response, false));
            if (result.instanceServers && result.token) {
                // Assign token to each instance server
                const token = result.token;
                result.instanceServers.forEach((server) => {
                    server.token = token;
                });
                return result.instanceServers;
            }
            return [];
        }
        catch (error) {
            throw error;
        }
    }
    /**
     * Closes the token provider and its associated transport
     * @returns A promise that resolves when the transport is closed
     */
    async close() {
        this.transport.close();
    }
}
exports.DefaultWsTokenProvider = DefaultWsTokenProvider;
//# sourceMappingURL=default_ws_token_provider.js.map