metaapi.cloud-sdk/build/esm/clients/metaApi/clientApi.client.js

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)

'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);
        });
    };
}
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 MetaApiClient from '../metaApi.client';
import LoggerManager from '../../logger';
import { NotFoundError } from '../errorHandler';
let ClientApiClient = class ClientApiClient extends MetaApiClient {
    /**
   * Type hashing ignored field lists
   * @typedef {Object} TypeHashingIgnoredFieldLists
   * @property {String[]} specification specification ignored fields
   * @property {String[]} position position ignored fields
   * @property {String[]} order order ignored fields
   */ /**
   * Hashing ignored field lists
   * @typedef {Object} HashingIgnoredFieldLists
   * @property {TypeHashingIgnoredFieldLists} g1 g1 hashing ignored field lists
   * @property {TypeHashingIgnoredFieldLists} g2 g2 hashing ignored field lists
   */ /**
   * Refreshes hashing ignored field lists
   * @param {String} region account region
   * @returns {Promise} promise resolving when the hashing field lists are updated.
   */ refreshIgnoredFieldLists(region) {
        var _this = this;
        return _async_to_generator(function*() {
            if (_this._ignoredFieldListsCaches[region] && _this._ignoredFieldListsCaches[region].requestPromise) {
                yield _this._ignoredFieldListsCaches[region].requestPromise;
            } else if (_this._ignoredFieldListsCaches[region] && Date.now() - _this._ignoredFieldListsCaches[region].lastUpdated < _this._updateInterval) {
                return;
            } else {
                if (!_this._ignoredFieldListsCaches[region]) {
                    _this._ignoredFieldListsCaches[region] = {
                        lastUpdated: 0,
                        data: null,
                        requestPromise: null,
                        updateJob: setInterval(()=>_this._refreshIgnoredFieldListsJob(region), 60000)
                    };
                }
                let resolve, reject;
                _this._ignoredFieldListsCaches[region].requestPromise = new Promise((res, rej)=>{
                    resolve = res, reject = rej;
                });
                let isCacheUpdated = false;
                while(!isCacheUpdated){
                    try {
                        const host = yield _this._domainClient.getUrl(_this._host, region);
                        const opts = {
                            url: `${host}/hashing-ignored-field-lists`,
                            method: 'GET',
                            json: true,
                            headers: {
                                'auth-token': _this._token
                            }
                        };
                        const response = yield _this._httpClient.request(opts, 'getHashingIgnoredFieldLists');
                        _this._ignoredFieldListsCaches[region] = {
                            lastUpdated: Date.now(),
                            data: response,
                            requestPromise: null
                        };
                        _this._ignoredFieldListsFreshestCache = response;
                        resolve(response);
                        isCacheUpdated = true;
                        _this._ignoredFieldListsCaches[region].retryIntervalInSeconds = _this._retryIntervalInSeconds;
                    } catch (err) {
                        _this._logger.error('Failed to update hashing ignored field list', err);
                        _this._ignoredFieldListsCaches[region].retryIntervalInSeconds = Math.min(_this._ignoredFieldListsCaches[region].retryIntervalInSeconds * 2, 300);
                        yield new Promise((res)=>setTimeout(res, _this._ignoredFieldListsCaches[region].retryIntervalInSeconds * 1000));
                    }
                }
            }
        })();
    }
    /**
   * Retrieves hashing ignored field lists
   * @param {String} region account region
   * @returns {HashingIgnoredFieldLists} promise resolving with hashing ignored field lists
   */ getHashingIgnoredFieldLists(region) {
        if (region === 'combined') {
            if (this._ignoredFieldListsFreshestCache) {
                return this._ignoredFieldListsFreshestCache;
            } else {
                throw new NotFoundError('Ignored field lists not found');
            }
        }
        if (this._ignoredFieldListsCaches[region] && this._ignoredFieldListsCaches[region].data) {
            return this._ignoredFieldListsCaches[region].data;
        } else {
            throw new NotFoundError(`Ignored field lists for region ${region} not found`);
        }
    }
    _refreshIgnoredFieldListsJob(region) {
        var _this = this;
        return _async_to_generator(function*() {
            if (!_this._ignoredFieldListsCaches[region].requestPromise && Date.now() - _this._ignoredFieldListsCaches[region].lastUpdated > _this._updateInterval) {
                yield _this.refreshIgnoredFieldLists(region);
            }
        })();
    }
    /**
   * Constructs client API client instance
   * @param {HttpClient} httpClient HTTP client
   * @param {DomainClient} domainClient domain client
   */ constructor(httpClient, domainClient){
        super(httpClient, domainClient);
        _define_property(this, "_retryIntervalInSeconds", void 0);
        _define_property(this, "_updateInterval", void 0);
        _define_property(this, "_ignoredFieldListsCaches", void 0);
        _define_property(this, "_ignoredFieldListsFreshestCache", void 0);
        _define_property(this, "_logger", void 0);
        this._host = 'https://mt-client-api-v1';
        this._retryIntervalInSeconds = 1;
        this._updateInterval = 60 * 60 * 1000;
        this._ignoredFieldListsCaches = {};
        this._ignoredFieldListsFreshestCache = null;
        this._logger = LoggerManager.getLogger('ClientApiClient');
    }
};
/**
 * metaapi.cloud client API client (see https://metaapi.cloud/docs/client/)
 */ export { ClientApiClient as default };

//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["<anon>"],"sourcesContent":["'use strict';\n\nimport MetaApiClient from '../metaApi.client';\nimport LoggerManager, {Logger} from '../../logger';\nimport {NotFoundError} from '../errorHandler';\nimport HttpClient from '../httpClient';\nimport DomainClient from '../domain.client';\n\n/**\n * metaapi.cloud client API client (see https://metaapi.cloud/docs/client/)\n */\nexport default class ClientApiClient extends MetaApiClient {\n  \n  private _retryIntervalInSeconds: number;\n  private _updateInterval: number;\n  private _ignoredFieldListsCaches: {};\n  private _ignoredFieldListsFreshestCache: null;\n  private _logger: Logger;\n\n  /**\n   * Constructs client API client instance\n   * @param {HttpClient} httpClient HTTP client\n   * @param {DomainClient} domainClient domain client\n   */\n  constructor(httpClient: HttpClient, domainClient: DomainClient) {\n    super(httpClient, domainClient);\n    this._host = 'https://mt-client-api-v1';\n    this._retryIntervalInSeconds = 1;\n    this._updateInterval = 60 * 60 * 1000;\n    this._ignoredFieldListsCaches = {};\n    this._ignoredFieldListsFreshestCache = null;\n    this._logger = LoggerManager.getLogger('ClientApiClient');\n  }\n\n  /**\n   * Type hashing ignored field lists\n   * @typedef {Object} TypeHashingIgnoredFieldLists\n   * @property {String[]} specification specification ignored fields\n   * @property {String[]} position position ignored fields\n   * @property {String[]} order order ignored fields\n   */\n\n  /**\n   * Hashing ignored field lists\n   * @typedef {Object} HashingIgnoredFieldLists\n   * @property {TypeHashingIgnoredFieldLists} g1 g1 hashing ignored field lists\n   * @property {TypeHashingIgnoredFieldLists} g2 g2 hashing ignored field lists\n   */\n\n  /**\n   * Refreshes hashing ignored field lists\n   * @param {String} region account region\n   * @returns {Promise} promise resolving when the hashing field lists are updated.\n   */\n  async refreshIgnoredFieldLists(region: string): Promise<any> {\n    if(this._ignoredFieldListsCaches[region] && this._ignoredFieldListsCaches[region].requestPromise) {\n      await this._ignoredFieldListsCaches[region].requestPromise;\n    } else if (this._ignoredFieldListsCaches[region] && \n      Date.now() - this._ignoredFieldListsCaches[region].lastUpdated < this._updateInterval) {\n      return;\n    } else {\n      if(!this._ignoredFieldListsCaches[region]) {\n        this._ignoredFieldListsCaches[region] = {\n          lastUpdated: 0,\n          data: null,\n          requestPromise: null,\n          updateJob: setInterval(() => this._refreshIgnoredFieldListsJob(region), 60000)\n        };\n      }\n      let resolve, reject;\n      this._ignoredFieldListsCaches[region].requestPromise = new Promise((res, rej) => {\n        resolve = res, reject = rej;\n      });\n      let isCacheUpdated = false;\n      while(!isCacheUpdated) {\n        try {\n          const host = await this._domainClient.getUrl(this._host, region);\n          const opts = {\n            url: `${host}/hashing-ignored-field-lists`,\n            method: 'GET',\n            json: true,\n            headers: {\n              'auth-token': this._token\n            }\n          };\n          const response = await this._httpClient.request(opts, 'getHashingIgnoredFieldLists');\n          this._ignoredFieldListsCaches[region] = { lastUpdated: Date.now(), data: response, requestPromise: null };\n          this._ignoredFieldListsFreshestCache = response;\n          resolve(response);\n          isCacheUpdated = true;\n          this._ignoredFieldListsCaches[region].retryIntervalInSeconds = this._retryIntervalInSeconds;\n        } catch (err) {\n          this._logger.error('Failed to update hashing ignored field list', err);\n          this._ignoredFieldListsCaches[region].retryIntervalInSeconds =\n            Math.min(this._ignoredFieldListsCaches[region].retryIntervalInSeconds * 2, 300);\n          await new Promise(res => setTimeout(res, \n            this._ignoredFieldListsCaches[region].retryIntervalInSeconds * 1000));\n        }\n      }\n    }\n  }\n\n  /**\n   * Retrieves hashing ignored field lists\n   * @param {String} region account region\n   * @returns {HashingIgnoredFieldLists} promise resolving with hashing ignored field lists\n   */\n  getHashingIgnoredFieldLists(region: string): HashingIgnoredFieldLists {\n    if(region === 'combined') {\n      if (this._ignoredFieldListsFreshestCache) {\n        return this._ignoredFieldListsFreshestCache;\n      } else{ \n        throw new NotFoundError('Ignored field lists not found');\n      }\n    }\n    if(this._ignoredFieldListsCaches[region] && this._ignoredFieldListsCaches[region].data) {\n      return this._ignoredFieldListsCaches[region].data;\n    } else {\n      throw new NotFoundError(`Ignored field lists for region ${region} not found`);\n    }\n  }\n\n  async _refreshIgnoredFieldListsJob(region) {\n    if(!this._ignoredFieldListsCaches[region].requestPromise && \n      Date.now() - this._ignoredFieldListsCaches[region].lastUpdated > this._updateInterval) {\n      await this.refreshIgnoredFieldLists(region);\n    }\n  }\n}\n\n/**\n * Type hashing ignored field lists\n */\nexport declare type TypeHashingIgnoredFieldLists = {\n\n  /**\n   * specifications ignored fields\n   */\n  specification: string[],\n\n  /**\n   * position ignored fields\n   */\n  position: string[],\n\n  /**\n   * order ignored fields\n   */\n  order: string[],\n}\n\n/**\n * Hashing ignored field lists\n */\nexport declare type HashingIgnoredFieldLists = {\n\n  /**\n   * g1 hashing ignored field lists\n   */\n  g1: TypeHashingIgnoredFieldLists,\n\n  /**\n   * g2 hashing ignored field lists\n   */\n  g2: TypeHashingIgnoredFieldLists,\n}\n"],"names":["MetaApiClient","LoggerManager","NotFoundError","ClientApiClient","refreshIgnoredFieldLists","region","_ignoredFieldListsCaches","requestPromise","Date","now","lastUpdated","_updateInterval","data","updateJob","setInterval","_refreshIgnoredFieldListsJob","resolve","reject","Promise","res","rej","isCacheUpdated","host","_domainClient","getUrl","_host","opts","url","method","json","headers","_token","response","_httpClient","request","_ignoredFieldListsFreshestCache","retryIntervalInSeconds","_retryIntervalInSeconds","err","_logger","error","Math","min","setTimeout","getHashingIgnoredFieldLists","constructor","httpClient","domainClient","getLogger"],"mappings":"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"}