firstock 1.0.1 → 1.0.5

package/dist/websockets/websockets.js

@@ -0,0 +1,213 @@
+"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);
+    }
+};
+class FirstockWebSocket {
+    constructor(options = {}) {
+        this.tokens = options.tokens || [];
+        this.option_greeks_tokens = options.option_greeks_tokens || [];
+        this.order_data = options.order_data;
+        this.position_data = options.position_data;
+        this.subscribe_feed_data = options.subscribe_feed_data;
+        this.subscribe_option_greeks_data = options.subscribe_option_greeks_data;
+        this.on_reconnect = options.on_reconnect;
+    }
+    toDict() {
+        return {
+            tokens: this.tokens,
+            option_greeks_tokens: this.option_greeks_tokens,
+            order_data: this.order_data,
+            position_data: this.position_data,
+            subscribe_feed_data: this.subscribe_feed_data,
+            subscribe_option_greeks_data: this.subscribe_option_greeks_data,
+            on_reconnect: this.on_reconnect
+        };
+    }
+}
+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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firstock",
-  "version": "1.0.1",
+  "version": "1.0.5",
   "description": "Node js package for using firstock developer apis",
   "main": "dist/index.js",
   "type": "commonjs",
@@ -23,10 +23,13 @@
   "homepage": "https://github.com/the-firstock/firstock-developer-sdk-nodejs#readme",
   "dependencies": {
     "axios": "^1.10.0",
-    "sha256": "^0.2.0"
+    "sha256": "^0.2.0",
+    "util": "^0.12.5",
+    "ws": "^8.18.3"
   },
   "devDependencies": {
     "@types/sha256": "^0.2.2",
+    "@types/ws": "^8.18.1",
     "typescript": "^5.8.3"
   }
 }

package/websockets/test_websockets.js

@@ -0,0 +1,187 @@
+const { Firstock, FirstockWebSocket } = require('./websockets');
+const { appendFileSync } = require('fs');
+
+function subscribeFeedData(data) {
+    try {
+        appendFileSync('websocket.log', `${JSON.stringify(data)}\n`);
+        console.log(data);
+    } catch (e) {
+        console.error(`Error writing to log: ${e}`);
+    }
+}
+
+function subscribeOptionGreeksData(data) {
+    try {
+        const timestamp = new Date().toISOString();
+        appendFileSync('option_greeks.log', `${timestamp} - ${JSON.stringify(data)}\n`);
+    } catch (e) {
+        console.error(`Error writing option Greeks: ${e}`);
+    }
+}
+
+function orderBookData(data) {
+    try {
+        const timestamp = new Date().toISOString();
+        appendFileSync('order_detail.log', `${timestamp} - ${JSON.stringify(data)}\n`);
+    } catch (e) {
+        console.error(`Error opening log file: ${e}`);
+    }
+}
+
+function positionBookData(data) {
+    try {
+        const timestamp = new Date().toISOString();
+        appendFileSync('position_detail.log', `${timestamp} - ${JSON.stringify(data)}\n`);
+    } catch (e) {
+        console.error(`Error opening log file: ${e}`);
+    }
+}
+
+function subscribeFeedData2(data) {
+    try {
+        const timestamp = new Date().toISOString();
+        appendFileSync('websocket2.log', `${timestamp} - ${JSON.stringify(data)}\n`);
+    } catch (e) {
+        console.error(`Error opening log file: ${e}`);
+    }
+}
+
+function subscribeFeedData3(data) {
+    try {
+        const timestamp = new Date().toISOString();
+        appendFileSync('websocket3.log', `${timestamp} - ${JSON.stringify(data)}\n`);
+    } catch (e) {
+        console.error(`Error opening log file: ${e}`);
+    }
+}
+
+function subscribeFeedData4(data) {
+    try {
+        const timestamp = new Date().toISOString();
+        appendFileSync('websocket4.log', `${timestamp} - ${JSON.stringify(data)}\n`);
+    } catch (e) {
+        console.error(`Error opening log file: ${e}`);
+    }
+}
+
+async function main() {
+    const userId = 'NP2997';
+
+    // Connection reference holder
+    const connectionRef = { conn: null };
+
+    // Reconnection callback
+    function onReconnectCallback(newWs) {
+        console.log("🔄 Connection reference updated");
+        connectionRef.conn = newWs;
+    }
+
+    // Create WebSocket model
+    const model = new FirstockWebSocket({
+        tokens: [],
+        option_greeks_tokens: [],
+        order_data: orderBookData,
+        position_data: positionBookData,
+        subscribe_feed_data: subscribeFeedData,
+        subscribe_option_greeks_data: subscribeOptionGreeksData,
+        on_reconnect: onReconnectCallback
+    });
+
+    // Initialize WebSocket
+    const [conn, err] = await Firstock.initializeWebsockets(userId, model);
+    connectionRef.conn = conn;
+    
+    console.log("Error:", err);
+
+    if (err) {
+        console.log(`Connection failed: ${JSON.stringify(err)}`);
+        return;
+    } else {
+        console.log("WebSocket connected successfully!");
+    }
+
+    // Subscribe to tokens
+    const subscribeErr = await Firstock.subscribe(connectionRef.conn, ["BSE:500470|NSE:26000"]);
+    console.log("Subscribe Error:", subscribeErr);
+
+    // Subscribe to option Greeks (uncomment to use)
+    // const optionErr = await Firstock.subscribeOptionGreeks(connectionRef.conn, ["NFO:44297"]);
+    // console.log("Option Greeks Subscribe Error:", optionErr);
+
+    // // Later, unsubscribe (uncomment to use)
+    // await new Promise(resolve => setTimeout(resolve, 30000));
+    // const unsubErr = await Firstock.unsubscribeOptionGreeks(connectionRef.conn, ["NFO:44283"]);
+    // console.log("Option Greeks Unsubscribe Error:", unsubErr);
+
+    // Multiple connections example (uncomment to use)
+    
+    // const model2 = new FirstockWebSocket({
+    //     tokens: [],
+    //     subscribe_feed_data: subscribeFeedData2
+    // });
+    // const [conn2, err2] = await Firstock.initializeWebsockets(userId, model2);
+    // console.log("Error:", err2);
+    
+    // const subscribeErr2 = await Firstock.subscribe(conn2, ["BSE:1"]);
+    // console.log("Error:", subscribeErr2);
+
+    // const model3 = new FirstockWebSocket({
+    //     tokens: [],
+    //     subscribe_feed_data: subscribeFeedData3
+    // });
+    // const [conn3, err3] = await Firstock.initializeWebsockets(userId, model3);
+    // console.log("Error:", err3);
+    
+    // const subscribeErr3 = await Firstock.subscribe(conn3, ["NSE:26000|BSE:1"]);
+    // console.log("Error:", subscribeErr3);
+
+    // const model4 = new FirstockWebSocket({
+    //     tokens: [],
+    //     subscribe_feed_data: subscribeFeedData4
+    // });
+    // const [conn4, err4] = await Firstock.initializeWebsockets(userId, model4);
+    // console.log("Error:", err4);
+    
+    // const subscribeErr4 = await Firstock.subscribe(conn4, ["NSE:26000"]);
+    // console.log("Error:", subscribeErr4);
+    
+    // Unsubscribe example
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    const unsubErr = await Firstock.unsubscribe(connectionRef.conn, ["BSE:500470|NSE:26000"]);
+    console.log("Unsubscribe Error:", unsubErr);
+
+    // Wait for 25 seconds
+    await new Promise(resolve => setTimeout(resolve, 200000));
+
+    // Close WebSocket connection
+    const closeErr = await Firstock.closeWebsocket(connectionRef.conn);
+    console.log("Close Error:", closeErr);
+
+    // Close additional connections (uncomment if using multiple connections)
+    // const closeErr2 = await Firstock.closeWebsocket(conn2);
+    // console.log("Close Error:", closeErr2);
+    
+    // const closeErr3 = await Firstock.closeWebsocket(conn3);
+    // console.log("Close Error:", closeErr3);
+
+    // Keep program running
+    console.log("\nWebSocket test running. Press Ctrl+C to exit.");
+    
+    // Handle graceful shutdown
+    process.on('SIGINT', async () => {
+        console.log("\nExiting...");
+        if (connectionRef.conn) {
+            await Firstock.closeWebsocket(connectionRef.conn);
+        }
+        process.exit(0);
+    });
+
+    // Keep alive - never resolves, keeps running until SIGINT
+    await new Promise(() => {});
+}
+
+// Run main function
+main().catch(error => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/config.json

@@ -1,3 +0,0 @@
-{
-  
-}