@mathieuc/tradingview 2.0.91 → 3.0.0-pre

package/src/client.js

@@ -0,0 +1,280 @@
+const WebSocket = require('ws');
+
+const misc = require('./miscRequests');
+const protocol = require('./protocol');
+
+const quoteSessionGenerator = require('./quote/session');
+const chartSessionGenerator = require('./chart/session');
+
+/**
+ * @typedef {Object} Session
+ * @prop {'quote' | 'chart' | 'replay'} type Session type
+ * @prop {(data: {}) => null} onData When there is a data
+ */
+
+/** @typedef {Object<string, Session>} SessionList Session list */
+
+/**
+ * @typedef {(t: string, p: []) => null} SendPacket Send a custom packet
+ * @param {string} t Packet type
+ * @param {string[]} p Packet data
+*/
+
+/**
+ * @typedef {Object} ClientBridge
+ * @prop {SessionList} sessions
+ * @prop {SendPacket} send
+ */
+
+/**
+ * @typedef { 'connected' | 'disconnected'
+ *  | 'logged' | 'ping' | 'data'
+ *  | 'error' | 'event'
+ * } ClientEvent
+ */
+
+module.exports = class Client {
+  #ws;
+
+  #logged = false;
+
+  /** If the client is logged in */
+  get isLogged() {
+    return this.#logged;
+  }
+
+  /** If the cient was closed */
+  get isOpen() {
+    return this.#ws.readyState === this.#ws.OPEN;
+  }
+
+  /** @type {SessionList} */
+  #sessions = {};
+
+  #callbacks = {
+    connected: [],
+    disconnected: [],
+    logged: [],
+    ping: [],
+    data: [],
+
+    error: [],
+    event: [],
+  };
+
+  /**
+   * @param {ClientEvent} ev Client event
+   * @param {...{}} data Packet data
+   */
+  #handleEvent(ev, ...data) {
+    this.#callbacks[ev].forEach((e) => e(...data));
+    this.#callbacks.event.forEach((e) => e(ev, ...data));
+  }
+
+  #handleError(...msgs) {
+    if (this.#callbacks.error.length === 0) console.error(...msgs);
+    else this.#handleEvent('error', ...msgs);
+  }
+
+  /**
+   * When client is connected
+   * @param {() => void} cb Callback
+   * @event
+   */
+  onConnected(cb) {
+    this.#callbacks.connected.push(cb);
+  }
+
+  /**
+   * When client is disconnected
+   * @param {() => void} cb Callback
+   * @event
+   */
+  onDisconnected(cb) {
+    this.#callbacks.disconnected.push(cb);
+  }
+
+  /**
+   * @typedef {Object} SocketSession
+   * @prop {string} session_id Socket session ID
+   * @prop {number} timestamp Session start timestamp
+   * @prop {number} timestampMs Session start milliseconds timestamp
+   * @prop {string} release Release
+   * @prop {string} studies_metadata_hash Studies metadata hash
+   * @prop {'json' | string} protocol Used protocol
+   * @prop {string} javastudies Javastudies
+   * @prop {number} auth_scheme_vsn Auth scheme type
+   * @prop {string} via Socket IP
+
+   * When client is logged
+   * @param {(SocketSession: SocketSession) => void} cb Callback
+   * @event
+   */
+  onLogged(cb) {
+    this.#callbacks.logged.push(cb);
+  }
+
+  /**
+   * When server is pinging the client
+   * @param {(i: number) => void} cb Callback
+   * @event
+   */
+  onPing(cb) {
+    this.#callbacks.ping.push(cb);
+  }
+
+  /**
+   * When unparsed data is received
+   * @param {(...{}) => void} cb Callback
+   * @event
+   */
+  onData(cb) {
+    this.#callbacks.data.push(cb);
+  }
+
+  /**
+   * When a client error happens
+   * @param {(...{}) => void} cb Callback
+   * @event
+   */
+  onError(cb) {
+    this.#callbacks.error.push(cb);
+  }
+
+  /**
+   * When a client event happens
+   * @param {(...{}) => void} cb Callback
+   * @event
+   */
+  onEvent(cb) {
+    this.#callbacks.event.push(cb);
+  }
+
+  #parsePacket(str) {
+    if (!this.isOpen) return;
+
+    protocol.parseWSPacket(str).forEach((packet) => {
+      if (global.TW_DEBUG) console.log('§90§30§107 CLIENT §0 PACKET', packet);
+      if (typeof packet === 'number') { // Ping
+        this.#ws.send(protocol.formatWSPacket(`~h~${packet}`));
+        this.#handleEvent('ping', packet);
+        return;
+      }
+
+      if (packet.m === 'protocol_error') { // Error
+        this.#handleError('Client critical error:', packet.p);
+        this.#ws.close();
+        return;
+      }
+
+      if (packet.m && packet.p) { // Normal packet
+        const parsed = {
+          type: packet.m,
+          data: packet.p,
+        };
+
+        const session = packet.p[0];
+
+        if (session && this.#sessions[session]) {
+          this.#sessions[session].onData(parsed);
+          return;
+        }
+      }
+
+      if (!this.#logged) {
+        this.#handleEvent('logged', packet);
+        return;
+      }
+
+      this.#handleEvent('data', packet);
+    });
+  }
+
+  #sendQueue = [];
+
+  /** @type {SendPacket} Send a custom packet */
+  send(t, p = []) {
+    this.#sendQueue.push(protocol.formatWSPacket({ m: t, p }));
+    this.sendQueue();
+  }
+
+  /** Send all waiting packets */
+  sendQueue() {
+    while (this.isOpen && this.#logged && this.#sendQueue.length > 0) {
+      const packet = this.#sendQueue.shift();
+      this.#ws.send(packet);
+    }
+  }
+
+  /**
+   * @typedef {Object} ClientOptions
+   * @prop {string} [token] User auth token (in 'sessionid' cookie)
+   * @prop {boolean} [DEBUG] Enable debug mode
+   */
+
+  /** Client object
+   * @param {ClientOptions} clientOptions TradingView client options
+   */
+  constructor(clientOptions = {}) {
+    if (clientOptions.DEBUG) global.TW_DEBUG = clientOptions.DEBUG;
+
+    this.#ws = new WebSocket('wss://widgetdata.tradingview.com/socket.io/websocket', {
+      origin: 'https://s.tradingview.com',
+    });
+
+    if (clientOptions.token) {
+      misc.getUser(clientOptions.token).then((user) => {
+        this.#sendQueue.unshift(protocol.formatWSPacket({
+          m: 'set_auth_token',
+          p: [user.authToken],
+        }));
+        this.#logged = true;
+        this.sendQueue();
+      }).catch((err) => {
+        this.#handleError('Credentials error:', err.message);
+      });
+    } else {
+      this.#sendQueue.unshift(protocol.formatWSPacket({
+        m: 'set_auth_token',
+        p: ['unauthorized_user_token'],
+      }));
+      this.#logged = true;
+      this.sendQueue();
+    }
+
+    this.#ws.on('open', () => {
+      this.#handleEvent('connected');
+      this.sendQueue();
+    });
+
+    this.#ws.on('close', () => {
+      this.#logged = false;
+      this.#handleEvent('disconnected');
+    });
+
+    this.#ws.on('message', (data) => this.#parsePacket(data));
+  }
+
+  /** @type {ClientBridge} */
+  #clientBridge = {
+    sessions: this.#sessions,
+    send: (t, p) => this.send(t, p),
+  };
+
+  /** @namespace Session */
+  Session = {
+    Quote: quoteSessionGenerator(this.#clientBridge),
+    Chart: chartSessionGenerator(this.#clientBridge),
+  };
+
+  /**
+   * Close the websocket connection
+   * @return {Promise<void>} When websocket is closed
+   */
+  end() {
+    return new Promise((cb) => {
+      this.#ws.close();
+      cb();
+    });
+  }
+};

package/{miscRequests.js → src/miscRequests.js}

@@ -1,7 +1,9 @@
 const https = require('https');
 
+const PineIndicator = require('./classes/PineIndicator');
+
 const indicators = ['Recommend.Other', 'Recommend.All', 'Recommend.MA'];
-const indicList = [];
+const builtInIndicList = [];
 
 /**
  * @param {https.RequestOptions} options HTTPS Request options
@@ -132,7 +134,7 @@ module.exports = {
   },
 
   /**
-   * @typedef {Object} SearchResult
+   * @typedef {Object} SearchMarketResult
    * @property {string} id
    * @property {string} exchange
    * @property {string} fullExchange
@@ -147,9 +149,9 @@ module.exports = {
    * Find a symbol
    * @param {string} search Keywords
    * @param {'stock' | 'futures' | 'forex' | 'cfd' | 'crypto' | 'index' | 'economic'} [filter]
-   * @returns {Promise<SearchResult[]>} Search results
+   * @returns {Promise<SearchMarketResult[]>} Search results
    */
-  async search(search, filter = '') {
+  async searchMarket(search, filter = '') {
     const data = await request({
       host: 'symbol-search.tradingview.com',
       path: `/symbol_search/?text=${search.replace(/ /g, '%20')}&type=${filter}`,
@@ -179,7 +181,7 @@ module.exports = {
   },
 
   /**
-   * @typedef {Object} IndicatorResult
+   * @typedef {Object} SearchIndicatorResult
    * @property {string} id Script ID
    * @property {string} version Script version
    * @property {string} name Script complete name
@@ -187,18 +189,20 @@ module.exports = {
    * @property {string} image Image ID https://tradingview.com/i/${image}
    * @property {string | ''} source Script source (if available)
    * @property {'study' | 'strategy'} type Script type (study / strategy)
-   * @property {'open_source' | 'closed_source' | 'invite_only' | 'other'} access Script access type
+   * @property {'open_source' | 'closed_source' | 'invite_only'
+   *  | 'private' | 'other'} access Script access type
+   * @property {() => Promise<PineIndicator>} get Get the full indicator informations
    */
 
   /**
    * Find an indicator
    * @param {string} search Keywords
-   * @returns {Promise<IndicatorResult[]>} Search results
+   * @returns {Promise<SearchIndicatorResult[]>} Search results
    */
   async searchIndicator(search = '') {
-    if (!indicList.length) {
+    if (!builtInIndicList.length) {
       await Promise.all(['standard', 'candlestick', 'fundamental'].map(async (type) => {
-        indicList.push(...await request({
+        builtInIndicList.push(...await request({
           host: 'pine-facade.tradingview.com',
           path: `/pine-facade/list/?filter=${type}`,
         }));
@@ -215,7 +219,7 @@ module.exports = {
     }
 
     return [
-      ...indicList.filter((i) => (
+      ...builtInIndicList.filter((i) => (
         norm(i.scriptName).includes(norm(search))
         || norm(i.extra.shortDescription).includes(norm(search))
       )).map((ind) => ({
@@ -230,6 +234,9 @@ module.exports = {
         access: 'closed_source',
         source: '',
         type: (ind.extra && ind.extra.kind) ? ind.extra.kind : 'study',
+        get() {
+          return module.exports.getIndicator(ind.scriptIdPart, ind.version);
+        },
       })),
 
       ...data.results.map((ind) => ({
@@ -244,42 +251,20 @@ module.exports = {
         access: ['open_source', 'closed_source', 'invite_only'][ind.access - 1] || 'other',
         source: ind.scriptSource,
         type: (ind.extra && ind.extra.kind) ? ind.extra.kind : 'study',
+        get() {
+          return module.exports.getIndicator(ind.scriptIdPart, ind.version);
+        },
       })),
     ];
   },
 
-  /**
-   * @typedef {Object} indicatorInput
-   * @property {string} name
-   * @property {string} inline Inline name
-   * @property { 'text' | 'source' | 'integer' | 'float' | 'resolution' | 'bool' } type
-   * @property {string | number | boolean} value
-   * @property {string | number | boolean} defVal
-   * @property {boolean} hidden
-   * @property {boolean} isFake
-   * @property {string[]} [options]
-   */
-
-  /**
-   * @typedef {Object} Indicator
-   * @property {string} pineId Indicator ID
-   * @property {string} pineVersion Indicator version
-   * @property {string} description Indicator description
-   * @property {string} shortDescription Indicator short description
-   * @property {string} typeID Indicator script type ID
-   * @property {Object<string, indicatorInput>} inputs Indicator inputs
-   * @property {Object<string, string>} plots Indicator plots
-   * @property {string} script Indicator script
-   */
-
   /**
    * Get an indicator
    * @param {string} id Indicator ID (Like: PUB;XXXXXXXXXXXXXXXXXXXXX)
-   * @param {string} version Wanted version of the indicator
-   * @param {'study' | 'strategy'} [type] Script type
-   * @returns {Promise<Indicator>} Indicator
+   * @param {'last' | string} [version] Wanted version of the indicator
+   * @returns {Promise<PineIndicator>} Indicator
    */
-  async getIndicator(id, version, settings = [], type = 'study') {
+  async getIndicator(id, version = 'last') {
     const indicID = id.replace(/ |%/g, '%25');
 
     let data = await request({
@@ -294,26 +279,24 @@ module.exports = {
     }
 
     if (!data.success || !data.result.metaInfo || !data.result.metaInfo.inputs) {
-      console.error(data);
-      throw new Error('Inexistent or unsupported indicator');
+      throw new Error(`Inexistent or unsupported indicator: "${data.reason}"`);
     }
 
     const inputs = {};
 
     data.result.metaInfo.inputs.forEach((input) => {
       if (['text', 'pineId', 'pineVersion'].includes(input.id)) return;
-      const inline = input.inline || input.name.replace(/ /g, '_').replace(/[^a-zA-Z0-9_]/g, '');
-
-      const i = parseInt(input.id.replace(/[^0-9]/g, ''), 10);
 
       inputs[input.id] = {
         name: input.name,
+        inline: input.inline || input.name.replace(/ /g, '_').replace(/[^a-zA-Z0-9_]/g, ''),
+        internalID: input.internalID,
+        tooltip: input.tooltip,
+
         type: input.type,
-        value: settings[input.internalID] ?? settings[i] ?? input.defval,
-        defVal: input.defval,
-        hidden: !!input.isHidden,
+        value: input.defval,
+        isHidden: !!input.isHidden,
         isFake: !!input.isFake,
-        inline,
       };
 
       if (input.options) inputs[input.id].options = input.options;
@@ -322,22 +305,37 @@ module.exports = {
     const plots = {};
 
     Object.keys(data.result.metaInfo.styles).forEach((plotId) => {
-      plots[plotId] = data.result.metaInfo.styles[plotId].title.replace(/ /g, '_').replace(/[^a-zA-Z0-9_]/g, '');
+      const plotTitle = data
+        .result
+        .metaInfo
+        .styles[plotId]
+        .title
+        .replace(/ /g, '_')
+        .replace(/[^a-zA-Z0-9_]/g, '');
+
+      const titles = Object.values(plots);
+
+      if (titles.includes(plotTitle)) {
+        let i = 2;
+        while (titles.includes(`${plotTitle}_${i}`)) i += 1;
+        plots[plotId] = `${plotTitle}_${i}`;
+      } else plots[plotId] = plotTitle;
+    });
+
+    data.result.metaInfo.plots.forEach((plot) => {
+      if (!plot.target) return;
+      plots[plot.id] = `${plots[plot.target] ?? plot.target}_${plot.type}`;
     });
 
-    return {
-      pineId: indicID,
-      pineVersion: version,
+    return new PineIndicator({
+      pineId: data.result.metaInfo.scriptIdPart || indicID,
+      pineVersion: data.result.metaInfo.pine.version || version,
       description: data.result.metaInfo.description,
       shortDescription: data.result.metaInfo.shortDescription,
-      typeID: {
-        study: 'Script@tv-scripting-101!',
-        strategy: 'StrategyScript@tv-scripting-101!',
-      }[type] || type,
       inputs,
       plots,
       script: data.result.ilTemplate,
-    };
+    });
   },
 
   /**
@@ -404,6 +402,49 @@ module.exports = {
     });
   },
 
+  /**
+   * Get user's private indicators from a 'sessionid' cookie
+   * @param {string} session User 'sessionid' cookie
+   * @returns {Promise<SearchIndicatorResult[]>} Search results
+   */
+  async getPrivateIndicators(session) {
+    return new Promise((cb, err) => {
+      https.get('https://pine-facade.tradingview.com/pine-facade/list?filter=saved', {
+        headers: { cookie: `sessionid=${session}` },
+      }, (res) => {
+        let rs = '';
+        res.on('data', (d) => { rs += d; });
+        res.on('end', async () => {
+          try {
+            rs = JSON.parse(rs);
+          } catch (error) {
+            err(new Error('Can\'t parse private indicator list'));
+            return;
+          }
+
+          cb(rs.map((ind) => ({
+            id: ind.scriptIdPart,
+            version: ind.version,
+            name: ind.scriptName,
+            author: {
+              id: -1,
+              username: '@ME@',
+            },
+            image: ind.imageUrl,
+            access: 'private',
+            source: ind.scriptSource,
+            type: (ind.extra && ind.extra.kind) ? ind.extra.kind : 'study',
+            get() {
+              return module.exports.getIndicator(ind.scriptIdPart, ind.version);
+            },
+          })));
+        });
+
+        res.on('error', err);
+      }).end();
+    });
+  },
+
   /**
    * User credentials
    * @typedef {Object} UserCredentials

package/src/protocol.js

@@ -0,0 +1,54 @@
+const JSZip = require('jszip');
+
+/**
+ * @typedef {Object} TWPacket
+ * @prop {string} [m] Packet type
+ * @prop {[session: string, {}]} [p] Packet data
+ */
+
+module.exports = {
+  /**
+   * Parse websocket packet
+   * @param {string} str Websocket raw data
+   * @returns {TWPacket[]} TradingView packets
+   */
+  parseWSPacket(str) {
+    return str.replace(/~h~/g, '').split(/~m~[0-9]{1,}~m~/g)
+      .map((p) => {
+        if (!p) return false;
+        try {
+          return JSON.parse(p);
+        } catch (error) {
+          console.warn('Cant parse', p);
+          return false;
+        }
+      })
+      .filter((p) => p);
+  },
+
+  /**
+   * Format websocket packet
+   * @param {TWPacket} packet TradingView packet
+   * @returns {string} Websocket raw data
+   */
+  formatWSPacket(packet) {
+    const msg = typeof packet === 'object'
+      ? JSON.stringify(packet)
+      : packet;
+    return `~m~${msg.length}~m~${msg}`;
+  },
+
+  /**
+   * Parse compressed data
+   * @param {string} data Compressed data
+   * @returns {Promise<{}>} Parsed data
+   */
+  async parseCompressed(data) {
+    const zip = new JSZip();
+    return JSON.parse(
+      await (
+        await zip.loadAsync(data, { base64: true })
+      ).file('').async('text'),
+    );
+  },
+};