metaapi.cloud-copyfactory-sdk
Version:
Javascript SDK for SDK for CopyFactory trade copying API. Can copy trades both between MetaTrader 5 (MT5) and MetaTrader 4 (MT4). (https://metaapi.cloud)
235 lines (234 loc) • 24.7 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;
}
function _object_spread(target) {
for(var i = 1; i < arguments.length; i++){
var source = arguments[i] != null ? arguments[i] : {};
var ownKeys = Object.keys(source);
if (typeof Object.getOwnPropertySymbols === "function") {
ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
return Object.getOwnPropertyDescriptor(source, sym).enumerable;
}));
}
ownKeys.forEach(function(key) {
_define_property(target, key, source[key]);
});
}
return target;
}
import axios from 'axios';
import { UnauthorizedError, ForbiddenError, ApiError, ValidationError, InternalError, NotFoundError, TooManyRequestsError } from './errorHandler';
import TimeoutError from './timeoutError';
let HttpClient = class HttpClient {
/**
* Performs a request. Response errors are returned as ApiError or subclasses.
* @param {Object} options request options
* @param {Boolean} isExtendedTimeout whether to run the request with an extended timeout
* @returns {Object|String|any} request result
*/ request(options, isExtendedTimeout, endTime = Date.now() + this._maxRetryDelay * this._retries) {
var _this = this;
return _async_to_generator(function*() {
options.timeout = isExtendedTimeout ? _this._extendedTimeout : _this._timeout;
try {
const response = yield _this._makeRequest(options);
return response && response.data || undefined;
} catch (err) {
const error = _this._convertError(err);
if (error.name === 'TooManyRequestsError') {
const retryTime = Date.parse(error.metadata.recommendedRetryTime);
const date = Date.now();
if (retryTime < endTime) {
if (retryTime > date) {
yield _this._wait(retryTime - date);
}
return yield _this.request(options, isExtendedTimeout, endTime);
} else {
throw error;
}
} else {
throw error;
}
}
})();
}
/**
* Performs a request with a failover. Response errors are returned as ApiError or subclasses.
* @param {Object} options request options
* @returns {Object|String|any} request result
*/ requestWithFailover(options, retryCounter = 0, endTime = Date.now() + this._maxRetryDelay * this._retries) {
var _this = this;
return _async_to_generator(function*() {
options.timeout = _this._timeout;
let retryAfterSeconds = 0;
options.callback = (e, res)=>{
if (res && res.status === 202) {
retryAfterSeconds = res.headers['retry-after'];
}
};
let body;
try {
const response = yield _this._makeRequest(options);
options.callback(null, response);
body = response && response.data || undefined;
} catch (err) {
retryCounter = yield _this._handleError(err, retryCounter, endTime);
return _this.requestWithFailover(options, retryCounter, endTime);
}
if (retryAfterSeconds) {
yield _this._handleRetry(endTime, retryAfterSeconds * 1000);
body = yield _this.requestWithFailover(options, retryCounter, endTime);
}
return body;
})();
}
_makeRequest(options) {
return axios(_object_spread({
transitional: {
clarifyTimeoutError: true
}
}, options));
}
_wait(pause) {
return _async_to_generator(function*() {
yield new Promise((res)=>setTimeout(res, pause));
})();
}
_handleRetry(endTime, retryAfter) {
var _this = this;
return _async_to_generator(function*() {
if (endTime > Date.now() + retryAfter) {
yield _this._wait(retryAfter);
} else {
throw new TimeoutError('Timed out waiting for the response');
}
})();
}
_handleError(err, retryCounter, endTime) {
var _this = this;
return _async_to_generator(function*() {
const error = _this._convertError(err);
if ([
'ConflictError',
'InternalError',
'ApiError',
'TimeoutError'
].includes(error.name) && retryCounter < _this._retries) {
const pause = Math.min(Math.pow(2, retryCounter) * _this._minRetryDelay, _this._maxRetryDelay);
yield _this._wait(pause);
return retryCounter + 1;
} else if (error.name === 'TooManyRequestsError') {
const retryTime = Date.parse(error.metadata.recommendedRetryTime);
if (retryTime < endTime) {
yield _this._wait(retryTime - Date.now());
return retryCounter;
}
}
throw error;
})();
}
// eslint-disable-next-line complexity
_convertError(err) {
var _err_config;
const errorResponse = err.response || {};
const errorData = errorResponse.data || {};
const status = errorResponse.status || err.status;
const url = err === null || err === void 0 ? void 0 : (_err_config = err.config) === null || _err_config === void 0 ? void 0 : _err_config.url;
const errMsg = errorData.message || err.message;
const errMsgDefault = errorData.message || err.code || err.message;
switch(status){
case 400:
return new ValidationError(errMsg, errorData.details || err.details, url);
case 401:
return new UnauthorizedError(errMsg, url);
case 403:
return new ForbiddenError(errMsg, url);
case 404:
return new NotFoundError(errMsg, url);
case 409:
return new NotFoundError(errMsg, url);
case 429:
return new TooManyRequestsError(errMsg, errorData.metadata || err.metadata, url);
case 500:
return new InternalError(errMsg, url);
default:
return new ApiError(ApiError, errMsgDefault, status, url);
}
}
/**
* @typedef {Object} RetryOptions retry options
* @property {Number} [retries] the number of attempts to retry failed request, default 5
* @property {Number} [minDelayInSeconds] minimum delay in seconds before retrying, default 1
* @property {Number} [maxDelayInSeconds] maximum delay in seconds before retrying, default 30
*/ /**
* Constructs HttpClient class instance
* @param {Number} [timeout] request timeout in seconds
* @param {Number} [extendedTimeout] request timeout in seconds
* @param {RetryOptions} [retryOpts] retry options
*/ constructor(timeout = 10, extendedTimeout = 70, retryOpts = {}){
this._timeout = timeout * 1000;
this._extendedTimeout = extendedTimeout * 1000;
this._retries = retryOpts.retries || 5;
this._minRetryDelay = (retryOpts.minDelayInSeconds || 1) * 1000;
this._maxRetryDelay = (retryOpts.maxDelayInSeconds || 30) * 1000;
}
};
/**
* HTTP client library based on request-promise
*/ export { HttpClient as default };
/**
* HTTP client service mock for tests
*/ export class HttpClientMock extends HttpClient {
_makeRequest() {
return this._requestFn.apply(this, arguments);
}
/**
* Constructs HTTP client mock
* @param {Function(options:Object):Promise} requestFn mocked request function
* @param {Number} timeout request timeout in seconds
* @param {RetryOptions} retryOpts retry options
*/ constructor(requestFn, timeout, extendedTimeout, retryOpts){
super(timeout, extendedTimeout, retryOpts);
this._requestFn = requestFn;
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["<anon>"],"sourcesContent":["'use strict';\n\nimport axios from 'axios';\nimport {\n  UnauthorizedError, ForbiddenError, ApiError, ValidationError, InternalError, \n  NotFoundError, TooManyRequestsError, ConflictError\n} from './errorHandler';\nimport TimeoutError from './timeoutError';\n\n/**\n * HTTP client library based on request-promise\n */\nexport default class HttpClient {\n\n  /**\n   * @typedef {Object} RetryOptions retry options\n   * @property {Number} [retries] the number of attempts to retry failed request, default 5\n   * @property {Number} [minDelayInSeconds] minimum delay in seconds before retrying, default 1\n   * @property {Number} [maxDelayInSeconds] maximum delay in seconds before retrying, default 30\n   */\n\n  /**\n   * Constructs HttpClient class instance\n   * @param {Number} [timeout] request timeout in seconds\n   * @param {Number} [extendedTimeout] request timeout in seconds\n   * @param {RetryOptions} [retryOpts] retry options\n   */\n  constructor(timeout = 10, extendedTimeout = 70, retryOpts = {}) {\n    this._timeout = timeout * 1000;\n    this._extendedTimeout = extendedTimeout * 1000;\n    this._retries = retryOpts.retries || 5;\n    this._minRetryDelay = (retryOpts.minDelayInSeconds || 1) * 1000;\n    this._maxRetryDelay = (retryOpts.maxDelayInSeconds || 30) * 1000;\n  }\n\n  /**\n   * Performs a request. Response errors are returned as ApiError or subclasses.\n   * @param {Object} options request options\n   * @param {Boolean} isExtendedTimeout whether to run the request with an extended timeout\n   * @returns {Object|String|any} request result\n   */\n  async request(options, isExtendedTimeout, endTime = Date.now() + this._maxRetryDelay * this._retries) {\n    options.timeout = isExtendedTimeout ? this._extendedTimeout : this._timeout;\n    try {\n      const response = await this._makeRequest(options);\n      return (response && response.data) || undefined;\n    } catch (err) {\n      const error = this._convertError(err);\n      if(error.name === 'TooManyRequestsError') {\n        const retryTime = Date.parse(error.metadata.recommendedRetryTime);\n        const date = Date.now();\n        if (retryTime < endTime) {\n          if(retryTime > date) {\n            await this._wait(retryTime - date);\n          }\n          return await this.request(options, isExtendedTimeout, endTime);\n        } else {\n          throw error;\n        }\n      } else {\n        throw error;\n      }\n    }\n  }\n\n  /**\n   * Performs a request with a failover. Response errors are returned as ApiError or subclasses.\n   * @param {Object} options request options\n   * @returns {Object|String|any} request result\n   */\n  async requestWithFailover(options, retryCounter = 0, endTime = Date.now() + this._maxRetryDelay * this._retries) {\n    options.timeout = this._timeout;\n    let retryAfterSeconds = 0;\n    options.callback = (e, res) => {\n      if (res && res.status === 202) {\n        retryAfterSeconds = res.headers['retry-after'];\n      }\n    };\n    let body;\n    try {\n      const response = await this._makeRequest(options);\n      options.callback(null, response);\n      body = (response && response.data) || undefined;\n    } catch (err) {\n      retryCounter = await this._handleError(err, retryCounter, endTime);\n      return this.requestWithFailover(options, retryCounter, endTime);\n    }\n    if (retryAfterSeconds) {\n      await this._handleRetry(endTime, retryAfterSeconds * 1000);\n      body = await this.requestWithFailover(options, retryCounter, endTime);\n    }\n    return body;\n  }\n\n  _makeRequest(options) {\n    return axios({\n      transitional: {\n        clarifyTimeoutError: true,\n      },\n      ...options\n    });\n  }\n\n  async _wait(pause) {\n    await new Promise(res => setTimeout(res, pause));\n  }\n\n  async _handleRetry(endTime, retryAfter) {\n    if(endTime > Date.now() + retryAfter) {\n      await this._wait(retryAfter);\n    } else {\n      throw new TimeoutError('Timed out waiting for the response');\n    }\n  }\n\n  async _handleError(err, retryCounter, endTime) {\n    const error = this._convertError(err);\n    if(['ConflictError', 'InternalError', 'ApiError', 'TimeoutError'].includes(error.name)\n      && retryCounter < this._retries) {\n      const pause = Math.min(Math.pow(2, retryCounter) * this._minRetryDelay, this._maxRetryDelay);\n      await this._wait(pause);\n      return retryCounter + 1;\n    } else if(error.name === 'TooManyRequestsError') {\n      const retryTime = Date.parse(error.metadata.recommendedRetryTime);\n      if (retryTime < endTime) {\n        await this._wait(retryTime - Date.now());\n        return retryCounter;\n      }\n    }\n    throw error;\n  }\n\n  // eslint-disable-next-line complexity\n  _convertError(err) {\n    const errorResponse = err.response || {};\n    const errorData = errorResponse.data || {};\n    const status = errorResponse.status || err.status;\n    const url = err?.config?.url;\n\n    const errMsg = errorData.message || err.message;\n    const errMsgDefault = errorData.message || err.code || err.message;\n\n    switch (status) {\n    case 400:\n      return new ValidationError(errMsg, errorData.details || err.details, url);\n    case 401:\n      return new UnauthorizedError(errMsg, url);\n    case 403:\n      return new ForbiddenError(errMsg, url);\n    case 404:\n      return new NotFoundError(errMsg, url);\n    case 409:\n      return new NotFoundError(errMsg, url);\n    case 429:\n      return new TooManyRequestsError(errMsg, errorData.metadata || err.metadata, url);\n    case 500:\n      return new InternalError(errMsg, url);\n    default:\n      return new ApiError(ApiError, errMsgDefault, status, url);\n    }\n  }\n}\n\n/**\n * HTTP client service mock for tests\n */\nexport class HttpClientMock extends HttpClient {\n\n  /**\n   * Constructs HTTP client mock\n   * @param {Function(options:Object):Promise} requestFn mocked request function\n   * @param {Number} timeout request timeout in seconds\n   * @param {RetryOptions} retryOpts retry options\n   */\n  constructor(requestFn, timeout, extendedTimeout, retryOpts) {\n    super(timeout, extendedTimeout, retryOpts);\n    this._requestFn = requestFn;\n  }\n\n  _makeRequest() {\n    return this._requestFn.apply(this, arguments);\n  }\n\n}\n"],"names":["axios","UnauthorizedError","ForbiddenError","ApiError","ValidationError","InternalError","NotFoundError","TooManyRequestsError","TimeoutError","HttpClient","request","options","isExtendedTimeout","endTime","Date","now","_maxRetryDelay","_retries","timeout","_extendedTimeout","_timeout","response","_makeRequest","data","undefined","err","error","_convertError","name","retryTime","parse","metadata","recommendedRetryTime","date","_wait","requestWithFailover","retryCounter","retryAfterSeconds","callback","e","res","status","headers","body","_handleError","_handleRetry","transitional","clarifyTimeoutError","pause","Promise","setTimeout","retryAfter","includes","Math","min","pow","_minRetryDelay","errorResponse","errorData","url","config","errMsg","message","errMsgDefault","code","details","constructor","extendedTimeout","retryOpts","retries","minDelayInSeconds","maxDelayInSeconds","HttpClientMock","_requestFn","apply","arguments","requestFn"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,OAAOA,WAAW,QAAQ;AAC1B,SACEC,iBAAiB,EAAEC,cAAc,EAAEC,QAAQ,EAAEC,eAAe,EAAEC,aAAa,EAC3EC,aAAa,EAAEC,oBAAoB,QAC9B,iBAAiB;AACxB,OAAOC,kBAAkB,iBAAiB;AAK3B,IAAA,AAAMC,aAAN,MAAMA;IAuBnB;;;;;GAKC,GACD,AAAMC,QAAQC,OAAO,EAAEC,iBAAiB,EAAEC,UAAUC,KAAKC,GAAG,KAAK,IAAI,CAACC,cAAc,GAAG,IAAI,CAACC,QAAQ;;eAApG,oBAAA,YAAsG;YACpGN,QAAQO,OAAO,GAAGN,oBAAoB,MAAKO,gBAAgB,GAAG,MAAKC,QAAQ;YAC3E,IAAI;gBACF,MAAMC,WAAW,MAAM,MAAKC,YAAY,CAACX;gBACzC,OAAO,AAACU,YAAYA,SAASE,IAAI,IAAKC;YACxC,EAAE,OAAOC,KAAK;gBACZ,MAAMC,QAAQ,MAAKC,aAAa,CAACF;gBACjC,IAAGC,MAAME,IAAI,KAAK,wBAAwB;oBACxC,MAAMC,YAAYf,KAAKgB,KAAK,CAACJ,MAAMK,QAAQ,CAACC,oBAAoB;oBAChE,MAAMC,OAAOnB,KAAKC,GAAG;oBACrB,IAAIc,YAAYhB,SAAS;wBACvB,IAAGgB,YAAYI,MAAM;4BACnB,MAAM,MAAKC,KAAK,CAACL,YAAYI;wBAC/B,CAAC;wBACD,OAAO,MAAM,MAAKvB,OAAO,CAACC,SAASC,mBAAmBC;oBACxD,OAAO;wBACL,MAAMa,MAAM;oBACd,CAAC;gBACH,OAAO;oBACL,MAAMA,MAAM;gBACd,CAAC;YACH;QACF;;IAEA;;;;GAIC,GACD,AAAMS,oBAAoBxB,OAAO,EAAEyB,eAAe,CAAC,EAAEvB,UAAUC,KAAKC,GAAG,KAAK,IAAI,CAACC,cAAc,GAAG,IAAI,CAACC,QAAQ;;eAA/G,oBAAA,YAAiH;YAC/GN,QAAQO,OAAO,GAAG,MAAKE,QAAQ;YAC/B,IAAIiB,oBAAoB;YACxB1B,QAAQ2B,QAAQ,GAAG,CAACC,GAAGC,MAAQ;gBAC7B,IAAIA,OAAOA,IAAIC,MAAM,KAAK,KAAK;oBAC7BJ,oBAAoBG,IAAIE,OAAO,CAAC,cAAc;gBAChD,CAAC;YACH;YACA,IAAIC;YACJ,IAAI;gBACF,MAAMtB,WAAW,MAAM,MAAKC,YAAY,CAACX;gBACzCA,QAAQ2B,QAAQ,CAAC,IAAI,EAAEjB;gBACvBsB,OAAO,AAACtB,YAAYA,SAASE,IAAI,IAAKC;YACxC,EAAE,OAAOC,KAAK;gBACZW,eAAe,MAAM,MAAKQ,YAAY,CAACnB,KAAKW,cAAcvB;gBAC1D,OAAO,MAAKsB,mBAAmB,CAACxB,SAASyB,cAAcvB;YACzD;YACA,IAAIwB,mBAAmB;gBACrB,MAAM,MAAKQ,YAAY,CAAChC,SAASwB,oBAAoB;gBACrDM,OAAO,MAAM,MAAKR,mBAAmB,CAACxB,SAASyB,cAAcvB;YAC/D,CAAC;YACD,OAAO8B;QACT;;IAEArB,aAAaX,OAAO,EAAE;QACpB,OAAOX,MAAM;YACX8C,cAAc;gBACZC,qBAAqB,IAAI;YAC3B;WACGpC;IAEP;IAEMuB,MAAMc,KAAK;eAAjB,oBAAA,YAAmB;YACjB,MAAM,IAAIC,QAAQT,CAAAA,MAAOU,WAAWV,KAAKQ;QAC3C;;IAEMH,aAAahC,OAAO,EAAEsC,UAAU;;eAAtC,oBAAA,YAAwC;YACtC,IAAGtC,UAAUC,KAAKC,GAAG,KAAKoC,YAAY;gBACpC,MAAM,MAAKjB,KAAK,CAACiB;YACnB,OAAO;gBACL,MAAM,IAAI3C,aAAa,sCAAsC;YAC/D,CAAC;QACH;;IAEMoC,aAAanB,GAAG,EAAEW,YAAY,EAAEvB,OAAO;;eAA7C,oBAAA,YAA+C;YAC7C,MAAMa,QAAQ,MAAKC,aAAa,CAACF;YACjC,IAAG;gBAAC;gBAAiB;gBAAiB;gBAAY;aAAe,CAAC2B,QAAQ,CAAC1B,MAAME,IAAI,KAChFQ,eAAe,MAAKnB,QAAQ,EAAE;gBACjC,MAAM+B,QAAQK,KAAKC,GAAG,CAACD,KAAKE,GAAG,CAAC,GAAGnB,gBAAgB,MAAKoB,cAAc,EAAE,MAAKxC,cAAc;gBAC3F,MAAM,MAAKkB,KAAK,CAACc;gBACjB,OAAOZ,eAAe;YACxB,OAAO,IAAGV,MAAME,IAAI,KAAK,wBAAwB;gBAC/C,MAAMC,YAAYf,KAAKgB,KAAK,CAACJ,MAAMK,QAAQ,CAACC,oBAAoB;gBAChE,IAAIH,YAAYhB,SAAS;oBACvB,MAAM,MAAKqB,KAAK,CAACL,YAAYf,KAAKC,GAAG;oBACrC,OAAOqB;gBACT,CAAC;YACH,CAAC;YACD,MAAMV,MAAM;QACd;;IAEA,sCAAsC;IACtCC,cAAcF,GAAG,EAAE;YAILA;QAHZ,MAAMgC,gBAAgBhC,IAAIJ,QAAQ,IAAI,CAAC;QACvC,MAAMqC,YAAYD,cAAclC,IAAI,IAAI,CAAC;QACzC,MAAMkB,SAASgB,cAAchB,MAAM,IAAIhB,IAAIgB,MAAM;QACjD,MAAMkB,MAAMlC,gBAAAA,iBAAAA,KAAAA,IAAAA,CAAAA,cAAAA,IAAKmC,MAAM,cAAXnC,yBAAAA,KAAAA,IAAAA,YAAakC,GAAF;QAEvB,MAAME,SAASH,UAAUI,OAAO,IAAIrC,IAAIqC,OAAO;QAC/C,MAAMC,gBAAgBL,UAAUI,OAAO,IAAIrC,IAAIuC,IAAI,IAAIvC,IAAIqC,OAAO;QAElE,OAAQrB;YACR,KAAK;gBACH,OAAO,IAAIrC,gBAAgByD,QAAQH,UAAUO,OAAO,IAAIxC,IAAIwC,OAAO,EAAEN;YACvE,KAAK;gBACH,OAAO,IAAI1D,kBAAkB4D,QAAQF;YACvC,KAAK;gBACH,OAAO,IAAIzD,eAAe2D,QAAQF;YACpC,KAAK;gBACH,OAAO,IAAIrD,cAAcuD,QAAQF;YACnC,KAAK;gBACH,OAAO,IAAIrD,cAAcuD,QAAQF;YACnC,KAAK;gBACH,OAAO,IAAIpD,qBAAqBsD,QAAQH,UAAU3B,QAAQ,IAAIN,IAAIM,QAAQ,EAAE4B;YAC9E,KAAK;gBACH,OAAO,IAAItD,cAAcwD,QAAQF;YACnC;gBACE,OAAO,IAAIxD,SAASA,UAAU4D,eAAetB,QAAQkB;QACvD;IACF;IAlJA;;;;;GAKC,GAED;;;;;GAKC,GACDO,YAAYhD,UAAU,EAAE,EAAEiD,kBAAkB,EAAE,EAAEC,YAAY,CAAC,CAAC,CAAE;QAC9D,IAAI,CAAChD,QAAQ,GAAGF,UAAU;QAC1B,IAAI,CAACC,gBAAgB,GAAGgD,kBAAkB;QAC1C,IAAI,CAAClD,QAAQ,GAAGmD,UAAUC,OAAO,IAAI;QACrC,IAAI,CAACb,cAAc,GAAG,AAACY,CAAAA,UAAUE,iBAAiB,IAAI,CAAA,IAAK;QAC3D,IAAI,CAACtD,cAAc,GAAG,AAACoD,CAAAA,UAAUG,iBAAiB,IAAI,EAAC,IAAK;IAC9D;AAgIF;AAxJA;;CAEC,GACD,SAAqB9D,wBAqJpB;AAED;;CAEC,GACD,OAAO,MAAM+D,uBAAuB/D;IAalCa,eAAe;QACb,OAAO,IAAI,CAACmD,UAAU,CAACC,KAAK,CAAC,IAAI,EAAEC;IACrC;IAbA;;;;;GAKC,GACDT,YAAYU,SAAS,EAAE1D,OAAO,EAAEiD,eAAe,EAAEC,SAAS,CAAE;QAC1D,KAAK,CAAClD,SAASiD,iBAAiBC;QAChC,IAAI,CAACK,UAAU,GAAGG;IACpB;AAMF,CAAC"}