metaapi.cloud-sdk
Version:
SDK for MetaApi, a professional cloud forex API which includes MetaTrader REST API and MetaTrader websocket API. Supports both MetaTrader 5 (MT5) and MetaTrader 4 (MT4). CopyFactory copy trading API included. (https://metaapi.cloud)
177 lines (176 loc) • 23.5 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return StreamingMetaApiConnectionInstance;
}
});
const _logger = /*#__PURE__*/ _interop_require_default(require("../logger"));
const _metaApiConnectionInstance = /*#__PURE__*/ _interop_require_default(require("./metaApiConnectionInstance"));
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
let StreamingMetaApiConnectionInstance = class StreamingMetaApiConnectionInstance extends _metaApiConnectionInstance.default {
/**
* Opens the connection. Can only be called the first time, next calls will be ignored.
* @return {Promise} promise resolving when the connection is opened
*/ async connect() {
if (!this._opened) {
this._opened = true;
try {
await this._metaApiConnection.connect(this.instanceId);
} catch (err) {
await this.close();
throw err;
}
}
}
/**
* Clears the order and transaction history of a specified application and removes application
* @return {Promise} promise resolving when the history is cleared and application is removed
*/ removeApplication() {
return this._metaApiConnection.removeApplication();
}
/**
* Subscribes on market data of specified symbol (see
* https://metaapi.cloud/docs/client/websocket/marketDataStreaming/subscribeToMarketData/).
* @param {String} symbol symbol (e.g. currency pair or an index)
* @param {Array<MarketDataSubscription>} subscriptions array of market data subscription to create or update. Please
* note that this feature is not fully implemented on server-side yet
* @param {number} [timeoutInSeconds] timeout to wait for prices in seconds, default is 30
* @param {boolean} [waitForQuote] if set to false, the method will resolve without waiting for the first quote to
* arrive. Default is to wait for quote if quotes subscription is requested.
* @returns {Promise} promise which resolves when subscription request was processed
*/ async subscribeToMarketData(symbol, subscriptions, timeoutInSeconds, waitForQuote = true) {
this._checkIsConnectionActive();
return this._metaApiConnection.subscribeToMarketData(symbol, subscriptions, timeoutInSeconds, waitForQuote);
}
/**
* Unsubscribes from market data of specified symbol (see
* https://metaapi.cloud/docs/client/websocket/marketDataStreaming/unsubscribeFromMarketData/).
* @param {String} symbol symbol (e.g. currency pair or an index)
* @param {Array<MarketDataUnsubscription>} subscriptions array of subscriptions to cancel
* @returns {Promise} promise which resolves when unsubscription request was processed
*/ unsubscribeFromMarketData(symbol, subscriptions) {
this._checkIsConnectionActive();
return this._metaApiConnection.unsubscribeFromMarketData(symbol, subscriptions);
}
/**
* Returns list of the symbols connection is subscribed to
* @returns {Array<String>} list of the symbols connection is subscribed to
*/ get subscribedSymbols() {
return this._metaApiConnection.subscribedSymbols;
}
/**
* Returns subscriptions for a symbol
* @param {string} symbol symbol to retrieve subscriptions for
* @returns {Array<MarketDataSubscription>} list of market data subscriptions for the symbol
*/ subscriptions(symbol) {
return this._metaApiConnection.subscriptions(symbol);
}
/**
* Sends client uptime stats to the server.
* @param {Object} uptime uptime statistics to send to the server
* @returns {Promise} promise which resolves when uptime statistics is submitted
*/ saveUptime(uptime) {
this._checkIsConnectionActive();
return this._websocketClient.saveUptime(this._metaApiConnection.account.id, uptime);
}
/**
* Returns local copy of terminal state
* @returns {TerminalState} local copy of terminal state
*/ get terminalState() {
return this._metaApiConnection.terminalState;
}
/**
* Returns local history storage
* @returns {HistoryStorage} local history storage
*/ get historyStorage() {
return this._metaApiConnection.historyStorage;
}
/**
* Adds synchronization listener
* @param {SynchronizationListener} listener synchronization listener to add
*/ addSynchronizationListener(listener) {
this._synchronizationListeners.push(listener);
this._websocketClient.addSynchronizationListener(this._metaApiConnection.account.id, listener);
}
/**
* Removes synchronization listener for specific account
* @param {SynchronizationListener} listener synchronization listener to remove
*/ removeSynchronizationListener(listener) {
this._synchronizationListeners = this._synchronizationListeners.filter((l)=>l !== listener);
this._websocketClient.removeSynchronizationListener(this._metaApiConnection.account.id, listener);
}
/**
* @typedef {Object} SynchronizationOptions
* @property {String} [applicationPattern] application regular expression pattern, default is .*
* @property {String} [synchronizationId] synchronization id, last synchronization request id will be used by
* default
* @property {Number} [instanceIndex] index of an account instance to ensure synchronization on, default is to wait
* for the first instance to synchronize
* @property {Number} [timeoutInSeconds] wait timeout in seconds, default is 5m
* @property {Number} [intervalInMilliseconds] interval between account reloads while waiting for a change, default is 1s
*/ /**
* Waits until synchronization to MetaTrader terminal is completed
* @param {SynchronizationOptions} opts synchronization options
* @return {Promise} promise which resolves when synchronization to MetaTrader terminal is completed
* @throws {TimeoutError} if application failed to synchronize with the teminal within timeout allowed
*/ // eslint-disable-next-line complexity
async waitSynchronized(opts) {
this._checkIsConnectionActive();
return this._metaApiConnection.waitSynchronized(opts);
}
/**
* Queues an event for processing among other synchronization events within same account
* @param {String} name event label name
* @param {Function} callable async or regular function to execute
*/ queueEvent(name, callable) {
this._websocketClient.queueEvent(this._metaApiConnection.account.id, name, callable);
}
/**
* Closes the connection. The instance of the class should no longer be used after this method is invoked.
*/ async close() {
if (!this._closed) {
for (let listener of this._synchronizationListeners){
this._websocketClient.removeSynchronizationListener(this._metaApiConnection.account.id, listener);
}
this._closed = true;
await this._metaApiConnection.close(this.instanceId);
}
}
/**
* Returns synchronization status
* @return {boolean} synchronization status
*/ get synchronized() {
return this._metaApiConnection.synchronized;
}
/**
* Returns MetaApi account
* @return {MetatraderAccount} MetaApi account
*/ get account() {
return this._metaApiConnection.account;
}
/**
* Returns connection health monitor instance
* @return {ConnectionHealthMonitor} connection health monitor instance
*/ get healthMonitor() {
return this._metaApiConnection.healthMonitor;
}
/**
* Constructs MetaApi MetaTrader streaming Api connection instance
* @param {MetaApiWebsocketClient} websocketClient MetaApi websocket client
* @param {StreamingMetaApiConnection} metaApiConnection streaming MetaApi connection
*/ constructor(websocketClient, metaApiConnection){
super(websocketClient, metaApiConnection);
this._metaApiConnection = metaApiConnection;
this._synchronizationListeners = [];
this._logger = _logger.default.getLogger("StreamingMetaApiConnectionInstance");
}
};
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["<anon>"],"sourcesContent":["'use strict';\n\nimport TerminalState from './terminalState';\nimport ConnectionHealthMonitor from './connectionHealthMonitor';\nimport LoggerManager from '../logger';\nimport MetaApiConnectionInstance from './metaApiConnectionInstance';\n\n/**\n * Exposes MetaApi MetaTrader streaming API connection instance to consumers\n */\nexport default class StreamingMetaApiConnectionInstance extends MetaApiConnectionInstance {\n\n  /**\n   * Constructs MetaApi MetaTrader streaming Api connection instance\n   * @param {MetaApiWebsocketClient} websocketClient MetaApi websocket client\n   * @param {StreamingMetaApiConnection} metaApiConnection streaming MetaApi connection\n   */\n  constructor(websocketClient, metaApiConnection) {\n    super(websocketClient, metaApiConnection);\n    this._metaApiConnection = metaApiConnection;\n    this._synchronizationListeners = [];\n    this._logger = LoggerManager.getLogger('StreamingMetaApiConnectionInstance');\n  }\n\n  /**\n   * Opens the connection. Can only be called the first time, next calls will be ignored.\n   * @return {Promise} promise resolving when the connection is opened\n   */\n  async connect() {\n    if (!this._opened) {\n      this._opened = true;\n      try {\n        await this._metaApiConnection.connect(this.instanceId);\n      } catch (err) {\n        await this.close();\n        throw err;\n      }\n    }\n  }\n\n  /**\n   * Clears the order and transaction history of a specified application and removes application\n   * @return {Promise} promise resolving when the history is cleared and application is removed\n   */\n  removeApplication() {\n    return this._metaApiConnection.removeApplication();\n  }\n\n  /**\n   * Subscribes on market data of specified symbol (see\n   * https://metaapi.cloud/docs/client/websocket/marketDataStreaming/subscribeToMarketData/).\n   * @param {String} symbol symbol (e.g. currency pair or an index)\n   * @param {Array<MarketDataSubscription>} subscriptions array of market data subscription to create or update. Please\n   * note that this feature is not fully implemented on server-side yet\n   * @param {number} [timeoutInSeconds] timeout to wait for prices in seconds, default is 30\n   * @param {boolean} [waitForQuote] if set to false, the method will resolve without waiting for the first quote to\n   * arrive. Default is to wait for quote if quotes subscription is requested.\n   * @returns {Promise} promise which resolves when subscription request was processed\n   */\n  async subscribeToMarketData(symbol, subscriptions, timeoutInSeconds, waitForQuote = true) {\n    this._checkIsConnectionActive();\n    return this._metaApiConnection.subscribeToMarketData(symbol, subscriptions, timeoutInSeconds, waitForQuote);\n  }\n\n  /**\n   * Unsubscribes from market data of specified symbol (see\n   * https://metaapi.cloud/docs/client/websocket/marketDataStreaming/unsubscribeFromMarketData/).\n   * @param {String} symbol symbol (e.g. currency pair or an index)\n   * @param {Array<MarketDataUnsubscription>} subscriptions array of subscriptions to cancel\n   * @returns {Promise} promise which resolves when unsubscription request was processed\n   */\n  unsubscribeFromMarketData(symbol, subscriptions) {\n    this._checkIsConnectionActive();\n    return this._metaApiConnection.unsubscribeFromMarketData(symbol, subscriptions);\n  }\n\n  /**\n   * Returns list of the symbols connection is subscribed to\n   * @returns {Array<String>} list of the symbols connection is subscribed to\n   */\n  get subscribedSymbols() {\n    return this._metaApiConnection.subscribedSymbols;\n  }\n\n  /**\n   * Returns subscriptions for a symbol\n   * @param {string} symbol symbol to retrieve subscriptions for\n   * @returns {Array<MarketDataSubscription>} list of market data subscriptions for the symbol\n   */\n  subscriptions(symbol) {\n    return this._metaApiConnection.subscriptions(symbol);\n  }\n\n  /**\n   * Sends client uptime stats to the server.\n   * @param {Object} uptime uptime statistics to send to the server\n   * @returns {Promise} promise which resolves when uptime statistics is submitted\n   */\n  saveUptime(uptime) {\n    this._checkIsConnectionActive();\n    return this._websocketClient.saveUptime(this._metaApiConnection.account.id, uptime);\n  }\n\n  /**\n   * Returns local copy of terminal state\n   * @returns {TerminalState} local copy of terminal state\n   */\n  get terminalState() {\n    return this._metaApiConnection.terminalState;\n  }\n\n  /**\n   * Returns local history storage\n   * @returns {HistoryStorage} local history storage\n   */\n  get historyStorage() {\n    return this._metaApiConnection.historyStorage;\n  }\n\n  /**\n   * Adds synchronization listener\n   * @param {SynchronizationListener} listener synchronization listener to add\n   */\n  addSynchronizationListener(listener) {\n    this._synchronizationListeners.push(listener);\n    this._websocketClient.addSynchronizationListener(this._metaApiConnection.account.id, listener);\n  }\n\n  /**\n   * Removes synchronization listener for specific account\n   * @param {SynchronizationListener} listener synchronization listener to remove\n   */\n  removeSynchronizationListener(listener) {\n    this._synchronizationListeners = this._synchronizationListeners.filter(l => l !== listener);\n    this._websocketClient.removeSynchronizationListener(this._metaApiConnection.account.id, listener);\n  }\n\n  /**\n   * @typedef {Object} SynchronizationOptions\n   * @property {String} [applicationPattern] application regular expression pattern, default is .*\n   * @property {String} [synchronizationId] synchronization id, last synchronization request id will be used by\n   * default\n   * @property {Number} [instanceIndex] index of an account instance to ensure synchronization on, default is to wait\n   * for the first instance to synchronize\n   * @property {Number} [timeoutInSeconds] wait timeout in seconds, default is 5m\n   * @property {Number} [intervalInMilliseconds] interval between account reloads while waiting for a change, default is 1s\n   */\n\n  /**\n   * Waits until synchronization to MetaTrader terminal is completed\n   * @param {SynchronizationOptions} opts synchronization options\n   * @return {Promise} promise which resolves when synchronization to MetaTrader terminal is completed\n   * @throws {TimeoutError} if application failed to synchronize with the teminal within timeout allowed\n   */\n  // eslint-disable-next-line complexity\n  async waitSynchronized(opts) {\n    this._checkIsConnectionActive();\n    return this._metaApiConnection.waitSynchronized(opts);\n  }\n\n  /**\n   * Queues an event for processing among other synchronization events within same account\n   * @param {String} name event label name\n   * @param {Function} callable async or regular function to execute\n   */\n  queueEvent(name, callable) {\n    this._websocketClient.queueEvent(this._metaApiConnection.account.id, name, callable);\n  }\n\n  /**\n   * Closes the connection. The instance of the class should no longer be used after this method is invoked.\n   */\n  async close() {\n    if (!this._closed){\n      for (let listener of this._synchronizationListeners) {\n        this._websocketClient.removeSynchronizationListener(this._metaApiConnection.account.id, listener);\n      }\n      this._closed = true;\n      await this._metaApiConnection.close(this.instanceId);\n    }\n  }\n\n  /**\n   * Returns synchronization status\n   * @return {boolean} synchronization status\n   */\n  get synchronized() {\n    return this._metaApiConnection.synchronized;\n  }\n\n  /**\n   * Returns MetaApi account\n   * @return {MetatraderAccount} MetaApi account\n   */\n  get account() {\n    return this._metaApiConnection.account;\n  }\n\n  /**\n   * Returns connection health monitor instance\n   * @return {ConnectionHealthMonitor} connection health monitor instance\n   */\n  get healthMonitor() {\n    return this._metaApiConnection.healthMonitor;\n  }\n\n}\n"],"names":["StreamingMetaApiConnectionInstance","MetaApiConnectionInstance","connect","_opened","_metaApiConnection","instanceId","err","close","removeApplication","subscribeToMarketData","symbol","subscriptions","timeoutInSeconds","waitForQuote","_checkIsConnectionActive","unsubscribeFromMarketData","subscribedSymbols","saveUptime","uptime","_websocketClient","account","id","terminalState","historyStorage","addSynchronizationListener","listener","_synchronizationListeners","push","removeSynchronizationListener","filter","l","waitSynchronized","opts","queueEvent","name","callable","_closed","synchronized","healthMonitor","constructor","websocketClient","metaApiConnection","_logger","LoggerManager","getLogger"],"mappings":"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"}