fyers-api-v3 1.0.0

package/config/config.js

@@ -0,0 +1,26 @@
+module.exports.Config = {
+    "API":"https://api.fyers.in/api/v2",
+    "SYNC_API":"https://api-t1.fyers.in/api/v3",
+    "data_Api": "https://api.fyers.in/data-rest/v2",
+    "data_Api1": "https://api-t1.fyers.in/data",
+    "HSM_SOCKET": "wss://socket.fyers.in/hsm/v1-5/prod",
+    "Order_SOCKET": "wss://socket.fyers.in/trade/v3",
+    "get_profile" : "/profile",
+    "tradebook" : "/tradebook",
+    "positions" : "/positions",
+    "holdings" : "/holdings",
+    "convertPosition" : "/positions",
+    "funds" : "/funds",
+    "gtt":"/gtt",
+    "orders" : "/orders",
+    "orders_sync" : "/orders/sync",
+    "orderStatus" : "/order-status",
+    "marketStatus" : "/marketStatus",
+    "auth" : "/generate-authcode",
+    "generateAccessToken" : "/validate-authcode",
+    "exitPositions" : "/positions",
+    "multi_orders" : "/multi-order/sync",
+    "history" : "/history",
+    "quotes" : "/quotes",
+    "market_depth" : "/depth"
+}

package/errorHandler/errorHandler.js

@@ -0,0 +1,37 @@
+class ErrorHandler {
+    #genricErrorStructure = {s: 'error', code: 500, message: 'Genric Error'}
+
+
+    constructor(errorObject) {
+        this.errorObject = errorObject
+    }
+
+    getError() {
+        if (this.errorObject && this.errorObject.response && this.errorObject.response.data) {
+            return this.errorObject.response.data;
+        } else if (this.errorObject && (this.errorObject.code === 'ENOTFOUND')) {
+            return this.setError(this.errorObject.errno, this.errorObject.code)
+        }else if(this.errorObject.code){
+            return this.setError(null, this.errorObject.code)
+        } else if(this.errorObject){
+            return this.setError(null, this.errorObject)
+        } {
+            return this.#genricErrorStructure
+        }
+    }
+
+
+    setError(code, message) {
+        if(code){
+            this.#genricErrorStructure.code = code
+        }
+        if(message){
+            this.#genricErrorStructure.message = message
+        }
+
+        return this.#genricErrorStructure
+    }
+
+}
+
+module.exports = ErrorHandler;

package/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var fyersModel =require("./apiService/apiService.js");
+var fyersDataSocket =require("./HSM/datasocket.min.js");
+var fyersOrderSocket =require("./ordersocket/fyersSocket.js");
+
+module.exports.fyersModel = fyersModel;
+module.exports.fyersDataSocket = fyersDataSocket;
+module.exports.fyersOrderSocket = fyersOrderSocket;

package/logger/log.js

@@ -0,0 +1,58 @@
+const fs = require('fs');
+const path = require('path');
+
+class Logger {
+  constructor(logDirectory = process.cwd()) {
+    const currentDate = new Date().toISOString().slice(0, 10);
+    this.logFileName =  `${currentDate}.log`;
+    this.logFilePath = path.join(logDirectory, this.logFileName);
+  }
+
+  log(level, message, data, functionName) {
+    const logEntry = {
+      level,
+      datetime: new Date().toISOString(),
+      message,
+      data,
+      functionName,
+    };
+
+    const logString = JSON.stringify(logEntry) + '\n';
+
+    fs.appendFile(this.logFilePath, logString, (err) => {
+      if (err) {
+        console.error('Failed to write to log file:', err);
+      }
+    });
+  }
+
+  debug(message, data, functionName) {
+    this.log('debug', message, data, functionName);
+  }
+
+  info(message, data, functionName) {
+    this.log('info', message, data, functionName);
+  }
+
+  warn(message, data, functionName) {
+    this.log('warn', message, data, functionName);
+  }
+
+  error(message, data, functionName) {
+    this.log('error', message, data, functionName);
+  }
+}
+
+// Usage example
+// const logger = new Logger(undefined); // Log file will be created in the current working directory with the name "YYYY-MM-DD.log"
+// logger.debug('Debug message', { example: 'data' }, 'myFunction');
+// logger.info('Info message', null, 'myFunction');
+// logger.warn('Warning message', { example: 'data' }, 'myFunction');
+// logger.error('Error message', { example: 'data' }, 'myFunction');
+
+// const customLogDirectory = '/home/nihar/fyers_project/node SDK/logger';
+// const customLogger = new Logger(customLogDirectory);
+// customLogger.debug('Custom debug message', null, 'myFunction');
+// customLogger.info('Custom info message', { example: 'data' }, 'myFunction');
+
+module.exports = Logger

package/ordersocket/fyersSocket.js

@@ -0,0 +1,302 @@
+const WebSocket = require('ws');
+let Logger = require("../logger/log.js")
+let { Config } = require("../config/config");
+let mapper =require("./mapper.js")
+var reconnectiontries = 0
+const maxreconnectiontries = 5
+const ordstatobj={11: 4, 12: 4, 20: 4, 21: 4, 22: 6, 23: 6, 24: 6, 25: 6, 26: 6, 90: 2,
+    91: 1, 92: 5, 93: 5, 94: 5, 51: 6, 52: 6, 53: 6, 54: 6, 55: 6, 61: 6, 62: 6, 63: 6,
+    64: 6, 71: 6, 72: 6, 73: 1}
+function datamapper(a,b){
+    const result = {};
+
+    for (const key of Object.keys(b)) {
+      if (a.hasOwnProperty(key)) {
+        result[b[key]] = a[key];
+      }
+    }
+  
+    return result;
+}
+/**
+ * Class to access order update websocket.
+ * @class
+ */
+class FyersOrderSocket {
+    constructor(authorizationKey, logpath = undefined) {
+        this.url = Config.Order_SOCKET;
+        this.authorizationKey = authorizationKey;
+        this.ws = null;
+        this.onErrorCallback = null;
+        this.onCloseCallback = null;
+        this.onMessageCallback = null;
+        this.onOpenCallback = null;
+        this.orderscallback = null;
+        this.LogPath = logpath;
+        this.Logger = new Logger(this.LogPath);
+        this.positionscallback = null;
+        this.tradescallback = null;
+        this.isPingEnabled = true;
+        this.pingInterval = null;
+        this.autoreconnectinterval = null;
+        this.orderUpdates = "orders"
+        this.tradeUpdates = "trades"
+        this.positionUpdates = "positions"
+        this.edis="edis"
+        this.pricealerts="pricealerts"
+    }
+
+    /**
+     * called to connect to the order socket
+     */
+    connect() {
+        const funcname = "connect"
+        const logger = this.Logger
+        try {
+            logger.debug("initalizing connection to socket", { "accesstoken": this.authorizationKey }, funcname)
+            this.ws = new WebSocket(this.url, {
+                headers: {
+                    Authorization: this.authorizationKey,
+                },
+            });
+            this.ws.binaryType = 'arraybuffer';
+            this.ws.on('error', (error) => {
+                if (this.onErrorCallback) {
+                    this.onErrorCallback(error);
+                }
+                else {
+                    console.log("error occoured", error)
+                }
+            });
+
+            this.ws.on('close', (event) => {
+                this.stopPing()
+                if (this.onCloseCallback) {
+                    this.onCloseCallback(event);
+                }
+                else {
+                    console.log("ws closed", event)
+                }
+            });
+
+            this.ws.on('message', (message) => {
+                const data = message.toString();
+                if (data === 'pong') {
+                    return
+                }
+                else {
+                    var parseddata = JSON.parse(data)
+                    if (parseddata.hasOwnProperty("orders")) {
+                        var orderdata=datamapper(parseddata["orders"],mapper.orders)
+                        orderdata.status=ordstatobj[orderdata.status]
+                        orderdata['orderNumStatus']=orderdata.id+':'+orderdata.status
+                        if (this.orderscallback) {
+                            this.orderscallback({"s":"ok","orders":orderdata})
+                        }
+                        else {
+                            console.log("Orders_internal", {"s":"ok","orders":orderdata})
+                        }
+                    }
+                    else if (parseddata.hasOwnProperty("positions")) {
+                        var positiondata=datamapper(parseddata["positions"],mapper.position)
+                        if (this.positionscallback) {
+                            this.positionscallback({"s":"ok","positions":positiondata})
+                        }
+                        else {
+                            console.log("positions_internal", {"s":"ok","positions":positiondata})
+                        }
+                    }
+                    else if (parseddata.hasOwnProperty("trades")) {
+                        var tradebookdata=datamapper(parseddata["trades"],mapper.tradebook)
+                        if (this.tradescallback) {
+                            this.tradescallback({"s":"ok","trades":tradebookdata})
+                        }
+                        else {
+                            console.log("trades_internal", {"s":"ok","trades":tradebookdata})
+                        }
+                    }
+                    else {
+                        if (this.onMessageCallback) {
+                            this.onMessageCallback(parseddata);
+                        }
+                        else {
+                            console.log("message_internal", parseddata)
+                        }
+                    }
+
+                }
+            });
+
+            this.ws.on('open', () => {
+                reconnectiontries = 0
+                if (this.onOpenCallback) {
+                    this.onOpenCallback();
+                }
+                else {
+                    console.log("connected")
+                }
+
+                if (this.isPingEnabled) {
+                    this.startPing();
+                }
+            });
+        }
+        catch (error) {
+            console.log(`Error occured ${funcname}: ${error}`)
+            logger.error("unexpected error on connect function", error, funcname)
+        }
+    }
+
+    /**
+     * used to define onmessage,onerror,onopen,onclose for websocket.
+     * @param {string} onwhat - defines for what the callback function is.
+     * @param {Function} callback - the callback function.
+     * @throws  error message if onwhat is not valid.
+     */
+    on(onwhat, callback) {
+        const funcname = "on"
+        const logger = this.Logger
+        try {
+            if (onwhat === 'error') {
+                this.onErrorCallback = callback;
+            }
+            else if (onwhat === 'general') {
+                this.onMessageCallback = callback;
+            }
+            else if (onwhat === 'connect') {
+                this.onOpenCallback = callback;
+            }
+            else if (onwhat === 'close') {
+                this.onCloseCallback = callback;
+            }
+            else if (onwhat === 'orders') {
+                this.orderscallback = callback;
+            }
+            else if (onwhat === 'trades') {
+                this.tradescallback = callback;
+            }
+            else if (onwhat === 'positions') {
+                this.positionscallback = callback;
+            }
+            else {
+                console.log("incorrect value passed", onwhat)
+                logger.error("wrong onwhat passed", { "onwhat": onwhat }, funcname)
+            }
+        }
+        catch (error) {
+            logger.error("unexpected error on 'on' function", error, funcname)
+        }
+    }
+
+    /**
+     * call to check if datasocket is connected
+     */
+    isConnected() {
+        return this.ws && this.ws.readyState === WebSocket.OPEN;
+    }
+
+    /**
+     * starts ping messages to ws
+     */
+    startPing() {
+        this.pingInterval = setInterval(() => {
+            if (this.isConnected()) {
+                this.ws.send("ping");
+            }
+        }, 1000);
+    }
+
+    /**
+     * stops pinging mechanism
+     */
+    stopPing() {
+        clearInterval(this.pingInterval);
+    }
+
+    /**
+     * Subscribe to socket.
+     * @param {Array|string} towhat - array or string of what you want to subscribe to.
+     */
+    subscribe(towhat) {
+        const funcname = "subscribe"
+        const logger = this.Logger
+        try {
+            if (this.isConnected()) {
+                logger.debug("trying to subscribe to", { "towhat": towhat }, funcname)
+                if (towhat.constructor === Array) {
+                    this.ws.send(JSON.stringify({ "T": "SUB_ORD", "SLIST": towhat, "SUB_T": 1 }));
+                }
+                else {
+                    this.ws.send(JSON.stringify({ "T": "SUB_ORD", "SLIST": [towhat], "SUB_T": 1 }));
+                }
+            }
+            else {
+                logger.error("websocket is not connected", { "towhat": towhat }, funcname)
+                console.log('Cannot send message. WebSocket is not connected.');
+            }
+        }
+        catch (error) {
+
+            logger.error("unexpected error on subscribe function", error, funcname)
+        }
+    }
+
+    /**
+     * Unsubscribe to socket.
+     * @param {Array|string} towhat - array or string of what you want to unsubscribe to.
+     */
+    unsubscribe(towhat) {
+        const funcname = "unsubscribe"
+        const logger = this.Logger
+        try {
+            if (this.isConnected()) {
+                if (towhat.constructor === Array) {
+                    logger.debug("trying to unsubscribe to", { "towhat": towhat }, funcname)
+                    this.ws.send(JSON.stringify({ "T": "SUB_ORD", "SLIST": towhat, "SUB_T": -1 }));
+                }
+                else {
+                    this.ws.send(JSON.stringify({ "T": "SUB_ORD", "SLIST": [towhat], "SUB_T": -1 }));
+                }
+            }
+            else {
+                logger.error("websocket is not connected", { "towhat": towhat }, funcname)
+                console.log('Cannot send message. WebSocket is not connected.');
+            }
+        }
+        catch (error) {
+            logger.error("unexpected error on unsubscribe function", error, funcname)
+        }
+    }
+
+    /**
+     * call to close the datasocket.
+     */
+    close() {
+        if (this.ws && this.isConnected) {
+            clearInterval(this.autoreconnectinterval)
+            this.stopPing()
+            this.ws.close();
+        }
+    }
+
+    /**
+     * call to enable autoreconnect functionality of websocket.
+     */
+    autoreconnect() {
+        this.autoreconnectinterval = setInterval(() => {
+            if ((!this.isConnected()) && (reconnectiontries < maxreconnectiontries)) {
+                console.log("trying to reconnect ", reconnectiontries + 1)
+                reconnectiontries++
+                this.connect()
+            } else if (reconnectiontries >= maxreconnectiontries) {
+                console.log("max autoconnect tries exceeded")
+                clearInterval(this.autoreconnectinterval)
+                this.stopPing()
+                reconnectiontries = 0
+            }
+        }, 5000);
+
+    }
+}
+
+module.exports = FyersOrderSocket

package/ordersocket/mapper.js

@@ -0,0 +1,77 @@
+const ordersMapper = {
+    'client_id': 'clientId',
+    'id': 'id',
+    'id_parent': 'parentId',
+    'id_exchange': 'exchOrdId',
+    'qty': 'qty',
+    'qty_remaining': 'remainingQuantity',
+    'qty_filled': 'filledQty',
+    'price_limit': 'limitPrice',
+    'price_stop': 'stopPrice',
+    'tradedPrice': 'price_traded',
+    'ord_type': 'type',
+    'fy_token': 'fyToken',
+    'exchange': 'exchange',
+    'segment': 'segment',
+    'symbol': 'symbol',
+    'instrument': 'instrument',
+    'oms_msg': 'message',
+    'offline_flag': 'offlineOrder',
+    'time_oms': 'orderDateTime',
+    'validity': 'orderValidity',
+    'product_type': 'productType',
+    'tran_side': 'side',
+    'ord_status': 'status',
+    'ord_source': 'source',
+    'symbol_exch': 'ex_sym',
+    'symbol_desc': 'description'
+}
+
+const positionbookMapper = {
+    'symbol': 'symbol',
+    'id': 'id',
+    'buy_avg': 'buyAvg',
+    'buy_qty': 'buyQty',
+    'buy_val': 'buyVal',
+    'sell_avg': 'sellAvg',
+    'sell_qty': 'sellQty',
+    'sell_val': 'sellVal',
+    'net_avg': 'netAvg',
+    'net_qty': 'netQty',
+    'tran_side': 'side',
+    'qty': 'qty',
+    'product_type': 'productType',
+    'pl_realized': 'realized_profit',
+    'rbirefrate': 'rbiRefRate',
+    'fy_token': 'fyToken',
+    'exchange': 'exchange',
+    'segment': 'segment',
+    'day_buy_qty': 'dayBuyQty',
+    'day_sell_qty': 'daySellQty',
+    'cf_buy_qty': 'cfBuyQty',
+    'cf_sell_qty': 'cfSellQty',
+    'qty_multiplier': 'qtyMulti_com',
+    'pl_total': 'pl',
+    'cross_curr_flag': 'crossCurrency',
+    'pl_unrealized': 'unrealized_profit',
+}
+
+const tradebookMapper = {
+    'id_fill': 'tradeNumber',
+    'id': 'orderNumber',
+    'qty_traded': 'tradedQty',
+    'price_traded': 'tradePrice',
+    'traded_val': 'tradeValue',
+    'product_type': 'productType',
+    'client_id': 'clientId',
+    'id_exchange': 'exchangeOrderNo',
+    'ord_type': 'orderType',
+    'tran_side': 'side',
+    'symbol': 'symbol',
+    'fill_time': 'orderDateTime',
+    'fy_token': 'fyToken',
+    'exchange': 'exchange',
+    'segment': 'segment',
+}
+
+module.exports = { "orders": ordersMapper, "position": positionbookMapper, "tradebook": tradebookMapper }

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "fyers-api-v3",
+  "version": "1.0.0",
+  "description": "connect to fyers API",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.3.5",
+    "jsonwebtoken": "^9.0.1",
+    "ws": "^8.13.0"
+  },
+  "devDependencies": {
+    "javascript-obfuscator": "^4.0.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/FyersDev/fyers-api-js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/FyersDev/fyers-api-js/issues"
+  },
+  "homepage": "https://github.com/FyersDev/fyers-api-js#readme"
+}

package/sample/api.js

@@ -0,0 +1,46 @@
+var fyersModel= require("../index.js").fyersModel
+
+var fyers= new fyersModel()
+
+fyers.setAppId("QCxxxx25-1xx")
+
+fyers.setRedirectUrl("https://xxx.xxxxxxx.xxxx")
+// generate authcode
+////////////////////////////
+
+// var URL=fyers.generateAuthCode()
+
+// console.log(URL)
+
+// after getting authcode
+
+////////////////////////////
+
+// generate accesstoken
+////////////////////////////
+// var authcode=""
+
+// fyers.generate_access_token({"client_id":fyers.AppID,"secret_key":"4362L6SS2C","auth_code":authcode}).then((response)=>{
+//     console.log(response)
+// })
+////////////////////////////
+
+fyers.setAccessToken("")
+
+fyers.get_profile().then((response)=>{
+        console.log(response)
+    }).catch((err)=>{
+        console.log(err)
+    })
+    
+fyers.getQuotes(["NSE:SBIN-EQ","NSE:TCS-EQ"]).then((response)=>{
+    console.log(response)
+}).catch((err)=>{
+    console.log(err)
+})
+
+fyers.getMarketDepth({"symbol":["NSE:SBIN-EQ","NSE:TCS-EQ"],"ohlcv_flag":1}).then((response)=>{
+    console.log(response)
+}).catch((err)=>{
+    console.log(err)
+})

package/sample/datasocket.js

@@ -0,0 +1,25 @@
+let DataSocket = require("../index.js").fyersDataSocket;
+
+var skt= DataSocket.getInstance("")
+
+skt.on("connect",function(){skt.subscribe(['NSE:IDEA-EQ',"NSE:SBIN-EQ"],false,1)
+skt.mode(skt.FullMode,1)
+console.log(skt.isConnected())
+// skt.mode(skt.LiteMode,[11,12,13])
+// skt.channelresume(2)
+// skt.unsubscribe(['NSE:IDEA-EQ'],false,1)
+})
+
+skt.on("message",function(message){
+	console.log({"TEST":message})
+})
+
+skt.on("error",function(message){
+	console.log("erroris",message)
+})
+
+skt.on("close",function(){
+    console.log("socket closed")
+})
+skt.connect()
+skt.autoreconnect()

package/sample/ordersocket.js

@@ -0,0 +1,29 @@
+var fyersOrderSocket= require("../index.js").fyersOrderSocket
+
+var skt=new fyersOrderSocket("")
+
+skt.on("error",function (errmsg) {
+    console.log(errmsg)
+})
+skt.on('general',function (msg) {
+    console.log(msg)
+})
+skt.on('connect',function () {
+    skt.subscribe([skt.orderUpdates,skt.tradeUpdates,skt.positionUpdates,skt.edis,skt.pricealerts])
+    console.log(skt.isConnected())
+})
+skt.on('close',function () {
+    console.log('closed')
+})
+skt.on('orders',function (msg) {
+    console.log("orders",msg)
+})
+skt.on('trades',function (msg) {
+    console.log('trades',msg)
+})
+skt.on('positions',function (msg) {
+    console.log('positions',msg)
+})
+skt.autoreconnect()
+skt.connect()
+