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)
154 lines (153 loc) • 13.6 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);
});
};
}
function _define_property(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
import LoggerManager from '../logger';
let DomainClient = class DomainClient {
/**
* Returns domain client domain
* @returns {String} client domain
*/ get domain() {
return this._domain;
}
/**
* Returns domain client token
* @returns {String} client token
*/ get token() {
return this._token;
}
/**
* Returns the API URL
* @param {String} host REST API host
* @param {String} region host region
* @returns {String} API URL
*/ getUrl(host, region) {
var _this = this;
return _async_to_generator(function*() {
yield _this._updateDomain();
return `${host}.${region}.${_this._urlCache.domain}`;
})();
}
/**
* Returns domain settings
* @returns {DomainSettings} domain settings
*/ getSettings() {
var _this = this;
return _async_to_generator(function*() {
yield _this._updateDomain();
return {
domain: _this._urlCache.domain,
hostname: _this._urlCache.hostname
};
})();
}
_updateDomain() {
var _this = this;
return _async_to_generator(function*() {
if (!_this._urlCache.domain || _this._urlCache.lastUpdated < Date.now() - 1000 * 60 * 10) {
if (_this._urlCache.requestPromise) {
yield _this._urlCache.requestPromise;
} else {
let resolve, reject;
_this._urlCache.requestPromise = new Promise((res, rej)=>{
resolve = res, reject = rej;
});
let isCacheUpdated = false;
while(!isCacheUpdated){
const opts = {
url: `https://mt-provisioning-api-v1.${_this._domain}/users/current/servers/mt-client-api`,
method: 'GET',
headers: {
'auth-token': _this._token
},
json: true
};
try {
const urlSettings = yield _this._httpClient.request(opts, '_updateDomain');
_this._urlCache = {
domain: urlSettings.domain,
hostname: urlSettings.hostname,
requestPromise: null,
lastUpdated: Date.now()
};
resolve();
isCacheUpdated = true;
_this._retryIntervalInSeconds = 1;
} catch (err) {
_this._logger.error('Failed to update domain settings cache', err);
_this._retryIntervalInSeconds = Math.min(_this._retryIntervalInSeconds * 2, 300);
yield new Promise((res)=>setTimeout(res, _this._retryIntervalInSeconds * 1000));
}
}
}
}
})();
}
/**
* 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'){
_define_property(this, "_httpClient", void 0);
_define_property(this, "_domain", void 0);
_define_property(this, "_token", void 0);
_define_property(this, "_urlCache", void 0);
_define_property(this, "_retryIntervalInSeconds", void 0);
_define_property(this, "_logger", void 0);
this._httpClient = httpClient;
this._domain = domain;
this._token = token;
this._urlCache = {
domain: null,
hostname: null,
requestPromise: null,
lastUpdated: 0
};
this._retryIntervalInSeconds = 1;
this._logger = LoggerManager.getLogger('DomainClient');
}
};
/**
* Connection URL managing client
*/ export { DomainClient as default };
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["<anon>"],"sourcesContent":["'use strict';\n\nimport LoggerManager, {Logger} from '../logger';\nimport HttpClient from './httpClient';\n\n/**\n * Connection URL managing client\n */\nexport default class DomainClient {\n  \n  private _httpClient: any;\n  private _domain: string;\n  private _token: any;\n  private _urlCache: any;\n  private _retryIntervalInSeconds: number;\n  private _logger: Logger;\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: HttpClient, token: string, domain = 'agiliumtrade.agiliumtrade.ai') {\n    this._httpClient = httpClient;\n    this._domain = domain;\n    this._token = token;\n    this._urlCache = {\n      domain: null,\n      hostname: null,\n      requestPromise: null,\n      lastUpdated: 0\n    };\n    this._retryIntervalInSeconds = 1;\n    this._logger = LoggerManager.getLogger('DomainClient');\n  }\n\n  /**\n   * Returns domain client domain\n   * @returns {String} client domain\n   */\n  get domain(): string {\n    return this._domain;\n  }\n\n  /**\n   * Returns domain client token\n   * @returns {String} client token\n   */\n  get token(): string {\n    return this._token;\n  }\n\n  /**\n   * Returns the API URL\n   * @param {String} host REST API host\n   * @param {String} region host region\n   * @returns {String} API URL\n   */\n  async getUrl(host: string, region: string): Promise<string> {\n    await this._updateDomain();\n    return `${host}.${region}.${this._urlCache.domain}`;\n  }\n\n  /**\n   * Returns domain settings\n   * @returns {DomainSettings} domain settings\n   */\n  async getSettings(): Promise<DomainSettings> {\n    await this._updateDomain();\n    return {domain: this._urlCache.domain, hostname: this._urlCache.hostname};\n  }\n\n  private async _updateDomain() {\n    if(!this._urlCache.domain || this._urlCache.lastUpdated < Date.now() - 1000 * 60 * 10) {\n      if(this._urlCache.requestPromise) {\n        await this._urlCache.requestPromise;\n      } else {\n        let resolve, reject;\n        this._urlCache.requestPromise = new Promise((res, rej) => {\n          resolve = res, reject = rej;\n        });\n        let isCacheUpdated = false;\n        while(!isCacheUpdated) {\n          const opts = {\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  \n          try {\n            const urlSettings = await this._httpClient.request(opts, '_updateDomain');\n            this._urlCache = {\n              domain: urlSettings.domain,\n              hostname: urlSettings.hostname,\n              requestPromise: null,\n              lastUpdated: Date.now()\n            }; \n            resolve();\n            isCacheUpdated = true;\n            this._retryIntervalInSeconds = 1;\n          } catch (err) {\n            this._logger.error('Failed to update domain settings cache', err);\n            this._retryIntervalInSeconds = Math.min(this._retryIntervalInSeconds * 2, 300);\n            await new Promise(res => setTimeout(res, this._retryIntervalInSeconds * 1000));\n          }\n        }\n      }\n    }\n  }\n}\n\n/**\n * Domain settings\n */\nexport declare type DomainSettings = {\n  /** client api host name */\n  hostname: string,\n  /** client api domain for regions */\n  domain: string\n};\n"],"names":["LoggerManager","DomainClient","domain","_domain","token","_token","getUrl","host","region","_updateDomain","_urlCache","getSettings","hostname","lastUpdated","Date","now","requestPromise","resolve","reject","Promise","res","rej","isCacheUpdated","opts","url","method","headers","json","urlSettings","_httpClient","request","_retryIntervalInSeconds","err","_logger","error","Math","min","setTimeout","constructor","httpClient","getLogger"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,OAAOA,mBAA6B,YAAY;AAMjC,IAAA,AAAMC,eAAN,MAAMA;IA6BnB;;;GAGC,GACD,IAAIC,SAAiB;QACnB,OAAO,IAAI,CAACC,OAAO;IACrB;IAEA;;;GAGC,GACD,IAAIC,QAAgB;QAClB,OAAO,IAAI,CAACC,MAAM;IACpB;IAEA;;;;;GAKC,GACD,AAAMC,OAAOC,IAAY,EAAEC,MAAc;;eAAzC,oBAAA;YACE,MAAM,MAAKC,aAAa;YACxB,OAAO,CAAC,EAAEF,KAAK,CAAC,EAAEC,OAAO,CAAC,EAAE,MAAKE,SAAS,CAACR,MAAM,CAAC,CAAC;QACrD;;IAEA;;;GAGC,GACD,AAAMS;;eAAN,oBAAA;YACE,MAAM,MAAKF,aAAa;YACxB,OAAO;gBAACP,QAAQ,MAAKQ,SAAS,CAACR,MAAM;gBAAEU,UAAU,MAAKF,SAAS,CAACE,QAAQ;YAAA;QAC1E;;IAEcH;;eAAd,oBAAA;YACE,IAAG,CAAC,MAAKC,SAAS,CAACR,MAAM,IAAI,MAAKQ,SAAS,CAACG,WAAW,GAAGC,KAAKC,GAAG,KAAK,OAAO,KAAK,IAAI;gBACrF,IAAG,MAAKL,SAAS,CAACM,cAAc,EAAE;oBAChC,MAAM,MAAKN,SAAS,CAACM,cAAc;gBACrC,OAAO;oBACL,IAAIC,SAASC;oBACb,MAAKR,SAAS,CAACM,cAAc,GAAG,IAAIG,QAAQ,CAACC,KAAKC;wBAChDJ,UAAUG,KAAKF,SAASG;oBAC1B;oBACA,IAAIC,iBAAiB;oBACrB,MAAM,CAACA,eAAgB;wBACrB,MAAMC,OAAO;4BACXC,KAAK,CAAC,+BAA+B,EAAE,MAAKrB,OAAO,CAAC,oCAAoC,CAAC;4BACzFsB,QAAQ;4BACRC,SAAS;gCACP,cAAc,MAAKrB,MAAM;4BAC3B;4BACAsB,MAAM;wBACR;wBAEA,IAAI;4BACF,MAAMC,cAAc,MAAM,MAAKC,WAAW,CAACC,OAAO,CAACP,MAAM;4BACzD,MAAKb,SAAS,GAAG;gCACfR,QAAQ0B,YAAY1B,MAAM;gCAC1BU,UAAUgB,YAAYhB,QAAQ;gCAC9BI,gBAAgB;gCAChBH,aAAaC,KAAKC,GAAG;4BACvB;4BACAE;4BACAK,iBAAiB;4BACjB,MAAKS,uBAAuB,GAAG;wBACjC,EAAE,OAAOC,KAAK;4BACZ,MAAKC,OAAO,CAACC,KAAK,CAAC,0CAA0CF;4BAC7D,MAAKD,uBAAuB,GAAGI,KAAKC,GAAG,CAAC,MAAKL,uBAAuB,GAAG,GAAG;4BAC1E,MAAM,IAAIZ,QAAQC,CAAAA,MAAOiB,WAAWjB,KAAK,MAAKW,uBAAuB,GAAG;wBAC1E;oBACF;gBACF;YACF;QACF;;IA/FA;;;;;GAKC,GACDO,YAAYC,UAAsB,EAAEnC,KAAa,EAAEF,SAAS,8BAA8B,CAAE;QAb5F,uBAAQ2B,eAAR,KAAA;QACA,uBAAQ1B,WAAR,KAAA;QACA,uBAAQE,UAAR,KAAA;QACA,uBAAQK,aAAR,KAAA;QACA,uBAAQqB,2BAAR,KAAA;QACA,uBAAQE,WAAR,KAAA;QASE,IAAI,CAACJ,WAAW,GAAGU;QACnB,IAAI,CAACpC,OAAO,GAAGD;QACf,IAAI,CAACG,MAAM,GAAGD;QACd,IAAI,CAACM,SAAS,GAAG;YACfR,QAAQ;YACRU,UAAU;YACVI,gBAAgB;YAChBH,aAAa;QACf;QACA,IAAI,CAACkB,uBAAuB,GAAG;QAC/B,IAAI,CAACE,OAAO,GAAGjC,cAAcwC,SAAS,CAAC;IACzC;AA8EF;AA5GA;;CAEC,GACD,SAAqBvC,0BAyGpB"}