firstock 1.0.8 → 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/Classes/AFirstock.d.ts

@@ -229,5 +229,35 @@ declare abstract class AFirstock {
     abstract getExpiry(params: GetExpiryParams, callBack: (error: Error | string | null, result: Response | null) => void): void;
     abstract brokerageCalculator(params: BrokerageCalculatorParams, callBack: (error: Error | string | null, result: Response | null) => void): void;
     abstract getHoldingsDetails(params: GetHoldingsParams, callBack: (error: Error | null, result: Response | null) => void): void;
+    abstract initializeWebsockets(userId: string, model: any, config?: any): Promise<[any | null, {
+        error: {
+            message: string;
+        };
+    } | null]>;
+    abstract closeWebsocket(ws: any | null): Promise<{
+        error: {
+            message: string;
+        };
+    } | null>;
+    abstract subscribe(ws: any | null, tokens: string[]): Promise<{
+        error: {
+            message: string;
+        };
+    } | null>;
+    abstract unsubscribe(ws: any | null, tokens: string[]): Promise<{
+        error: {
+            message: string;
+        };
+    } | null>;
+    abstract subscribeOptionGreeks(ws: any | null, tokens: string[]): Promise<{
+        error: {
+            message: string;
+        };
+    } | null>;
+    abstract unsubscribeOptionGreeks(ws: any | null, tokens: string[]): Promise<{
+        error: {
+            message: string;
+        };
+    } | null>;
 }
 export default AFirstock;

package/dist/Classes/Firstock.d.ts

@@ -1,4 +1,7 @@
+import WebSocket from "ws";
 import AFirstock from "./AFirstock";
+import { FirstockWebSocket } from "../websockets/websockets";
+import { Config } from "../websockets/websocket_functions";
 interface Response {
     data: {
         [key: string]: any;
@@ -932,5 +935,84 @@ export declare class Firstock extends AFirstock {
      * - `result`: Parsed response containing holdings information if successful.
      */
     getHoldingsDetails({ userId }: GetHoldingsParams, callBack: (error: Error | null, result: Response | null) => void): void;
+    /**
+     * Initializes a WebSocket connection to Firstock for real-time market data streaming.
+     *
+     * @param {string} userId - The user ID for authentication.
+     * @param {FirstockWebSocket} model - WebSocket model containing tokens and subscriptions.
+     * @param {Config} [config] - Optional configuration for WebSocket connection.
+     * @returns {Promise<[WebSocket | null, { error: { message: string } } | null]>}
+     *          A promise that resolves to a tuple containing the WebSocket instance (or null on error)
+     *          and an error object (or null on success).
+     */
+    initializeWebsockets(userId: string, model: FirstockWebSocket, config?: Config): Promise<[WebSocket | null, {
+        error: {
+            message: string;
+        };
+    } | null]>;
+    /**
+     * Closes an active WebSocket connection.
+     *
+     * @param {WebSocket | null} ws - The WebSocket instance to close.
+     * @returns {Promise<{ error: { message: string } } | null>}
+     *          A promise that resolves to an error object if closure fails, or null on success.
+     */
+    closeWebsocket(ws: WebSocket | null): Promise<{
+        error: {
+            message: string;
+        };
+    } | null>;
+    /**
+     * Subscribes to market data for specified tokens.
+     *
+     * @param {WebSocket | null} ws - The WebSocket instance.
+     * @param {string[]} tokens - Array of token strings to subscribe to.
+     * @returns {Promise<{ error: { message: string } } | null>}
+     *          A promise that resolves to an error object on failure, or null on success.
+     */
+    subscribe(ws: WebSocket | null, tokens: string[]): Promise<{
+        error: {
+            message: string;
+        };
+    } | null>;
+    /**
+     * Unsubscribes from market data for specified tokens.
+     *
+     * @param {WebSocket | null} ws - The WebSocket instance.
+     * @param {string[]} tokens - Array of token strings to unsubscribe from.
+     * @returns {Promise<{ error: { message: string } } | null>}
+     *          A promise that resolves to an error object on failure, or null on success.
+     */
+    unsubscribe(ws: WebSocket | null, tokens: string[]): Promise<{
+        error: {
+            message: string;
+        };
+    } | null>;
+    /**
+     * Subscribes to option Greeks data for specified tokens.
+     *
+     * @param {WebSocket | null} ws - The WebSocket instance.
+     * @param {string[]} tokens - Array of option token strings to subscribe to.
+     * @returns {Promise<{ error: { message: string } } | null>}
+     *          A promise that resolves to an error object on failure, or null on success.
+     */
+    subscribeOptionGreeks(ws: WebSocket | null, tokens: string[]): Promise<{
+        error: {
+            message: string;
+        };
+    } | null>;
+    /**
+     * Unsubscribes from option Greeks data for specified tokens.
+     *
+     * @param {WebSocket | null} ws - The WebSocket instance.
+     * @param {string[]} tokens - Array of option token strings to unsubscribe from.
+     * @returns {Promise<{ error: { message: string } } | null>}
+     *          A promise that resolves to an error object on failure, or null on success.
+     */
+    unsubscribeOptionGreeks(ws: WebSocket | null, tokens: string[]): Promise<{
+        error: {
+            message: string;
+        };
+    } | null>;
 }
 export {};

package/dist/Classes/Firstock.js

@@ -32,6 +32,15 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -39,9 +48,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Firstock = void 0;
 const axios_1 = __importDefault(require("axios"));
 const sha256 = __importStar(require("sha256"));
+const ws_1 = __importDefault(require("ws"));
 const AFirstock_1 = __importDefault(require("./AFirstock"));
 const commonFunction_1 = require("../shared/commonFunction");
 const constant_1 = require("../shared/constant");
+const websocket_functions_1 = require("../websockets/websocket_functions");
+// interface Config {
+//   scheme?: string;
+//   host?: string;
+//   path?: string;
+//   source?: string;
+//   accept_encoding?: string;
+//   accept_language?: string;
+//   origin?: string;
+//   max_websocket_connection_retries?: number;
+//   time_interval?: number;
+//   [key: string]: any;
+// }
 const axiosInterceptor = axios_1.default.create({
     baseURL: constant_1.API_LINK,
 });
@@ -1821,5 +1844,209 @@ class Firstock extends AFirstock_1.default {
             }
         });
     }
+    // WebSocket methods
+    /**
+     * Initializes a WebSocket connection to Firstock for real-time market data streaming.
+     *
+     * @param {string} userId - The user ID for authentication.
+     * @param {FirstockWebSocket} model - WebSocket model containing tokens and subscriptions.
+     * @param {Config} [config] - Optional configuration for WebSocket connection.
+     * @returns {Promise<[WebSocket | null, { error: { message: string } } | null]>}
+     *          A promise that resolves to a tuple containing the WebSocket instance (or null on error)
+     *          and an error object (or null on success).
+     */
+    initializeWebsockets(userId, model, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const finalConfig = Object.assign({ scheme: 'wss', host: 'socket.firstock.in', path: '/ws', source: 'developer-api', accept_encoding: 'gzip, deflate, br', accept_language: 'en-US,en;q=0.9', origin: 'https://firstock.in', max_websocket_connection_retries: 3, time_interval: 5 }, config);
+            const [baseUrl, headers, err] = (0, websocket_functions_1.getUrlAndHeaderData)(userId, finalConfig);
+            if (err) {
+                return [null, { error: { message: err.message } }];
+            }
+            try {
+                const ws = new ws_1.default(baseUrl, { headers });
+                yield new Promise((resolve, reject) => {
+                    const timeout = setTimeout(() => {
+                        reject(new Error('Connection timeout'));
+                    }, 10000);
+                    ws.once('open', () => {
+                        clearTimeout(timeout);
+                        resolve();
+                    });
+                    ws.once('error', (error) => {
+                        clearTimeout(timeout);
+                        reject(error);
+                    });
+                });
+                yield websocket_functions_1.connections.addConnection(ws);
+                const msg = yield new Promise((resolve, reject) => {
+                    const timeout = setTimeout(() => {
+                        reject(new Error('Authentication timeout'));
+                    }, 5000);
+                    ws.once('message', (data) => {
+                        clearTimeout(timeout);
+                        resolve(data.toString());
+                    });
+                    ws.once('error', (error) => {
+                        clearTimeout(timeout);
+                        reject(error);
+                    });
+                });
+                if (msg.includes("Authentication successful")) {
+                    yield new Promise(resolve => setTimeout(resolve, 500));
+                    const modelDict = model.toDict();
+                    (0, websocket_functions_1.readMessage)(userId, ws, modelDict, finalConfig);
+                    yield new Promise(resolve => setTimeout(resolve, 500));
+                    if (model.tokens && model.tokens.length > 0) {
+                        const subscribeErr = yield (0, websocket_functions_1.subscribe)(ws, model.tokens);
+                        if (subscribeErr) {
+                        }
+                    }
+                    if (model.option_greeks_tokens && model.option_greeks_tokens.length > 0) {
+                        const subscribeErr = yield (0, websocket_functions_1.subscribeOptionGreeks)(ws, model.option_greeks_tokens);
+                        if (subscribeErr) {
+                        }
+                    }
+                    return [ws, null];
+                }
+                else if (msg.includes("Maximum sessions limit")) {
+                    yield websocket_functions_1.connections.deleteConnection(ws);
+                    return [null, { error: { message: msg } }];
+                }
+                else {
+                    yield websocket_functions_1.connections.deleteConnection(ws);
+                    return [null, { error: { message: `Unexpected authentication response: ${msg}` } }];
+                }
+            }
+            catch (e) {
+                return [null, { error: { message: e.message } }];
+            }
+        });
+    }
+    /**
+     * Closes an active WebSocket connection.
+     *
+     * @param {WebSocket | null} ws - The WebSocket instance to close.
+     * @returns {Promise<{ error: { message: string } } | null>}
+     *          A promise that resolves to an error object if closure fails, or null on success.
+     */
+    closeWebsocket(ws) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (ws === null) {
+                return {
+                    error: {
+                        message: "Connection does not exist"
+                    }
+                };
+            }
+            if (yield websocket_functions_1.connections.checkIfConnectionExists(ws)) {
+                try {
+                    ws.close();
+                    yield websocket_functions_1.connections.deleteConnection(ws);
+                    return null;
+                }
+                catch (e) {
+                    const errorMsg = e.message.toLowerCase();
+                    if (!errorMsg.includes("closed")) {
+                        return {
+                            error: {
+                                message: e.message
+                            }
+                        };
+                    }
+                    else {
+                        yield websocket_functions_1.connections.deleteConnection(ws);
+                        return null;
+                    }
+                }
+            }
+            else {
+                return {
+                    error: {
+                        message: "Connection does not exist"
+                    }
+                };
+            }
+        });
+    }
+    /**
+     * Subscribes to market data for specified tokens.
+     *
+     * @param {WebSocket | null} ws - The WebSocket instance.
+     * @param {string[]} tokens - Array of token strings to subscribe to.
+     * @returns {Promise<{ error: { message: string } } | null>}
+     *          A promise that resolves to an error object on failure, or null on success.
+     */
+    subscribe(ws, tokens) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (ws === null) {
+                return {
+                    error: {
+                        message: "Connection does not exist"
+                    }
+                };
+            }
+            return (0, websocket_functions_1.subscribe)(ws, tokens);
+        });
+    }
+    /**
+     * Unsubscribes from market data for specified tokens.
+     *
+     * @param {WebSocket | null} ws - The WebSocket instance.
+     * @param {string[]} tokens - Array of token strings to unsubscribe from.
+     * @returns {Promise<{ error: { message: string } } | null>}
+     *          A promise that resolves to an error object on failure, or null on success.
+     */
+    unsubscribe(ws, tokens) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (ws === null) {
+                return {
+                    error: {
+                        message: "Connection does not exist"
+                    }
+                };
+            }
+            return (0, websocket_functions_1.unsubscribe)(ws, tokens);
+        });
+    }
+    /**
+     * Subscribes to option Greeks data for specified tokens.
+     *
+     * @param {WebSocket | null} ws - The WebSocket instance.
+     * @param {string[]} tokens - Array of option token strings to subscribe to.
+     * @returns {Promise<{ error: { message: string } } | null>}
+     *          A promise that resolves to an error object on failure, or null on success.
+     */
+    subscribeOptionGreeks(ws, tokens) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (ws === null) {
+                return {
+                    error: {
+                        message: "Connection does not exist"
+                    }
+                };
+            }
+            return (0, websocket_functions_1.subscribeOptionGreeks)(ws, tokens);
+        });
+    }
+    /**
+     * Unsubscribes from option Greeks data for specified tokens.
+     *
+     * @param {WebSocket | null} ws - The WebSocket instance.
+     * @param {string[]} tokens - Array of option token strings to unsubscribe from.
+     * @returns {Promise<{ error: { message: string } } | null>}
+     *          A promise that resolves to an error object on failure, or null on success.
+     */
+    unsubscribeOptionGreeks(ws, tokens) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (ws === null) {
+                return {
+                    error: {
+                        message: "Connection does not exist"
+                    }
+                };
+            }
+            return (0, websocket_functions_1.unsubscribeOptionGreeks)(ws, tokens);
+        });
+    }
 }
 exports.Firstock = Firstock;

package/dist/test.js

@@ -7,11 +7,11 @@ const index_1 = __importDefault(require("./index"));
 const firstock = new index_1.default();
 let orderNumber = "";
 const userDetails = {
-    userId: "NP2997",
-    password: "Skanda@2025",
-    TOTP: "1997",
-    vendorCode: "NP2997_API",
-    apiKey: "e55eb28e18ee1337fc0b2705f9b82465",
+    userId: "CM2096",
+    password: "Leaveme@L0ne",
+    TOTP: "1996",
+    vendorCode: "FIRSTOCK_MST_KEY",
+    apiKey: "Nco@MS7K8t",
 };
 // const userDetails = {
 //   userId: "",

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.d.ts

@@ -1,5 +1,5 @@
 import WebSocket from 'ws';
-import { Config, WebSocketModel } from './websocket_functions';
+import { WebSocketModel } from './websocket_functions';
 export declare class FirstockWebSocket {
     tokens?: string[];
     option_greeks_tokens?: string[];
@@ -19,35 +19,3 @@ export declare class FirstockWebSocket {
     });
     toDict(): WebSocketModel;
 }
-export declare class Firstock {
-    static initializeWebsockets(userId: string, model: FirstockWebSocket, config?: Config): Promise<[WebSocket | null, {
-        error: {
-            message: string;
-        };
-    } | null]>;
-    static closeWebsocket(ws: WebSocket | null): Promise<{
-        error: {
-            message: string;
-        };
-    } | null>;
-    static subscribe(ws: WebSocket | null, tokens: string[]): Promise<{
-        error: {
-            message: string;
-        };
-    } | null>;
-    static unsubscribe(ws: WebSocket | null, tokens: string[]): Promise<{
-        error: {
-            message: string;
-        };
-    } | null>;
-    static subscribeOptionGreeks(ws: WebSocket | null, tokens: string[]): Promise<{
-        error: {
-            message: string;
-        };
-    } | null>;
-    static unsubscribeOptionGreeks(ws: WebSocket | null, tokens: string[]): Promise<{
-        error: {
-            message: string;
-        };
-    } | null>;
-}

package/dist/websockets/websockets.js

@@ -1,28 +1,6 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Firstock = exports.FirstockWebSocket = void 0;
-const ws_1 = __importDefault(require("ws"));
-const websocket_functions_1 = require("./websocket_functions");
-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);
-    }
-};
+exports.FirstockWebSocket = void 0;
 class FirstockWebSocket {
     constructor(options = {}) {
         this.tokens = options.tokens || [];
@@ -46,168 +24,176 @@ class FirstockWebSocket {
     }
 }
 exports.FirstockWebSocket = FirstockWebSocket;
-class Firstock {
-    static initializeWebsockets(userId, model, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const finalConfig = Object.assign({ scheme: 'wss', host: 'socket.firstock.in', path: '/ws', source: 'developer-api', accept_encoding: 'gzip, deflate, br', accept_language: 'en-US,en;q=0.9', origin: 'https://firstock.in', max_websocket_connection_retries: 3, time_interval: 5 }, config);
-            const [baseUrl, headers, err] = (0, websocket_functions_1.getUrlAndHeaderData)(userId, finalConfig);
-            if (err) {
-                return [null, { error: { message: err.message } }];
-            }
-            try {
-                const ws = new ws_1.default(baseUrl, { headers });
-                yield new Promise((resolve, reject) => {
-                    const timeout = setTimeout(() => {
-                        reject(new Error('Connection timeout'));
-                    }, 10000);
-                    ws.once('open', () => {
-                        clearTimeout(timeout);
-                        resolve();
-                    });
-                    ws.once('error', (error) => {
-                        clearTimeout(timeout);
-                        reject(error);
-                    });
-                });
-                logger.info("WebSocket connection created");
-                yield websocket_functions_1.connections.addConnection(ws);
-                const msg = yield new Promise((resolve, reject) => {
-                    const timeout = setTimeout(() => {
-                        reject(new Error('Authentication timeout'));
-                    }, 5000);
-                    ws.once('message', (data) => {
-                        clearTimeout(timeout);
-                        resolve(data.toString());
-                    });
-                    ws.once('error', (error) => {
-                        clearTimeout(timeout);
-                        reject(error);
-                    });
-                });
-                logger.info(`Initial message received: ${msg}`);
-                if (msg.includes("Authentication successful")) {
-                    logger.info("Authentication successful, starting message reader");
-                    yield new Promise(resolve => setTimeout(resolve, 500));
-                    const modelDict = model.toDict();
-                    (0, websocket_functions_1.readMessage)(userId, ws, modelDict, finalConfig);
-                    yield new Promise(resolve => setTimeout(resolve, 500));
-                    if (model.tokens && model.tokens.length > 0) {
-                        logger.info(`Subscribing to initial tokens: ${model.tokens.join(', ')}`);
-                        const subscribeErr = yield (0, websocket_functions_1.subscribe)(ws, model.tokens);
-                        if (subscribeErr) {
-                            logger.error(`Initial subscription error: ${JSON.stringify(subscribeErr)}`);
-                        }
-                    }
-                    if (model.option_greeks_tokens && model.option_greeks_tokens.length > 0) {
-                        logger.info(`Subscribing to option Greeks tokens: ${model.option_greeks_tokens.join(', ')}`);
-                        const subscribeErr = yield (0, websocket_functions_1.subscribeOptionGreeks)(ws, model.option_greeks_tokens);
-                        if (subscribeErr) {
-                            logger.error(`Initial option Greeks subscription error: ${JSON.stringify(subscribeErr)}`);
-                        }
-                    }
-                    return [ws, null];
-                }
-                else if (msg.includes("Maximum sessions limit")) {
-                    yield websocket_functions_1.connections.deleteConnection(ws);
-                    return [null, { error: { message: msg } }];
-                }
-                else {
-                    yield websocket_functions_1.connections.deleteConnection(ws);
-                    return [null, { error: { message: `Unexpected authentication response: ${msg}` } }];
-                }
-            }
-            catch (e) {
-                logger.error(`WebSocket initialization error: ${e.message}`, e);
-                return [null, { error: { message: e.message } }];
-            }
-        });
-    }
-    static closeWebsocket(ws) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (ws === null) {
-                return {
-                    error: {
-                        message: "Connection does not exist"
-                    }
-                };
-            }
-            if (yield websocket_functions_1.connections.checkIfConnectionExists(ws)) {
-                try {
-                    ws.close();
-                    yield websocket_functions_1.connections.deleteConnection(ws);
-                    return null;
-                }
-                catch (e) {
-                    const errorMsg = e.message.toLowerCase();
-                    if (!errorMsg.includes("closed")) {
-                        return {
-                            error: {
-                                message: e.message
-                            }
-                        };
-                    }
-                    else {
-                        yield websocket_functions_1.connections.deleteConnection(ws);
-                        return null;
-                    }
-                }
-            }
-            else {
-                return {
-                    error: {
-                        message: "Connection does not exist"
-                    }
-                };
-            }
-        });
-    }
-    static subscribe(ws, tokens) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (ws === null) {
-                return {
-                    error: {
-                        message: "Connection does not exist"
-                    }
-                };
-            }
-            return (0, websocket_functions_1.subscribe)(ws, tokens);
-        });
-    }
-    static unsubscribe(ws, tokens) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (ws === null) {
-                return {
-                    error: {
-                        message: "Connection does not exist"
-                    }
-                };
-            }
-            return (0, websocket_functions_1.unsubscribe)(ws, tokens);
-        });
-    }
-    static subscribeOptionGreeks(ws, tokens) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (ws === null) {
-                return {
-                    error: {
-                        message: "Connection does not exist"
-                    }
-                };
-            }
-            return (0, websocket_functions_1.subscribeOptionGreeks)(ws, tokens);
-        });
-    }
-    static unsubscribeOptionGreeks(ws, tokens) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (ws === null) {
-                return {
-                    error: {
-                        message: "Connection does not exist"
-                    }
-                };
-            }
-            return (0, websocket_functions_1.unsubscribeOptionGreeks)(ws, tokens);
-        });
-    }
-}
-exports.Firstock = Firstock;
+// export class Firstock {
+//     static async initializeWebsockets(
+//         userId: string,
+//         model: FirstockWebSocket,
+//         config?: Config
+//     ): Promise<[WebSocket | null, { error: { message: string } } | null]> {
+//         const finalConfig: Config = {
+//             scheme: 'wss',
+//             host: 'socket.firstock.in',
+//             path: '/ws',
+//             source: 'developer-api',
+//             accept_encoding: 'gzip, deflate, br',
+//             accept_language: 'en-US,en;q=0.9',
+//             origin: 'https://firstock.in',
+//             max_websocket_connection_retries: 3,
+//             time_interval: 5,
+//             ...config
+//         };
+//         const [baseUrl, headers, err] = getUrlAndHeaderData(userId, finalConfig);
+//         if (err) {
+//             return [null, { error: { message: err.message } }];
+//         }
+//         try {
+//             const ws = new WebSocket(baseUrl, { headers });
+//             await new Promise<void>((resolve, reject) => {
+//                 const timeout = setTimeout(() => {
+//                     reject(new Error('Connection timeout'));
+//                 }, 10000);
+//                 ws.once('open', () => {
+//                     clearTimeout(timeout);
+//                     resolve();
+//                 });
+//                 ws.once('error', (error) => {
+//                     clearTimeout(timeout);
+//                     reject(error);
+//                 });
+//             });
+//             logger.info("WebSocket connection created");
+//             await connections.addConnection(ws);
+//             const msg = await new Promise<string>((resolve, reject) => {
+//                 const timeout = setTimeout(() => {
+//                     reject(new Error('Authentication timeout'));
+//                 }, 5000);
+//                 ws.once('message', (data) => {
+//                     clearTimeout(timeout);
+//                     resolve(data.toString());
+//                 });
+//                 ws.once('error', (error) => {
+//                     clearTimeout(timeout);
+//                     reject(error);
+//                 });
+//             });
+//             logger.info(`Initial message received: ${msg}`);
+//             if (msg.includes("Authentication successful")) {
+//                 logger.info("Authentication successful, starting message reader");
+//                 await new Promise(resolve => setTimeout(resolve, 500));
+//                 const modelDict = model.toDict();
+//                 readMessage(userId, ws, modelDict, finalConfig);
+//                 await new Promise(resolve => setTimeout(resolve, 500));
+//                 if (model.tokens && model.tokens.length > 0) {
+//                     logger.info(`Subscribing to initial tokens: ${model.tokens.join(', ')}`);
+//                     const subscribeErr = await subscribeHelper(ws, model.tokens);
+//                     if (subscribeErr) {
+//                         logger.error(`Initial subscription error: ${JSON.stringify(subscribeErr)}`);
+//                     }
+//                 }
+//                 if (model.option_greeks_tokens && model.option_greeks_tokens.length > 0) {
+//                     logger.info(`Subscribing to option Greeks tokens: ${model.option_greeks_tokens.join(', ')}`);
+//                     const subscribeErr = await subscribeOptionGreeksHelper(ws, model.option_greeks_tokens);
+//                     if (subscribeErr) {
+//                         logger.error(`Initial option Greeks subscription error: ${JSON.stringify(subscribeErr)}`);
+//                     }
+//                 }
+//                 return [ws, null];
+//             } else if (msg.includes("Maximum sessions limit")) {
+//                 await connections.deleteConnection(ws);
+//                 return [null, { error: { message: msg } }];
+//             } else {
+//                 await connections.deleteConnection(ws);
+//                 return [null, { error: { message: `Unexpected authentication response: ${msg}` } }];
+//             }
+//         } catch (e) {
+//             logger.error(`WebSocket initialization error: ${(e as Error).message}`, e as Error);
+//             return [null, { error: { message: (e as Error).message } }];
+//         }
+//     }
+//     static async closeWebsocket(ws: WebSocket | null): Promise<{ error: { message: string } } | null> {
+//         if (ws === null) {
+//             return {
+//                 error: {
+//                     message: "Connection does not exist"
+//                 }
+//             };
+//         }
+//         if (await connections.checkIfConnectionExists(ws)) {
+//             try {
+//                 ws.close();
+//                 await connections.deleteConnection(ws);
+//                 return null;
+//             } catch (e) {
+//                 const errorMsg = (e as Error).message.toLowerCase();
+//                 if (!errorMsg.includes("closed")) {
+//                     return {
+//                         error: {
+//                             message: (e as Error).message
+//                         }
+//                     };
+//                 } else {
+//                     await connections.deleteConnection(ws);
+//                     return null;
+//                 }
+//             }
+//         } else {
+//             return {
+//                 error: {
+//                     message: "Connection does not exist"
+//                 }
+//             };
+//         }
+//     }
+//     static async subscribe(
+//         ws: WebSocket | null,
+//         tokens: string[]
+//     ): Promise<{ error: { message: string } } | null> {
+//         if (ws === null) {
+//             return {
+//                 error: {
+//                     message: "Connection does not exist"
+//                 }
+//             };
+//         }
+//         return subscribeHelper(ws, tokens);
+//     }
+//     static async unsubscribe(
+//         ws: WebSocket | null,
+//         tokens: string[]
+//     ): Promise<{ error: { message: string } } | null> {
+//         if (ws === null) {
+//             return {
+//                 error: {
+//                     message: "Connection does not exist"
+//                 }
+//             };
+//         }
+//         return unsubscribeHelper(ws, tokens);
+//     }
+//     static async subscribeOptionGreeks(
+//         ws: WebSocket | null,
+//         tokens: string[]
+//     ): Promise<{ error: { message: string } } | null> {
+//         if (ws === null) {
+//             return {
+//                 error: {
+//                     message: "Connection does not exist"
+//                 }
+//             };
+//         }
+//         return subscribeOptionGreeksHelper(ws, tokens);
+//     }
+//     static async unsubscribeOptionGreeks(
+//         ws: WebSocket | null,
+//         tokens: string[]
+//     ): Promise<{ error: { message: string } } | null> {
+//         if (ws === null) {
+//             return {
+//                 error: {
+//                     message: "Connection does not exist"
+//                 }
+//             };
+//         }
+//         return unsubscribeOptionGreeksHelper(ws, tokens);
+//     }
+// }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firstock",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "description": "Node js package for using firstock developer apis",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,6 +11,7 @@
     "LICENSE"
   ],
   "scripts": {
+    "test:ws": "ts-node test_websockets.js",
     "build": "tsc",
     "prepublishOnly": "npm run build",
     "test": "echo \"Error: no test specified\" && exit 1"