firstock 1.0.9 → 1.1.0

package/Readme.md

@@ -5,7 +5,7 @@ To communicate with the Firstock Developer API using Nodejs, you can use the off
 Licensed under the MIT License.
 
 
-[Version - 1.0.7](https://www.npmjs.com/package/firstock)
+[Version - 1.0.9](https://www.npmjs.com/package/firstock)
 
 
 ## Documentation

package/dist/websockets/websocket_functions.js

@@ -21,17 +21,6 @@ exports.subscribeOptionGreeks = subscribeOptionGreeks;
 exports.unsubscribeOptionGreeks = unsubscribeOptionGreeks;
 const ws_1 = __importDefault(require("ws"));
 const fs_1 = require("fs");
-// Configure logging
-const logger = {
-    debug: (msg) => console.debug(`${new Date().toISOString()} - ${msg}`),
-    info: (msg) => console.info(`${new Date().toISOString()} - ${msg}`),
-    warning: (msg) => console.warn(`${new Date().toISOString()} - ${msg}`),
-    error: (msg, err) => {
-        console.error(`[ERROR] ${new Date().toISOString()} - ${msg}`);
-        if (err)
-            console.error(err);
-    }
-};
 var UpdateType;
 (function (UpdateType) {
     UpdateType["ORDER"] = "order";
@@ -85,14 +74,12 @@ class ConnectionManager {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.acquireLock();
             if (this.indexMap.has(ws)) {
-                logger.info("Connection already exists");
                 this.releaseLock();
                 return this.indexMap.get(ws);
             }
             const safe = new SafeConn(ws);
             this.connMap.set(safe, true);
             this.indexMap.set(ws, safe);
-            logger.info("Connection added");
             this.releaseLock();
             return safe;
         });
@@ -135,7 +122,6 @@ class ConnectionManager {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.acquireLock();
             if (this.indexMap.has(ws)) {
-                // Set shutdown flag BEFORE closing
                 _setShutdownFlag(ws);
                 const safe = this.indexMap.get(ws);
                 this.connMap.delete(safe);
@@ -148,13 +134,10 @@ class ConnectionManager {
                 catch (e) {
                     // Ignore errors during close
                 }
-                logger.info("Connection deleted");
-                // Clear subscription tracking
                 _clearTrackedSubscriptions(ws);
                 this.releaseLock();
                 return;
             }
-            logger.info("Connection not found");
             this.releaseLock();
         });
     }
@@ -178,7 +161,6 @@ function _trackSubscription(ws, tokens, subscriptionType) {
             tracker[subscriptionType].push(token);
         }
     }
-    logger.debug(`Tracked subscription: ${subscriptionType} - ${tokens.join(', ')}`);
 }
 function _untrackSubscription(ws, tokens, subscriptionType) {
     const wsId = _getWsId(ws);
@@ -191,7 +173,6 @@ function _untrackSubscription(ws, tokens, subscriptionType) {
             }
         }
     }
-    logger.debug(`Untracked subscription: ${subscriptionType} - ${tokens.join(', ')}`);
 }
 function _getTrackedSubscriptions(ws) {
     const wsId = _getWsId(ws);
@@ -201,7 +182,6 @@ function _clearTrackedSubscriptions(ws) {
     const wsId = _getWsId(ws);
     if (subscriptionTracker.has(wsId)) {
         subscriptionTracker.delete(wsId);
-        logger.debug(`Cleared subscription tracking for connection ${wsId}`);
     }
 }
 // Shutdown flags
@@ -209,7 +189,6 @@ const shutdownFlags = new Map();
 function _setShutdownFlag(ws) {
     const wsId = _getWsId(ws);
     shutdownFlags.set(wsId, true);
-    logger.debug(`Shutdown flag set for connection ${wsId}`);
 }
 function _isShutdownRequested(ws) {
     const wsId = _getWsId(ws);
@@ -219,7 +198,6 @@ function _clearShutdownFlag(ws) {
     const wsId = _getWsId(ws);
     if (shutdownFlags.has(wsId)) {
         shutdownFlags.delete(wsId);
-        logger.debug(`Shutdown flag cleared for connection ${wsId}`);
     }
 }
 function getUrlAndHeaderData(userId, config) {
@@ -231,7 +209,6 @@ function getUrlAndHeaderData(userId, config) {
     const acceptLanguage = config.accept_language || 'en-US,en;q=0.9';
     const origin = config.origin || '';
     const baseUrl = `${scheme}://${host}${path}`;
-    logger.info(`Connecting to ${baseUrl}`);
     let configJson;
     try {
         const configFile = (0, fs_1.readFileSync)('config.json', 'utf-8');
@@ -240,7 +217,6 @@ function getUrlAndHeaderData(userId, config) {
     catch (e) {
         return ['', null, new Error('Failed to read config.json')];
     }
-    // Use the userId parameter to get the jKey
     if (!configJson[userId]) {
         return ['', null, new Error(`User ID '${userId}' not found in config.json`)];
     }
@@ -279,11 +255,9 @@ function _identifyUpdateType(data) {
 }
 function _handleAuthenticationResponse(message) {
     if (message.includes("Authentication successful")) {
-        logger.info("Authentication successful");
         return true;
     }
     else if (message.includes('"status":"failed"')) {
-        logger.warning(`Authentication failed: ${message}`);
         return false;
     }
     return true;
@@ -292,25 +266,15 @@ function readMessage(userId, ws, model, config) {
     return __awaiter(this, void 0, void 0, function* () {
         const maxRetries = config.max_websocket_connection_retries || 3;
         const timeInterval = config.time_interval || 5;
-        let messageCount = 0;
         let isAuthenticated = true;
-        logger.info(`Starting message reader for user ${userId}`);
-        logger.info(`Callbacks configured - Feed: ${model.subscribe_feed_data !== undefined}, ` +
-            `Order: ${model.order_data !== undefined}, ` +
-            `Position: ${model.position_data !== undefined}, ` +
-            `Option Greeks: ${model.subscribe_option_greeks_data !== undefined}`);
         const messageHandler = (data) => __awaiter(this, void 0, void 0, function* () {
             if (!(yield exports.connections.checkIfConnectionExists(ws))) {
-                logger.info("Connection no longer exists, stopping reader");
                 _clearShutdownFlag(ws);
                 return;
             }
             try {
                 const message = data.toString();
-                messageCount++;
-                logger.debug(`Message #${messageCount}: ${message.substring(0, 200)}...`);
                 if (!message) {
-                    logger.debug("Empty message received, skipping");
                     return;
                 }
                 let parsedData;
@@ -318,14 +282,12 @@ function readMessage(userId, ws, model, config) {
                     parsedData = JSON.parse(message);
                 }
                 catch (e) {
-                    logger.error(`JSON parse error: ${e.message}. Message: ${message.substring(0, 200)}`);
                     return;
                 }
                 // Handle authentication responses
                 if (parsedData.status && parsedData.message) {
                     if (_handleAuthenticationResponse(message)) {
                         isAuthenticated = true;
-                        logger.info("Re-authentication successful");
                     }
                     return;
                 }
@@ -335,10 +297,9 @@ function readMessage(userId, ws, model, config) {
                     if (model.order_data) {
                         try {
                             model.order_data(parsedData);
-                            logger.debug("Order callback invoked");
                         }
                         catch (e) {
-                            logger.error(`Error in order callback: ${e.message}`, e);
+                            // Ignore callback errors
                         }
                     }
                 }
@@ -346,10 +307,9 @@ function readMessage(userId, ws, model, config) {
                     if (model.position_data) {
                         try {
                             model.position_data(parsedData);
-                            logger.debug("Position callback invoked");
                         }
                         catch (e) {
-                            logger.error(`Error in position callback: ${e.message}`, e);
+                            // Ignore callback errors
                         }
                     }
                 }
@@ -363,10 +323,9 @@ function readMessage(userId, ws, model, config) {
                                     }
                                 }
                             }
-                            logger.debug("Option Greeks callback invoked");
                         }
                         catch (e) {
-                            logger.error(`Error in option Greeks callback: ${e.message}`, e);
+                            // Ignore callback errors
                         }
                     }
                 }
@@ -374,55 +333,39 @@ function readMessage(userId, ws, model, config) {
                     if (model.subscribe_feed_data) {
                         try {
                             model.subscribe_feed_data(parsedData);
-                            logger.debug("Feed callback invoked");
                         }
                         catch (e) {
-                            logger.error(`Error in feed callback: ${e.message}`, e);
+                            // Ignore callback errors
                         }
                     }
                 }
             }
             catch (e) {
-                logger.error(`Error processing message: ${e.message}`, e);
+                // Ignore processing errors
             }
         });
         const closeHandler = () => __awaiter(this, void 0, void 0, function* () {
-            // Check if shutdown was requested
             if (_isShutdownRequested(ws)) {
-                logger.info("Connection closed intentionally");
                 _clearShutdownFlag(ws);
                 return;
             }
-            // Unexpected disconnection - attempt reconnection
-            logger.warning("Unexpected disconnection");
-            console.log("\n Connection lost");
-            console.log("Attempting to reconnect...");
             if (!(yield exports.connections.checkIfConnectionExists(ws))) {
-                logger.info("Connection no longer in manager, stopping reader");
                 return;
             }
-            // Attempt reconnection
             const newWs = yield _attemptReconnection(userId, ws, config, maxRetries, timeInterval, model);
             if (newWs === null) {
-                logger.error("Failed to reconnect after all attempts");
-                console.log("✗ Failed to reconnect. Please restart the application.");
                 return;
             }
-            logger.info("Reconnection successful, resuming message reading");
-            // Call user's reconnection callback if provided
             if (model.on_reconnect) {
                 try {
                     model.on_reconnect(newWs);
-                    logger.info("User's on_reconnect callback executed");
                 }
                 catch (callbackError) {
-                    logger.error(`Error in on_reconnect callback: ${callbackError.message}`, callbackError);
+                    // Ignore callback errors
                 }
             }
         });
         const errorHandler = (error) => __awaiter(this, void 0, void 0, function* () {
-            logger.error(`WebSocket error: ${error.message}`, error);
-            // Trigger close handler for reconnection logic
             yield closeHandler();
         });
         ws.on('message', messageHandler);
@@ -432,28 +375,20 @@ function readMessage(userId, ws, model, config) {
 }
 function _attemptReconnection(userId, oldWs, config, maxRetries, timeInterval, model) {
     return __awaiter(this, void 0, void 0, function* () {
-        // Get the actual tracked subscriptions
         const tracked = _getTrackedSubscriptions(oldWs);
         const allTokens = tracked.tokens;
         const allOptionGreeksTokens = tracked.option_greeks_tokens;
-        logger.info(`Attempting reconnection. Will restore: ${allTokens.length} market tokens, ${allOptionGreeksTokens.length} option greeks tokens`);
         for (let attempt = 1; attempt <= maxRetries; attempt++) {
             if (!(yield exports.connections.checkIfConnectionExists(oldWs))) {
-                logger.info("Connection no longer exists in manager, stopping reconnection");
                 return null;
             }
-            logger.info(`Reconnection attempt ${attempt}/${maxRetries}...`);
-            console.log(`Reconnection attempt ${attempt}/${maxRetries}...`);
             yield new Promise(resolve => setTimeout(resolve, timeInterval * 1000));
             try {
-                // Create new connection
                 const [baseUrl, headers, err] = getUrlAndHeaderData(userId, config);
                 if (err) {
-                    logger.error(`Failed to get URL/headers: ${err.message}`);
                     continue;
                 }
                 const newWs = new ws_1.default(baseUrl, { headers });
-                // Wait for connection to open
                 yield new Promise((resolve, reject) => {
                     const timeout = setTimeout(() => {
                         reject(new Error('Connection timeout'));
@@ -467,8 +402,6 @@ function _attemptReconnection(userId, oldWs, config, maxRetries, timeInterval, m
                         reject(error);
                     });
                 });
-                logger.info(`New WebSocket connection created (attempt ${attempt})`);
-                // Wait for authentication message
                 const authMessage = yield new Promise((resolve, reject) => {
                     const timeout = setTimeout(() => {
                         reject(new Error('Authentication timeout'));
@@ -482,13 +415,11 @@ function _attemptReconnection(userId, oldWs, config, maxRetries, timeInterval, m
                         reject(error);
                     });
                 });
-                logger.info(`Reconnection auth message: ${authMessage}`);
                 if (!authMessage.includes("Authentication successful")) {
-                    logger.warning(`Authentication failed on reconnect: ${authMessage}`);
                     newWs.close();
                     continue;
                 }
-                // Transfer subscription tracking from old connection to new connection
+                // Transfer subscription tracking
                 const oldWsId = _getWsId(oldWs);
                 const newWsId = _getWsId(newWs);
                 if (subscriptionTracker.has(oldWsId)) {
@@ -497,55 +428,29 @@ function _attemptReconnection(userId, oldWs, config, maxRetries, timeInterval, m
                         tokens: [...oldTracker.tokens],
                         option_greeks_tokens: [...oldTracker.option_greeks_tokens]
                     });
-                    logger.debug(`Transferred subscription tracking from ${oldWsId} to ${newWsId}`);
                 }
-                // Update connection manager
                 yield exports.connections.deleteConnection(oldWs);
                 yield exports.connections.addConnection(newWs);
-                logger.info("Connection manager updated with new connection");
-                // Resubscribe to all tracked tokens
-                logger.info("Resubscribing to previous subscriptions...");
-                console.log("Resubscribing to previous feeds...");
                 // Resubscribe to market feed tokens
                 if (allTokens.length > 0) {
                     yield new Promise(resolve => setTimeout(resolve, 500));
                     const tokensStr = allTokens.join("|");
                     const msg = JSON.stringify({ action: "subscribe", tokens: tokensStr });
-                    const error = yield exports.connections.writeMessage(newWs, msg);
-                    if (error) {
-                        logger.error(`Failed to resubscribe to market tokens: ${error}`);
-                    }
-                    else {
-                        logger.info(`Resubscribed to ${allTokens.length} market feed token(s): ${allTokens.join(', ')}`);
-                        console.log(`✓ Resubscribed to ${allTokens.length} market feed token(s)`);
-                    }
+                    yield exports.connections.writeMessage(newWs, msg);
                 }
+                // Resubscribe to option Greeks tokens
                 if (allOptionGreeksTokens.length > 0) {
                     yield new Promise(resolve => setTimeout(resolve, 500));
                     const tokensStr = allOptionGreeksTokens.join("|");
                     const msg = JSON.stringify({ action: "subscribe-option-greeks", tokens: tokensStr });
-                    const error = yield exports.connections.writeMessage(newWs, msg);
-                    if (error) {
-                        logger.error(`Failed to resubscribe to option Greeks: ${error}`);
-                    }
-                    else {
-                        logger.info(`Resubscribed to ${allOptionGreeksTokens.length} option Greeks token(s): ${allOptionGreeksTokens.join(', ')}`);
-                        console.log(`✓ Resubscribed to ${allOptionGreeksTokens.length} option Greeks token(s)`);
-                    }
+                    yield exports.connections.writeMessage(newWs, msg);
                 }
                 yield new Promise(resolve => setTimeout(resolve, 1000));
-                logger.info("Reconnection and resubscription successful!");
-                console.log("✓ Reconnection complete - all subscriptions restored");
-                // IMPORTANT: Restart the message reader for the new WebSocket
                 readMessage(userId, newWs, model, config);
                 return newWs;
             }
             catch (e) {
-                logger.error(`Reconnection attempt ${attempt} failed: ${e.message}`, e);
-                console.log(`✗ Attempt ${attempt} failed: ${e.message.substring(0, 100)}...`);
                 if (attempt === maxRetries) {
-                    logger.error("Max reconnection attempts reached");
-                    console.log(`✗ All ${maxRetries} reconnection attempts failed`);
                     return null;
                 }
             }
@@ -574,12 +479,10 @@ function subscribe(ws, tokens) {
             action: "subscribe",
             tokens: tokensStr
         });
-        logger.info(`Sending subscribe message: ${msg}`);
         const error = yield exports.connections.writeMessage(ws, msg);
         if (error) {
             return { error: { message: error } };
         }
-        logger.info("Subscribe message sent successfully");
         return null;
     });
 }
@@ -598,7 +501,6 @@ function unsubscribe(ws, tokens) {
             action: "unsubscribe",
             tokens: tokensStr
         });
-        logger.info(`Sending unsubscribe message: ${msg}`);
         const error = yield exports.connections.writeMessage(ws, msg);
         if (error) {
             return { error: { message: error } };
@@ -627,12 +529,10 @@ function subscribeOptionGreeks(ws, tokens) {
             action: "subscribe-option-greeks",
             tokens: tokensStr
         });
-        logger.info(`Sending subscribe option greeks message: ${msg}`);
         const error = yield exports.connections.writeMessage(ws, msg);
         if (error) {
             return { error: { message: error } };
         }
-        logger.info("Subscribe option greeks message sent successfully");
         return null;
     });
 }
@@ -657,12 +557,10 @@ function unsubscribeOptionGreeks(ws, tokens) {
             action: "unsubscribe-option-greeks",
             tokens: tokensStr
         });
-        logger.info(`Sending unsubscribe option greeks message: ${msg}`);
         const error = yield exports.connections.writeMessage(ws, msg);
         if (error) {
             return { error: { message: error } };
         }
-        logger.info("Unsubscribe option greeks message sent successfully");
         return null;
     });
 }

package/dist/websockets/websockets.js

@@ -1,14 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FirstockWebSocket = void 0;
-const logger = {
-    info: (msg) => console.info(`[INFO] ${new Date().toISOString()} - ${msg}`),
-    error: (msg, err) => {
-        console.error(`[ERROR] ${new Date().toISOString()} - ${msg}`);
-        if (err)
-            console.error(err);
-    }
-};
 class FirstockWebSocket {
     constructor(options = {}) {
         this.tokens = options.tokens || [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firstock",
-  "version": "1.0.9",
+  "version": "1.1.0",
   "description": "Node js package for using firstock developer apis",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",