@adaptic/utils 0.0.380 → 0.0.382

package/dist/test.js

@@ -6153,7 +6153,7 @@ class AlpacaMarketDataAPI extends EventEmitter {
     cryptoWs = null;
     stockSubscriptions = { trades: [], quotes: [], bars: [] };
     optionSubscriptions = { trades: [], quotes: [], bars: [] };
-    cryptoSubscriptions = { trades: [], quotes: [], bars: [], dailyBars: [], updatedBars: [], orderbooks: [] };
+    cryptoSubscriptions = { trades: [], quotes: [], bars: [] };
     setMode(mode = 'production') {
         if (mode === 'sandbox') { // sandbox mode
             this.stockStreamUrl = 'wss://stream.data.sandbox.alpaca.markets/v2/sip';
@@ -6210,7 +6210,16 @@ class AlpacaMarketDataAPI extends EventEmitter {
         return super.emit(event, ...args);
     }
     connect(streamType) {
-        const url = streamType === 'stock' ? this.stockStreamUrl : streamType === 'option' ? this.optionStreamUrl : this.cryptoStreamUrl;
+        let url;
+        if (streamType === 'stock') {
+            url = this.stockStreamUrl;
+        }
+        else if (streamType === 'option') {
+            url = this.optionStreamUrl;
+        }
+        else {
+            url = this.cryptoStreamUrl;
+        }
         const ws = new WebSocket(url);
         if (streamType === 'stock') {
             this.stockWs = ws;
@@ -6231,20 +6240,36 @@ class AlpacaMarketDataAPI extends EventEmitter {
             ws.send(JSON.stringify(authMessage));
         });
         ws.on('message', (data) => {
-            //log(`RAW MESSASGE: ${data.toString()}`);
-            const messages = JSON.parse(data.toString());
+            const rawData = data.toString();
+            let messages;
+            try {
+                messages = JSON.parse(rawData);
+            }
+            catch (e) {
+                log$1(`${streamType} stream received invalid JSON: ${rawData.substring(0, 200)}`, { type: 'error' });
+                return;
+            }
             for (const message of messages) {
                 if (message.T === 'success' && message.msg === 'authenticated') {
                     log$1(`${streamType} stream authenticated`, { type: 'info' });
                     this.sendSubscription(streamType);
                 }
+                else if (message.T === 'success' && message.msg === 'connected') {
+                    log$1(`${streamType} stream connected message received`, { type: 'debug' });
+                }
+                else if (message.T === 'subscription') {
+                    log$1(`${streamType} subscription confirmed: trades=${message.trades?.length || 0}, quotes=${message.quotes?.length || 0}, bars=${message.bars?.length || 0}`, { type: 'info' });
+                }
                 else if (message.T === 'error') {
-                    log$1(`${streamType} stream error: ${message.msg}`, { type: 'error' });
+                    log$1(`${streamType} stream error: ${message.msg} (code: ${message.code}, raw: ${JSON.stringify(message)})`, { type: 'error' });
                 }
                 else if (message.S) {
                     super.emit(`${streamType}-${message.T}`, message);
                     super.emit(`${streamType}-data`, message);
                 }
+                else {
+                    log$1(`${streamType} received unknown message type: ${JSON.stringify(message)}`, { type: 'debug' });
+                }
             }
         });
         ws.on('close', () => {
@@ -6265,39 +6290,50 @@ class AlpacaMarketDataAPI extends EventEmitter {
         });
     }
     sendSubscription(streamType) {
-        const ws = streamType === 'stock' ? this.stockWs : streamType === 'option' ? this.optionWs : this.cryptoWs;
-        const subscriptions = streamType === 'stock' ? this.stockSubscriptions : streamType === 'option' ? this.optionSubscriptions : this.cryptoSubscriptions;
+        let ws;
+        let subscriptions;
+        if (streamType === 'stock') {
+            ws = this.stockWs;
+            subscriptions = this.stockSubscriptions;
+        }
+        else if (streamType === 'option') {
+            ws = this.optionWs;
+            subscriptions = this.optionSubscriptions;
+        }
+        else {
+            ws = this.cryptoWs;
+            subscriptions = this.cryptoSubscriptions;
+        }
+        log$1(`sendSubscription called for ${streamType} (wsReady=${ws?.readyState === WebSocket.OPEN}, trades=${subscriptions.trades?.length || 0}, quotes=${subscriptions.quotes?.length || 0}, bars=${subscriptions.bars?.length || 0})`, {
+            type: 'debug',
+        });
         if (ws && ws.readyState === WebSocket.OPEN) {
             const subMessagePayload = {};
-            if (subscriptions.trades && subscriptions.trades.length > 0) {
+            if (subscriptions.trades.length > 0) {
                 subMessagePayload.trades = subscriptions.trades;
             }
-            if (subscriptions.quotes && subscriptions.quotes.length > 0) {
+            if (subscriptions.quotes.length > 0) {
                 subMessagePayload.quotes = subscriptions.quotes;
             }
-            if (subscriptions.bars && subscriptions.bars.length > 0) {
+            if (subscriptions.bars.length > 0) {
                 subMessagePayload.bars = subscriptions.bars;
             }
-            // Crypto-specific subscription types
-            if (streamType === 'crypto') {
-                if (subscriptions.dailyBars && subscriptions.dailyBars.length > 0) {
-                    subMessagePayload.dailyBars = subscriptions.dailyBars;
-                }
-                if (subscriptions.updatedBars && subscriptions.updatedBars.length > 0) {
-                    subMessagePayload.updatedBars = subscriptions.updatedBars;
-                }
-                if (subscriptions.orderbooks && subscriptions.orderbooks.length > 0) {
-                    subMessagePayload.orderbooks = subscriptions.orderbooks;
-                }
-            }
             if (Object.keys(subMessagePayload).length > 0) {
                 const subMessage = {
                     action: 'subscribe',
                     ...subMessagePayload,
                 };
-                ws.send(JSON.stringify(subMessage));
+                const messageJson = JSON.stringify(subMessage);
+                log$1(`Sending ${streamType} subscription: ${messageJson}`, { type: 'info' });
+                ws.send(messageJson);
+            }
+            else {
+                log$1(`No ${streamType} subscriptions to send (all arrays empty)`, { type: 'debug' });
             }
         }
+        else {
+            log$1(`Cannot send ${streamType} subscription: WebSocket not ready`, { type: 'warn' });
+        }
     }
     connectStockStream() {
         if (!this.stockWs) {
@@ -6309,6 +6345,11 @@ class AlpacaMarketDataAPI extends EventEmitter {
             this.connect('option');
         }
     }
+    connectCryptoStream() {
+        if (!this.cryptoWs) {
+            this.connect('crypto');
+        }
+    }
     disconnectStockStream() {
         if (this.stockWs) {
             this.stockWs.close();
@@ -6319,18 +6360,38 @@ class AlpacaMarketDataAPI extends EventEmitter {
             this.optionWs.close();
         }
     }
-    connectCryptoStream() {
-        if (!this.cryptoWs) {
-            this.connect('crypto');
-        }
-    }
     disconnectCryptoStream() {
         if (this.cryptoWs) {
             this.cryptoWs.close();
         }
     }
+    /**
+     * Check if a specific stream is connected
+     * @param streamType - The type of stream to check
+     * @returns True if the stream is connected
+     */
+    isStreamConnected(streamType) {
+        if (streamType === 'stock') {
+            return this.stockWs !== null && this.stockWs.readyState === WebSocket.OPEN;
+        }
+        else if (streamType === 'option') {
+            return this.optionWs !== null && this.optionWs.readyState === WebSocket.OPEN;
+        }
+        else {
+            return this.cryptoWs !== null && this.cryptoWs.readyState === WebSocket.OPEN;
+        }
+    }
     subscribe(streamType, subscriptions) {
-        const currentSubscriptions = streamType === 'stock' ? this.stockSubscriptions : streamType === 'option' ? this.optionSubscriptions : this.cryptoSubscriptions;
+        let currentSubscriptions;
+        if (streamType === 'stock') {
+            currentSubscriptions = this.stockSubscriptions;
+        }
+        else if (streamType === 'option') {
+            currentSubscriptions = this.optionSubscriptions;
+        }
+        else {
+            currentSubscriptions = this.cryptoSubscriptions;
+        }
         Object.entries(subscriptions).forEach(([key, value]) => {
             if (value) {
                 currentSubscriptions[key] = [...new Set([...(currentSubscriptions[key] || []), ...value])];
@@ -6339,7 +6400,16 @@ class AlpacaMarketDataAPI extends EventEmitter {
         this.sendSubscription(streamType);
     }
     unsubscribe(streamType, subscriptions) {
-        const currentSubscriptions = streamType === 'stock' ? this.stockSubscriptions : streamType === 'option' ? this.optionSubscriptions : this.cryptoSubscriptions;
+        let currentSubscriptions;
+        if (streamType === 'stock') {
+            currentSubscriptions = this.stockSubscriptions;
+        }
+        else if (streamType === 'option') {
+            currentSubscriptions = this.optionSubscriptions;
+        }
+        else {
+            currentSubscriptions = this.cryptoSubscriptions;
+        }
         Object.entries(subscriptions).forEach(([key, value]) => {
             if (value) {
                 currentSubscriptions[key] = (currentSubscriptions[key] || []).filter(s => !value.includes(s));
@@ -6349,7 +6419,16 @@ class AlpacaMarketDataAPI extends EventEmitter {
             action: 'unsubscribe',
             ...subscriptions,
         };
-        const ws = streamType === 'stock' ? this.stockWs : streamType === 'option' ? this.optionWs : this.cryptoWs;
+        let ws;
+        if (streamType === 'stock') {
+            ws = this.stockWs;
+        }
+        else if (streamType === 'option') {
+            ws = this.optionWs;
+        }
+        else {
+            ws = this.cryptoWs;
+        }
         if (ws && ws.readyState === WebSocket.OPEN) {
             ws.send(JSON.stringify(unsubMessage));
         }