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)
207 lines (206 loc) • 24.5 kB
JavaScript
'use strict';
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
Promise.resolve(value).then(_next, _throw);
}
}
function _async_to_generator(fn) {
return function() {
var self = this, args = arguments;
return new Promise(function(resolve, reject) {
var gen = fn.apply(self, args);
function _next(value) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
}
function _throw(err) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
}
_next(undefined);
});
};
}
import LoggerManager from '../logger';
import MetaApiConnectionInstance from './metaApiConnectionInstance';
let StreamingMetaApiConnectionInstance = class StreamingMetaApiConnectionInstance extends MetaApiConnectionInstance {
/**
* Opens the connection. Can only be called the first time, next calls will be ignored.
* @return {Promise} promise resolving when the connection is opened
*/ connect() {
var _this = this;
return _async_to_generator(function*() {
if (!_this._opened) {
_this._opened = true;
try {
yield _this._metaApiConnection.connect(_this.instanceId);
} catch (err) {
yield _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
*/ subscribeToMarketData(symbol, subscriptions, timeoutInSeconds, waitForQuote = true) {
var _this = this;
return _async_to_generator(function*() {
_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
waitSynchronized(opts) {
var _this = this;
return _async_to_generator(function*() {
_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.
*/ close() {
var _this = this;
return _async_to_generator(function*() {
if (!_this._closed) {
for (let listener of _this._synchronizationListeners){
_this._websocketClient.removeSynchronizationListener(_this._metaApiConnection.account.id, listener);
}
_this._closed = true;
yield _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 = LoggerManager.getLogger('StreamingMetaApiConnectionInstance');
}
};
/**
* Exposes MetaApi MetaTrader streaming API connection instance to consumers
*/ export { StreamingMetaApiConnectionInstance as default };
//# 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":["LoggerManager","MetaApiConnectionInstance","StreamingMetaApiConnectionInstance","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","getLogger"],"mappings":"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"}