metaapi.cloud-metastats-sdk
Version:
Javascript SDK for MetaStats forex trading statistics API. Can calculate metrics for MetaTrader accounts added to MetaApi. Supports both MetaTrader 5 (MT5) and MetaTrader 4 (MT4). (https://metaapi.cloud)
158 lines (157 loc) • 15.5 kB
JavaScript
;
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 { ValidationError } from './errorHandler';
let DomainClient = class DomainClient {
/**
* Returns domain client token
* @returns {String} client token
*/ get token() {
return this._token;
}
/**
* Sends a MetaStats API request
* @param {Function} getOpts function to get request options
* @param {String} accountId account id
* @returns {Object|String|any} request result
*/ requestMetastats(getOpts, accountId) {
var _this = this;
return _async_to_generator(function*() {
yield _this._updateHost();
yield _this._updateAccountHost(accountId);
const accountCache = _this._accountCache[accountId];
try {
const regionSettings = accountCache.regions[accountCache.regionIndex];
const opts = getOpts(`https://metastats-api-v1.${regionSettings.region}.${_this._urlCache.domain}`, regionSettings.id);
return yield _this._httpClient.request(opts);
} catch (err) {
if (![
'ConflictError',
'InternalError',
'ApiError',
'TimeoutError'
].includes(err.name)) {
throw err;
} else {
if (accountCache.regions.length === accountCache.regionIndex + 1) {
accountCache.regionIndex = 0;
throw err;
} else {
accountCache.regionIndex++;
return yield _this.requestMetastats(getOpts, accountId);
}
}
}
})();
}
_updateHost() {
var _this = this;
return _async_to_generator(function*() {
if (!_this._urlCache || _this._urlCache.lastUpdated < Date.now() - 1000 * 60 * 10) {
const urlSettings = yield _this._httpClient.requestWithFailover({
url: `https://mt-provisioning-api-v1.${_this._domain}/users/current/servers/mt-client-api`,
method: 'GET',
headers: {
'auth-token': _this._token
},
json: true
});
_this._urlCache = {
domain: urlSettings.domain,
lastUpdated: Date.now()
};
}
})();
}
_updateAccountHost(accountId) {
var _this = this;
return _async_to_generator(function*() {
if (!_this._accountCache[accountId] || _this._accountCache[accountId].lastUpdated < Date.now() - 1000 * 60 * 10) {
const getAccount = function() {
var _ref = _async_to_generator(function*(id) {
const accountOpts = {
url: `https://mt-provisioning-api-v1.${_this._domain}/users/current/accounts/${id}`,
method: 'GET',
headers: {
'auth-token': _this._token
},
json: true
};
return yield _this._httpClient.requestWithFailover(accountOpts);
});
return function getAccount(id) {
return _ref.apply(this, arguments);
};
}();
let accounts = [];
let accountData = yield getAccount(accountId);
if (accountData.primaryAccountId) {
accountData = yield getAccount(accountData.primaryAccountId);
}
accounts = [
{
_id: accountData._id,
region: accountData.region,
state: accountData.state
}
].concat(accountData.accountReplicas || []);
accounts = accounts.filter((account)=>account.state === 'DEPLOYED');
if (!accounts.length) {
throw new ValidationError('There are no replicas deployed yet. Please make sure at least ' + 'one of the replicas is deployed.');
}
let regions = accounts.map((account)=>({
region: account.region,
id: account._id
}));
_this._accountCache[accountId] = {
regions,
regionIndex: 0,
lastUpdated: Date.now()
};
}
})();
}
/**
* Constructs domain client instance
* @param {HttpClient} httpClient HTTP client
* @param {String} token authorization token
* @param {String} domain domain to connect to, default is agiliumtrade.agiliumtrade.ai
*/ constructor(httpClient, token, domain = 'agiliumtrade.agiliumtrade.ai'){
this._httpClient = httpClient;
this._domain = domain;
this._token = token;
this._urlCache = null;
this._accountCache = {};
}
};
/**
* Connection URL and request managing client
*/ export { DomainClient as default };
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["<anon>"],"sourcesContent":["'use strict';\n\nimport { ValidationError } from './errorHandler';\n\n/**\n * Connection URL and request managing client\n */\nexport default class DomainClient {\n\n  /**\n   * Constructs domain client instance\n   * @param {HttpClient} httpClient HTTP client\n   * @param {String} token authorization token\n   * @param {String} domain domain to connect to, default is agiliumtrade.agiliumtrade.ai\n   */\n  constructor(httpClient, token, domain = 'agiliumtrade.agiliumtrade.ai') {\n    this._httpClient = httpClient;\n    this._domain = domain;\n    this._token = token;\n    this._urlCache = null;\n    this._accountCache = {};\n  }\n\n  /**\n   * Returns domain client token\n   * @returns {String} client token\n   */\n  get token() {\n    return this._token;\n  }\n\n  /**\n   * Sends a MetaStats API request\n   * @param {Function} getOpts function to get request options\n   * @param {String} accountId account id\n   * @returns {Object|String|any} request result\n   */\n  async requestMetastats(getOpts, accountId) {\n    await this._updateHost();\n    await this._updateAccountHost(accountId);\n    const accountCache = this._accountCache[accountId];\n    try {\n      const regionSettings = accountCache.regions[accountCache.regionIndex];\n      const opts = getOpts(`https://metastats-api-v1.${regionSettings.region}.${this._urlCache.domain}`, \n        regionSettings.id);\n\n      return await this._httpClient.request(opts);\n    } catch (err) {\n      if (!['ConflictError', 'InternalError', 'ApiError', 'TimeoutError'].includes(err.name)) {\n        throw err;\n      } else {\n        if (accountCache.regions.length === accountCache.regionIndex + 1) {\n          accountCache.regionIndex = 0;\n          throw err;\n        } else {\n          accountCache.regionIndex++;\n          return await this.requestMetastats(getOpts, accountId);\n        }\n      }\n    }\n\n  }\n\n  async _updateHost() {\n    if (!this._urlCache || this._urlCache.lastUpdated < Date.now() - 1000 * 60 * 10) {\n      const urlSettings = await this._httpClient.requestWithFailover({\n        url: `https://mt-provisioning-api-v1.${this._domain}/users/current/servers/mt-client-api`,\n        method: 'GET',\n        headers: {\n          'auth-token': this._token\n        },\n        json: true,\n      });\n      this._urlCache = {\n        domain: urlSettings.domain,\n        lastUpdated: Date.now()\n      }; \n    }\n  }\n  \n  async _updateAccountHost(accountId) {\n    if (!this._accountCache[accountId] || this._accountCache[accountId].lastUpdated < Date.now() - 1000 * 60 * 10) {\n\n      const getAccount = async (id) => {\n        const accountOpts = {\n          url: `https://mt-provisioning-api-v1.${this._domain}/users/current/accounts/${id}`,\n          method: 'GET',\n          headers: {\n            'auth-token': this._token\n          },\n          json: true\n        };\n\n        return await this._httpClient.requestWithFailover(accountOpts);\n      };\n\n      let accounts = [];\n      let accountData = await getAccount(accountId);\n      if (accountData.primaryAccountId) {\n        accountData = await getAccount(accountData.primaryAccountId);\n      }\n      accounts = [{_id: accountData._id, region: accountData.region, state: accountData.state}]\n        .concat((accountData.accountReplicas || []));\n      accounts = accounts.filter(account => account.state === 'DEPLOYED');\n      if (!accounts.length) {\n        throw new ValidationError('There are no replicas deployed yet. Please make sure at least ' +\n        'one of the replicas is deployed.');\n      }\n\n      let regions = accounts.map(account => ({region: account.region, id: account._id}));\n\n      this._accountCache[accountId] = {\n        regions,\n        regionIndex: 0,\n        lastUpdated: Date.now()\n      };\n    }\n  }\n\n}\n"],"names":["ValidationError","DomainClient","token","_token","requestMetastats","getOpts","accountId","_updateHost","_updateAccountHost","accountCache","_accountCache","regionSettings","regions","regionIndex","opts","region","_urlCache","domain","id","_httpClient","request","err","includes","name","length","lastUpdated","Date","now","urlSettings","requestWithFailover","url","_domain","method","headers","json","getAccount","accountOpts","accounts","accountData","primaryAccountId","_id","state","concat","accountReplicas","filter","account","map","constructor","httpClient"],"mappings":"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"}