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)
265 lines (264 loc) • 28.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);
});
};
}
import TimeoutError from '../clients/timeoutError';
import LoggerManager from '../logger';
import _ from 'lodash';
const realSetTimeout = setTimeout;
const realDateNow = Date.now.bind(Date);
/**
* Creates a promise that can be used as a handle. It will not raise errors when rejected until it is explicitly
* awaited or catch is set
* @returns modified handle promise
*/ export function createHandlePromise() {
let resolve, reject;
let promise = new Promise((res, rej)=>{
resolve = res;
reject = rej;
});
promise.completed = false;
promise.resolve = (result)=>{
if (!promise.completed) {
promise.completed = true;
promise.resolved = true;
promise.result = result;
resolve(result);
}
};
promise.reject = (err)=>{
if (!promise.completed) {
promise.completed = true;
promise.rejected = true;
promise.error = err;
reject(err);
}
};
promise.timeout = (milliseconds, errorMessage)=>{
if (!promise.completed) {
let timeout = setTimeout(()=>promise.reject(new TimeoutError(errorMessage)), milliseconds);
promise.finally(()=>clearTimeout(timeout)).catch(()=>{});
}
return promise;
};
promise.catch(()=>{});
return promise;
}
/**
* Wraps a promise into a handle promise
* @param promise native promise
* @returns handle promise
*/ export function wrapHandlePromise(promise) {
let result = createHandlePromise();
promise.then(result.resolve).catch(()=>{});
promise.catch(result.reject);
return result;
}
/**
* This function ensures that a promise is returned
* @param call call
* @returns promise
*/ export function ensurePromise(call) {
return _ensurePromise.apply(this, arguments);
}
function _ensurePromise() {
_ensurePromise = _async_to_generator(function*(call) {
return call();
});
return _ensurePromise.apply(this, arguments);
}
/**
* Waits specified delay
* @param ms Milliseconds to wait
* @param options Additional options
* @return promise resolving when the delay has ended
*/ export function delay(ms, options) {
let resolve;
let timeout;
let canceled = false;
let result = new Promise((res)=>{
timeout = (options === null || options === void 0 ? void 0 : options.ignoreSinonClock) ? realSetTimeout(res, ms) : setTimeout(res, ms);
resolve = res;
});
Object.defineProperty(result, 'canceled', {
get: ()=>canceled,
enumerable: true,
configurable: true
});
result.cancel = ()=>{
canceled = true;
clearTimeout(timeout);
resolve();
};
return result;
}
/**
* Assembles log4js config from logging level map
* @param {Object} [config] log4js config
* @param {String} [config.defaultLevel = 'INFO'] Default logging level
* @param {Object} [config.levels] Logging levels
* @return {Object} Log4js config
*/ export function assembleLog4jsConfig(config = {}) {
let appenders = {
console: {
type: 'console'
}
};
let categories = {
default: {
appenders: Object.keys(appenders),
level: config.defaultLevel || 'INFO'
}
};
Object.keys(config.levels || {}).forEach((category)=>{
categories[category] = {
appenders: Object.keys(appenders),
level: config.levels[category]
};
});
return {
appenders,
categories
};
}
/**
* Waits untill specified callable will pass successfully and return true. Uses log4js logger named `helpers.wait`
* @param {() => boolean|Promise<boolean>} callable Callable to call until it returns true
* @param {Number} [intervalInMs = 25] Interval in milliseconds between the checks
* @param {WaitOptions & DelayOptions} [options] Additional wait options
* @return {Promise} Promise resolving with callable return value when waited
* @throws {Error|TimeoutError} Error from the callable or timeout error when timed out
*/ // eslint-disable-next-line complexity
export function wait(callable) {
return _wait.apply(this, arguments);
}
function _wait() {
_wait = _async_to_generator(function*(callable, intervalInMs = 25, options) {
const logger = LoggerManager.getLogger('helpers.wait');
if (typeof intervalInMs === 'object') {
// for backward compatibility
options = intervalInMs;
intervalInMs = _.defaultTo(options.intervalInMs, 1000);
}
const dateNow = (options === null || options === void 0 ? void 0 : options.ignoreSinonClock) ? realDateNow : ()=>Date.now();
let result = false, lastError;
let timesAt = dateNow() + _.defaultTo(options === null || options === void 0 ? void 0 : options.timeoutInMs, 30000);
while(!result && dateNow() < timesAt){
try {
result = yield callable();
} catch (err) {
lastError = err;
logger.debug('The executor failed', err);
if (dateNow() >= timesAt) {
throw err;
}
} finally{
if (!result) {
logger.debug('Waiting because the result is', result);
yield delay(intervalInMs, options);
}
}
}
if (dateNow() >= timesAt) {
if (lastError) {
throw lastError;
}
throw new TimeoutError('Timed out till specified callable returns true');
}
return result;
});
return _wait.apply(this, arguments);
}
/**
* Waits untill specified callable will pass successfully and return true. Uses log4js logger named `helpers.wait`
* @param {() => boolean|Promise<boolean>} callable Callable to call until it returns true
* @param {Number} [intervalInMs = 25] Interval in milliseconds between the checks
* @param {WaitOptions & DelayOptions} [options] Additional wait options
* @return {Promise} Promise resolving with callable return value when waited
* @throws {Error|TimeoutError} Error from the callable or timeout error when timed out
*/ export function waitTrue(callable, intervalInMs = 25, options) {
return wait(callable, intervalInMs, options);
}
/**
* Waits untill specified callable will pass successfully. Uses log4js logger named `helpers.wait`
* @param {() => boolean|Promise<boolean>} callable Callable to call
* @param {Number} [intervalInMs = 25] Interval in milliseconds between the checks
* @param {WaitOptions & DelayOptions} [options] Additional wait options
* @return {Promise} Promise resolving with callable return value when waited
* @throws {Error|TimeoutError} Error from the callable or timeout error when timed out
*/ export function waitPass(callable) {
return _waitPass.apply(this, arguments);
}
function _waitPass() {
_waitPass = _async_to_generator(function*(callable, intervalInMs = 25, options) {
let result;
yield wait(/*#__PURE__*/ _async_to_generator(function*() {
result = yield callable();
return true;
}), intervalInMs, options);
return result;
});
return _waitPass.apply(this, arguments);
}
/**
* Waits untill specified callable successfully returns any non-undefined value. Uses log4js logger named `helpers.wait`
* @param callable Callable to call
* @param intervalInMs Interval in milliseconds between the checks
* @param options Additional wait options
* @return Promise resolving with callable return value when waited
* @throws {Error|TimeoutError} Error from the callable or timeout error when timed out
*/ export function waitAny(callable) {
return _waitAny.apply(this, arguments);
}
function _waitAny() {
_waitAny = _async_to_generator(function*(callable, intervalInMs = 25, options) {
let result;
yield waitTrue(/*#__PURE__*/ _async_to_generator(function*() {
result = yield callable();
if (result !== undefined) {
return true;
}
}), intervalInMs, options);
return result;
});
return _waitAny.apply(this, arguments);
}
/**
* Calculates exponential backoff delay. At the initial iteration, there is no delay. At the next iteration, the delay
* is `startDelay`. Further, at the every next iteration the previous delay multiplies to 2
* @param iteration current iteration, where 0 is initial iteration without delaying
* @param startDelay start delay
* @param maxDelay maximum delay
*/ export function expBackoffDelay(iteration, startDelay, maxDelay) {
if (iteration === 0) {
return 0;
}
return Math.min(startDelay * Math.pow(2, iteration - 1), maxDelay);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["<anon>"],"sourcesContent":["'use strict';\n\nimport TimeoutError from '../clients/timeoutError';\nimport LoggerManager from '../logger';\nimport {PromiseOrNot} from '../types/util';\nimport _ from 'lodash';\n\nconst realSetTimeout = setTimeout;\nconst realDateNow = Date.now.bind(Date);\n\n/** An extended promise with additional properties and methods */\nexport interface HandlePromise<T> extends Promise<T> {\n  /** Whether the promise is resolved or rejected */\n  completed: boolean,\n  /** Whether the promise is resolved */\n  resolved?: boolean,\n  /** Whether the promise is rejected */\n  rejected?: boolean,\n  /** Result value the promise resolved with */\n  result?: T,\n  /** Error the promise rejected with */\n  error?: Error,\n  /**\n   * Resolves the promise with specified value\n   * @param result Value to resolve the promise with\n   */\n  resolve(result?: T): void,\n  /**\n   * Rejects the promise with specified error\n   * @param err Error to reject the promise with\n   */\n  reject(err: Error): void,\n  /**\n   * Adds a timeout to reject the promise with `TimeoutError`\n   * @param milliseconds timeout in milliseconds\n   * @param errorMessage error message\n   * @returns self\n   */\n  timeout(milliseconds: number, errorMessage: string): HandlePromise<T>\n}\n\n/**\n * Creates a promise that can be used as a handle. It will not raise errors when rejected until it is explicitly\n * awaited or catch is set\n * @returns modified handle promise\n */\nexport function createHandlePromise<T>(): HandlePromise<T> {\n  let resolve, reject;\n  let promise = new Promise((res, rej) => {\n    resolve = res;\n    reject = rej;\n  }) as HandlePromise<T>;\n  promise.completed = false;\n  promise.resolve = (result) => {\n    if (!promise.completed) {\n      promise.completed = true;\n      promise.resolved = true;\n      promise.result = result;\n      resolve(result);\n    }\n  };\n  promise.reject = (err) => {\n    if (!promise.completed) {\n      promise.completed = true;\n      promise.rejected = true;\n      promise.error = err;\n      reject(err);\n    }\n  };\n  promise.timeout = (milliseconds, errorMessage) => {\n    if (!promise.completed) {\n      let timeout = setTimeout(() => promise.reject(new TimeoutError(errorMessage)), milliseconds);\n      promise.finally(() => clearTimeout(timeout)).catch(() => {});\n    }\n    return promise;\n  };\n  promise.catch(() => {});\n  return promise;\n}\n\n/**\n * Wraps a promise into a handle promise\n * @param promise native promise\n * @returns handle promise\n */\nexport function wrapHandlePromise<T>(promise: Promise<T>): HandlePromise<T> {\n  let result = createHandlePromise<T>();\n  promise.then(result.resolve).catch(() => {});\n  promise.catch(result.reject);\n  return result;\n}\n\n/**\n * This function ensures that a promise is returned\n * @param call call\n * @returns promise\n */\nexport async function ensurePromise<T>(call: () => PromiseOrNot<T>): Promise<T> {\n  return call();\n}\n\n/** Additional delay options */\nexport type DelayOptions = {\n  /** Whether to delay real time, if a stubbed frozen `sinon` clock is used */\n  ignoreSinonClock?: boolean\n};\n\n/**\n * Waits specified delay\n * @param ms Milliseconds to wait\n * @param options Additional options\n * @return promise resolving when the delay has ended\n */\nexport function delay(ms: number, options?: DelayOptions): DelayPromise {\n  let resolve: () => void;\n  let timeout: NodeJS.Timeout;\n  let canceled = false;\n  let result = new Promise<void>(res => {\n    timeout = options?.ignoreSinonClock ? realSetTimeout(res, ms) : setTimeout(res, ms);\n    resolve = res;\n  }) as DelayPromise;\n  Object.defineProperty(result, 'canceled', {\n    get: () => canceled,\n    enumerable: true,\n    configurable: true\n  });\n  result.cancel = () => {\n    canceled = true;\n    clearTimeout(timeout);\n    resolve();\n  };\n  return result;\n}\n\n/**\n * Delay promise\n */\nexport interface DelayPromise extends Promise<void> {\n  /**\n   * Returns whether the promise is canceled\n   * @returns whether canceled\n   */\n  get canceled(): boolean;\n  /**\n   * Cancels waiting and resolves the promise immediately\n   */\n  cancel(): void;\n}\n\n/**\n * Assembles log4js config from logging level map\n * @param {Object} [config] log4js config\n * @param {String} [config.defaultLevel = 'INFO'] Default logging level\n * @param {Object} [config.levels] Logging levels\n * @return {Object} Log4js config\n */\nexport function assembleLog4jsConfig(config: any = {}) {\n  let appenders = {console: {type: 'console'}};\n  let categories = {\n    default: {\n      appenders: Object.keys(appenders),\n      level: config.defaultLevel || 'INFO'\n    }\n  };\n  Object.keys(config.levels || {}).forEach((category) => {\n    categories[category] = {\n      appenders: Object.keys(appenders),\n      level: config.levels[category]\n    };\n  });\n  return {appenders, categories};\n}\n\n/** Options for `wait*` functions */\nexport type WaitOptions = {\n  /** Wait timeout in milliseconds. Defaults to `30000` */\n  timeoutInMs?: number\n};\n\n/**\n * Waits untill specified callable will pass successfully and return true. Uses log4js logger named `helpers.wait`\n * @param {() => boolean|Promise<boolean>} callable Callable to call until it returns true\n * @param {Number} [intervalInMs = 25] Interval in milliseconds between the checks\n * @param {WaitOptions & DelayOptions} [options] Additional wait options\n * @return {Promise} Promise resolving with callable return value when waited\n * @throws {Error|TimeoutError} Error from the callable or timeout error when timed out\n */\n// eslint-disable-next-line complexity\nexport async function wait(callable, intervalInMs = 25, options?: WaitOptions & DelayOptions) {\n  const logger = LoggerManager.getLogger('helpers.wait');\n  if (typeof intervalInMs === 'object') {\n    // for backward compatibility\n    options = intervalInMs;\n    intervalInMs = _.defaultTo((options as any).intervalInMs, 1000);\n  }\n  const dateNow = options?.ignoreSinonClock ? realDateNow : () => Date.now();\n  let result = false, lastError;\n  let timesAt = dateNow() + _.defaultTo(options?.timeoutInMs, 30000);\n  while (!result && dateNow() < timesAt) {\n    try {\n      result = await callable();\n    } catch (err) {\n      lastError = err;\n      logger.debug('The executor failed', err);\n      if (dateNow() >= timesAt) {\n        throw err;\n      }\n    } finally {\n      if (!result) {\n        logger.debug('Waiting because the result is', result);\n        await delay(intervalInMs, options);\n      }\n    }\n  }\n  if (dateNow() >= timesAt) {\n    if (lastError) {\n      throw lastError;\n    }\n    throw new TimeoutError('Timed out till specified callable returns true');\n  }\n  return result;\n}\n\n/**\n * Waits untill specified callable will pass successfully and return true. Uses log4js logger named `helpers.wait`\n * @param {() => boolean|Promise<boolean>} callable Callable to call until it returns true\n * @param {Number} [intervalInMs = 25] Interval in milliseconds between the checks\n * @param {WaitOptions & DelayOptions} [options] Additional wait options\n * @return {Promise} Promise resolving with callable return value when waited\n * @throws {Error|TimeoutError} Error from the callable or timeout error when timed out\n */\nexport function waitTrue(callable, intervalInMs = 25, options?: WaitOptions & DelayOptions) {\n  return wait(callable, intervalInMs, options);\n}\n\n/**\n * Waits untill specified callable will pass successfully. Uses log4js logger named `helpers.wait`\n * @param {() => boolean|Promise<boolean>} callable Callable to call\n * @param {Number} [intervalInMs = 25] Interval in milliseconds between the checks\n * @param {WaitOptions & DelayOptions} [options] Additional wait options\n * @return {Promise} Promise resolving with callable return value when waited\n * @throws {Error|TimeoutError} Error from the callable or timeout error when timed out\n */\nexport async function waitPass<T = void>(\n  callable: () => PromiseOrNot<T>,\n  intervalInMs = 25,\n  options?: WaitOptions & DelayOptions\n): Promise<T> {\n  let result;\n  await wait(async () => {\n    result = await callable();\n    return true;\n  }, intervalInMs, options);\n  return result;\n}\n\n/**\n * Waits untill specified callable successfully returns any non-undefined value. Uses log4js logger named `helpers.wait`\n * @param callable Callable to call\n * @param intervalInMs Interval in milliseconds between the checks\n * @param options Additional wait options\n * @return Promise resolving with callable return value when waited\n * @throws {Error|TimeoutError} Error from the callable or timeout error when timed out\n */\nexport async function waitAny<T>(\n  callable: () => PromiseOrNot<T>, intervalInMs = 25, options?: WaitOptions\n): Promise<T> {\n  let result: T;\n  await waitTrue(async () => {\n    result = await callable();\n    if (result !== undefined) {\n      return true;\n    }\n  }, intervalInMs, options);\n  return result;\n}\n\n/**\n * Calculates exponential backoff delay. At the initial iteration, there is no delay. At the next iteration, the delay\n * is `startDelay`. Further, at the every next iteration the previous delay multiplies to 2\n * @param iteration current iteration, where 0 is initial iteration without delaying\n * @param startDelay start delay\n * @param maxDelay maximum delay\n */\nexport function expBackoffDelay(iteration: number, startDelay: number, maxDelay: number) {\n  if (iteration === 0) {\n    return 0;\n  }\n  return Math.min(startDelay * Math.pow(2, iteration - 1), maxDelay);\n}\n"],"names":["TimeoutError","LoggerManager","_","realSetTimeout","setTimeout","realDateNow","Date","now","bind","createHandlePromise","resolve","reject","promise","Promise","res","rej","completed","result","resolved","err","rejected","error","timeout","milliseconds","errorMessage","finally","clearTimeout","catch","wrapHandlePromise","then","ensurePromise","call","delay","ms","options","canceled","ignoreSinonClock","Object","defineProperty","get","enumerable","configurable","cancel","assembleLog4jsConfig","config","appenders","console","type","categories","default","keys","level","defaultLevel","levels","forEach","category","wait","callable","intervalInMs","logger","getLogger","defaultTo","dateNow","lastError","timesAt","timeoutInMs","debug","waitTrue","waitPass","waitAny","undefined","expBackoffDelay","iteration","startDelay","maxDelay","Math","min","pow"],"mappings":"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"}