@clonegod/ttd-core 2.0.69 → 2.0.71

package/dist/ws/ws_client.d.ts

@@ -1,13 +1,10 @@
 export interface WebSocketClientOptions {
-    reconnectInterval?: number;
-    maxReconnectAttempts?: number;
     headers?: {
         [key: string]: string;
     };
-    protocols?: string | string[];
-    handshakeTimeout?: number;
-    perMessageDeflate?: boolean | object;
-    timeout?: number;
+    reconnectInterval?: number;
+    maxReconnectAttempts?: number;
+    rejectUnauthorized?: boolean;
     keepAlive?: boolean;
     keepAliveInterval?: number;
 }
@@ -15,28 +12,19 @@ export declare class WebSocketClient {
     private url;
     private options;
     private ws;
-    private reconnectInterval;
     private onMessageCallback;
     private onOpenCallback;
-    private onCloseCallback;
-    private onErrorCallback;
     private reconnectAttempts;
     private maxReconnectAttempts;
-    private isReconnecting;
     private keepAliveTimer;
     constructor(url: string, options?: WebSocketClientOptions);
-    private setDefaultOptions;
     connect(): void;
     onMessage(callback: (data: any) => void): void;
     onOpen(callback: () => void): void;
-    onClose(callback: () => void): void;
-    onError(callback: (error: Error) => void): void;
-    send(data: any): boolean;
+    send(data_obj: string): boolean;
     disconnect(): void;
     private handleReconnect;
     isConnected(): boolean;
-    getConnectionState(): string;
-    resetReconnectAttempts(): void;
     private startKeepAlive;
     private stopKeepAlive;
 }

package/dist/ws/ws_client.js

@@ -4,53 +4,27 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebSocketClient = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
 const ws_1 = __importDefault(require("ws"));
-const __1 = require("..");
 class WebSocketClient {
     constructor(url, options = {}) {
         this.ws = null;
         this.onMessageCallback = null;
         this.onOpenCallback = null;
-        this.onCloseCallback = null;
-        this.onErrorCallback = null;
         this.reconnectAttempts = 0;
         this.maxReconnectAttempts = 10;
-        this.isReconnecting = false;
         this.keepAliveTimer = null;
         this.url = url;
-        this.options = this.setDefaultOptions(options);
-        this.reconnectInterval = this.options.reconnectInterval;
+        this.options = Object.assign({ reconnectInterval: 3000, maxReconnectAttempts: 10, rejectUnauthorized: false, keepAlive: false, keepAliveInterval: 30000 }, options);
         this.maxReconnectAttempts = this.options.maxReconnectAttempts;
-        (0, __1.log_info)(`WebSocketClient constructor, url: ${this.url}`, this.options);
-    }
-    setDefaultOptions(options) {
-        const defaults = {
-            reconnectInterval: 3000,
-            maxReconnectAttempts: 10,
-            keepAlive: true,
-            keepAliveInterval: 30000,
-            handshakeTimeout: 10000,
-            perMessageDeflate: true,
-            timeout: 5000,
-        };
-        return Object.assign(Object.assign({}, defaults), options);
+        (0, dist_1.log_info)(`WebSocketClient constructor, url: ${this.url}`, this.options);
     }
     connect() {
-        if (this.isReconnecting) {
-            return;
-        }
-        const wsOptions = {
-            headers: this.options.headers,
-            protocols: this.options.protocols,
-            handshakeTimeout: this.options.handshakeTimeout,
-            perMessageDeflate: this.options.perMessageDeflate
-        };
-        (0, __1.log_info)(`Connecting to ${this.url} with options:`, wsOptions);
-        this.ws = new ws_1.default(this.url, wsOptions);
+        (0, dist_1.log_info)(`Connecting to ${this.url}`);
+        this.ws = new ws_1.default(this.url, { headers: this.options.headers });
         this.ws.on('open', () => {
-            console.log(`Connected to ${this.url}`);
+            (0, dist_1.log_info)('ws connected');
             this.reconnectAttempts = 0;
-            this.isReconnecting = false;
             this.startKeepAlive();
             if (this.onOpenCallback)
                 this.onOpenCallback();
@@ -62,19 +36,16 @@ class WebSocketClient {
                     this.onMessageCallback(data);
             }
             catch (err) {
-                console.error('Invalid message format:', err);
+                (0, dist_1.log_error)('Invalid message format:', err);
             }
         });
         this.ws.on('close', (code, reason) => {
-            console.log(`Disconnected from server: ${code} - ${reason.toString()}`);
-            if (this.onCloseCallback)
-                this.onCloseCallback();
+            (0, dist_1.log_warn)(`ws disconnected: ${code} - ${reason.toString()}`);
             this.handleReconnect();
         });
         this.ws.on('error', (err) => {
-            console.error('WebSocket error:', err);
-            if (this.onErrorCallback)
-                this.onErrorCallback(err);
+            (0, dist_1.log_error)('ws error:', err);
+            this.handleReconnect();
         });
     }
     onMessage(callback) {
@@ -83,24 +54,17 @@ class WebSocketClient {
     onOpen(callback) {
         this.onOpenCallback = callback;
     }
-    onClose(callback) {
-        this.onCloseCallback = callback;
-    }
-    onError(callback) {
-        this.onErrorCallback = callback;
-    }
-    send(data) {
+    send(data_obj) {
         if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
-            this.ws.send(JSON.stringify(data));
+            this.ws.send(JSON.stringify(data_obj));
             return true;
         }
         else {
-            console.error('WebSocket is not connected');
+            (0, dist_1.log_warn)('ws is not connected, you need connect first, then send message');
             return false;
         }
     }
     disconnect() {
-        this.isReconnecting = false;
         this.stopKeepAlive();
         if (this.ws) {
             this.ws.close();
@@ -108,55 +72,30 @@ class WebSocketClient {
         }
     }
     handleReconnect() {
-        if (this.isReconnecting) {
-            return;
-        }
         if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-            (0, __1.log_info)(`Max reconnection attempts (${this.maxReconnectAttempts}) reached`);
+            (0, dist_1.log_warn)(`Max reconnection attempts (${this.maxReconnectAttempts}) reached`);
             return;
         }
-        this.isReconnecting = true;
         this.reconnectAttempts++;
-        (0, __1.log_info)(`Scheduling reconnect in ${this.reconnectInterval}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+        (0, dist_1.log_warn)(`Reconnecting in ${this.options.reconnectInterval}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
         setTimeout(() => {
-            (0, __1.log_info)(`Attempting to reconnect to ${this.url}... (${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
             this.connect();
-        }, this.reconnectInterval);
+        }, this.options.reconnectInterval);
     }
     isConnected() {
         return this.ws !== null && this.ws.readyState === ws_1.default.OPEN;
     }
-    getConnectionState() {
-        if (!this.ws)
-            return 'DISCONNECTED';
-        switch (this.ws.readyState) {
-            case ws_1.default.CONNECTING:
-                return 'CONNECTING';
-            case ws_1.default.OPEN:
-                return 'OPEN';
-            case ws_1.default.CLOSING:
-                return 'CLOSING';
-            case ws_1.default.CLOSED:
-                return 'CLOSED';
-            default:
-                return 'UNKNOWN';
-        }
-    }
-    resetReconnectAttempts() {
-        this.reconnectAttempts = 0;
-        this.isReconnecting = false;
-    }
     startKeepAlive() {
         if (!this.options.keepAlive) {
-            (0, __1.log_info)('KeepAlive disabled');
             return;
         }
-        const interval = this.options.keepAliveInterval;
-        (0, __1.log_info)(`Starting keepAlive with interval: ${interval}ms`);
+        this.stopKeepAlive();
+        const interval = this.options.keepAliveInterval || 30000;
+        (0, dist_1.log_info)(`Starting keepAlive with interval: ${interval}ms`);
         this.keepAliveTimer = setInterval(() => {
             if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
                 this.ws.ping();
-                (0, __1.log_info)('KeepAlive ping sent');
+                (0, dist_1.log_info)('KeepAlive ping sent');
             }
         }, interval);
     }
@@ -164,6 +103,7 @@ class WebSocketClient {
         if (this.keepAliveTimer) {
             clearInterval(this.keepAliveTimer);
             this.keepAliveTimer = null;
+            (0, dist_1.log_info)('KeepAlive stopped');
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clonegod/ttd-core",
-    "version": "2.0.69",
+    "version": "2.0.71",
     "description": "Common types and utilities for trading systems - use `npm run push` to publish",
     "main": "dist/index.js",
     "types": "types/index.d.ts",