@tradejs/core 1.0.0

package/dist/backtest.js

@@ -0,0 +1,574 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/backtest.ts
+var backtest_exports = {};
+__export(backtest_exports, {
+  calculateMaxDrawdown: () => calculateMaxDrawdown,
+  calculateStatsFull: () => calculateStatsFull,
+  classifyMetric: () => classifyMetric,
+  compactOrderLog: () => compactOrderLog,
+  createTestSuite: () => createTestSuite,
+  generateName: () => generateName,
+  generateParamGrid: () => generateParamGrid,
+  getBacktestScore: () => getBacktestScore,
+  getFormatted: () => getFormatted,
+  getTimeline: () => getTimeline,
+  mergeConfigs: () => mergeConfigs,
+  parseTestName: () => parseTestName,
+  sortBestTests: () => sortBestTests
+});
+module.exports = __toCommonJS(backtest_exports);
+
+// src/utils/grid.ts
+var import_lodash = __toESM(require("lodash"));
+
+// src/constants/index.ts
+var BACKTEST_PRELOAD_DAYS = 160;
+var TestThresholdsConfig = {
+  // Период и частота — используем как требования к качеству теста, в скоринг не влияют
+  periodDays: {
+    thresholds: [30, 120],
+    direction: "higher",
+    precision: 0
+  },
+  periodMonths: {
+    thresholds: [1, 6],
+    direction: "higher",
+    precision: 2
+  },
+  orders: {
+    thresholds: [30, 200],
+    direction: "higher",
+    precision: 0
+  },
+  wins: {
+    thresholds: [30, 100],
+    direction: "higher",
+    precision: 0
+  },
+  losses: {
+    thresholds: [20, 50],
+    direction: "lower",
+    precision: 0
+  },
+  ordersPerMonth: {
+    thresholds: [4, 20],
+    direction: "higher",
+    precision: 2
+  },
+  exposure: {
+    thresholds: [20, 60],
+    direction: "higher",
+    isPercent: true,
+    precision: 1
+  },
+  // Доходность
+  amount: {
+    thresholds: [105, 120],
+    direction: "higher",
+    isAmount: true,
+    precision: 2
+  },
+  maxAmount: {
+    thresholds: [140, 180],
+    direction: "higher",
+    isAmount: true,
+    precision: 2
+  },
+  minAmount: {
+    thresholds: [80, 90],
+    direction: "higher",
+    isAmount: true,
+    precision: 2
+  },
+  netProfit: {
+    thresholds: [5, 20],
+    direction: "higher",
+    isAmount: true,
+    precision: 2
+  },
+  totalReturn: {
+    thresholds: [10, 50],
+    direction: "higher",
+    isPercent: true,
+    precision: 1
+  },
+  cagr: {
+    thresholds: [15, 40],
+    direction: "higher",
+    isPercent: true,
+    precision: 1
+  },
+  // Риск и риск/доходность
+  maxDrawdown: {
+    thresholds: [25, 12],
+    direction: "lower",
+    isPercent: true,
+    precision: 1
+  },
+  calmar: {
+    thresholds: [0.5, 2],
+    direction: "higher",
+    precision: 2
+  },
+  // Качество сделок
+  winRate: {
+    thresholds: [40, 60],
+    direction: "higher",
+    isPercent: true,
+    precision: 1
+  },
+  riskRewardRatio: {
+    thresholds: [1.5, 2.5],
+    direction: "higher",
+    precision: 2
+  },
+  expectancy: {
+    thresholds: [0.3, 1],
+    direction: "higher",
+    isPercent: true,
+    precision: 2
+  },
+  maxConsecutiveWins: {
+    thresholds: [2, 6],
+    direction: "higher",
+    precision: 0
+  },
+  maxConsecutiveLosses: {
+    thresholds: [5, 2],
+    direction: "lower",
+    precision: 0
+  },
+  // Sharpe (годовой, по месячным ретернам equity)
+  sharpeRatio: {
+    thresholds: [0.5, 1.5],
+    direction: "higher",
+    precision: 2
+  },
+  score: {
+    thresholds: [10, 100],
+    direction: "higher",
+    precision: 0
+  }
+};
+
+// src/utils/timestamp.ts
+var import_date_fns = require("date-fns");
+var import_date_fns2 = require("date-fns");
+var TIMELINE_STEP = 864e5;
+var getTimestamp = (days = 0) => {
+  if (days > 0) {
+    return (0, import_date_fns2.getUnixTime)((0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), days)) * 1e3;
+  }
+  return (0, import_date_fns2.getUnixTime)(/* @__PURE__ */ new Date()) * 1e3;
+};
+var getTimeline = (start = getTimestamp(BACKTEST_PRELOAD_DAYS), end = getTimestamp(), step = TIMELINE_STEP) => {
+  const res = new Array();
+  for (let ind = start; ind <= end; ind += step) {
+    res.push(ind);
+  }
+  return res;
+};
+var compactOrderLog = (timeline, orderLog) => {
+  const result = [];
+  let currentAmount = orderLog.length > 0 && orderLog[0].amount != null ? orderLog[0].amount : 100;
+  let orderLogCursor = 0;
+  for (let timelineIndex = 0; timelineIndex < timeline.length; timelineIndex++) {
+    const currentTimestamp = timeline[timelineIndex];
+    let lastApplicableOrderIndex = -1;
+    let nextCursor = orderLogCursor;
+    for (let checkIndex = orderLogCursor; checkIndex < orderLog.length; checkIndex++) {
+      const checkOrder = orderLog[checkIndex];
+      if (checkOrder.timestamp <= currentTimestamp) {
+        lastApplicableOrderIndex = checkIndex;
+        nextCursor = checkIndex + 1;
+      } else {
+        break;
+      }
+    }
+    if (lastApplicableOrderIndex !== -1) {
+      currentAmount = orderLog[lastApplicableOrderIndex].amount;
+      orderLogCursor = nextCursor;
+    }
+    result.push([currentTimestamp, currentAmount]);
+  }
+  return result;
+};
+
+// src/utils/uuid.ts
+var import_uuid = require("uuid");
+var uuid = (len = 12) => {
+  const uuid2 = (0, import_uuid.v4)();
+  return uuid2.slice(-len);
+};
+
+// src/utils/grid.ts
+var generateParamGrid = (paramOptions) => {
+  const keys = Object.keys(paramOptions);
+  const combinations = [];
+  const helper = (index = 0, current = {}) => {
+    if (index === keys.length) {
+      combinations.push(current);
+      return;
+    }
+    const key = keys[index];
+    for (const value of paramOptions[key] || []) {
+      const copiedValue = typeof value === "object" && value !== null ? structuredClone(value) : value;
+      helper(index + 1, {
+        ...current,
+        [key]: copiedValue
+      });
+    }
+  };
+  helper();
+  return combinations;
+};
+var generateName = (prefix) => `${prefix}_${uuid(6)}`;
+var mergeConfigs = (configs) => {
+  const result = {};
+  for (const config of configs) {
+    for (const [key, value] of Object.entries(config)) {
+      if (!result[key]) {
+        result[key] = [];
+      }
+      const clonedValue = typeof value === "object" && value !== null ? import_lodash.default.cloneDeep(value) : value;
+      const isDuplicate = result[key].some(
+        (existing) => import_lodash.default.isEqual(existing, value)
+      );
+      if (!isDuplicate) {
+        result[key].push(clonedValue);
+      }
+    }
+  }
+  for (const key in result) {
+    if (result[key].every((v) => typeof v === "number")) {
+      result[key] = import_lodash.default.sortBy(result[key]);
+    }
+  }
+  return result;
+};
+var createTestSuite = (userName, tickers, strategyName, backtestConfig, connectorName) => {
+  const start = getTimestamp(BACKTEST_PRELOAD_DAYS);
+  const end = getTimestamp();
+  const testSuiteId = uuid(6);
+  const paramGrid = generateParamGrid(backtestConfig);
+  return tickers.flatMap(
+    (symbol) => paramGrid.map((params) => {
+      const testId = uuid(6);
+      return {
+        userName,
+        name: `${symbol}_${testSuiteId}_${testId}`,
+        testId,
+        testSuiteId,
+        symbol,
+        options: { start, end },
+        strategyName,
+        strategyConfig: params,
+        connectorName
+      };
+    })
+  );
+};
+
+// src/utils/tests.ts
+var parseTestName = (testName) => {
+  const [symbol, testSuiteId, testId] = testName.split("_");
+  return { symbol, testSuiteId, testId };
+};
+
+// src/utils/stat.ts
+var import_date_fns3 = require("date-fns");
+
+// src/utils/math.ts
+var import_lodash2 = __toESM(require("lodash"));
+var round = (value, precision = 2) => precision > 0 ? Math.round(value * 10 ** precision) / 10 ** precision : Math.round(value);
+var sum = (xs) => xs.reduce((a, b) => a + b, 0);
+var mean = (xs) => xs.length ? sum(xs) / xs.length : 0;
+var absReturns = (data) => data.map((p) => p.close.amount - p.open.amount);
+var relReturns = (data) => data.map((p) => (p.close.amount - p.open.amount) / p.open.amount);
+var equityPoints = (data) => data.flatMap((p) => [
+  { ts: p.open.timestamp, amount: p.open.amount },
+  { ts: p.close.timestamp, amount: p.close.amount }
+]).sort((a, b) => a.ts - b.ts);
+
+// src/utils/stat.ts
+var calcStreaks = (retsAbs) => {
+  let maxW = 0, maxL = 0, cw = 0, cl = 0;
+  for (const r of retsAbs) {
+    if (r > 0) {
+      cw++;
+      cl = 0;
+      if (cw > maxW) maxW = cw;
+    } else if (r < 0) {
+      cl++;
+      cw = 0;
+      if (cl > maxL) maxL = cl;
+    } else {
+      cw = 0;
+      cl = 0;
+    }
+  }
+  return { maxConsecutiveWins: maxW, maxConsecutiveLosses: maxL };
+};
+var calculateMaxDrawdown = (amounts) => {
+  let max = amounts[0];
+  let maxDrawdown = 0;
+  for (const amount of amounts) {
+    if (amount > max) {
+      max = amount;
+    }
+    const drawdown = (max - amount) / max * 100;
+    if (drawdown > maxDrawdown) {
+      maxDrawdown = drawdown;
+    }
+  }
+  return maxDrawdown;
+};
+var computeMonthlyEquityStats = (positionLogData, opts) => {
+  const MAR = opts?.mar ?? 0;
+  const useSample = !!opts?.sampleStd;
+  const tsMul = (opts?.tsUnit ?? "ms") === "s" ? 1e3 : 1;
+  if (!positionLogData.length) {
+    return {
+      eomSeries: [],
+      monthlyReturns: [],
+      monthlyMean: 0,
+      monthlyStd: 0,
+      monthlyDownsideStd: 0,
+      sharpeMonthly: null,
+      sharpeMonthlyAnnualized: null,
+      sortinoMonthly: null,
+      sortinoMonthlyAnnualized: null,
+      positiveMonths: 0,
+      maxMonthlyGain: 0,
+      maxMonthlyDrop: 0
+    };
+  }
+  const equityPoints2 = positionLogData.flatMap((p) => [
+    { ts: p.open.timestamp * tsMul, amount: p.open.amount },
+    { ts: p.close.timestamp * tsMul, amount: p.close.amount }
+  ]).sort((a, b) => a.ts - b.ts);
+  const startTs = equityPoints2[0].ts;
+  const endTs = equityPoints2[equityPoints2.length - 1].ts;
+  const eomSeries = [];
+  let monthCursor = (0, import_date_fns3.startOfMonth)(new Date(startTs));
+  const lastMonth = (0, import_date_fns3.endOfMonth)(new Date(endTs));
+  let i = 0;
+  let lastAmount = equityPoints2[0].amount;
+  while (monthCursor <= lastMonth) {
+    const eom = (0, import_date_fns3.endOfMonth)(monthCursor);
+    const eomTs = eom.getTime();
+    while (i < equityPoints2.length && equityPoints2[i].ts <= eomTs) {
+      lastAmount = equityPoints2[i].amount;
+      i += 1;
+    }
+    const key = `${eom.getFullYear()}-${String(eom.getMonth() + 1).padStart(2, "0")}`;
+    eomSeries.push({ month: key, ts: eomTs, amount: lastAmount });
+    monthCursor = (0, import_date_fns3.addMonths)(monthCursor, 1);
+  }
+  const monthlyReturns = [];
+  for (let k = 1; k < eomSeries.length; k++) {
+    const prev = eomSeries[k - 1].amount;
+    const curr = eomSeries[k].amount;
+    monthlyReturns.push(prev > 0 ? curr / prev - 1 : 0);
+  }
+  const n = monthlyReturns.length;
+  const monthlyMean = n ? monthlyReturns.reduce((a, b) => a + b, 0) / n : 0;
+  const variance = n ? monthlyReturns.reduce((a, v) => a + (v - monthlyMean) ** 2, 0) / (useSample && n > 1 ? n - 1 : n) : 0;
+  const monthlyStd = Math.sqrt(variance);
+  const downside = monthlyReturns.map((r) => Math.min(r - MAR, 0)).filter((v) => v < 0);
+  const nd = downside.length;
+  const downsideVar = nd ? downside.reduce((a, v) => a + v * v, 0) / (useSample && nd > 1 ? nd - 1 : nd) : 0;
+  const monthlyDownsideStd = Math.sqrt(downsideVar);
+  const sharpeMonthly = monthlyStd > 0 ? (monthlyMean - MAR) / monthlyStd : null;
+  const sortinoMonthly = monthlyDownsideStd > 0 ? (monthlyMean - MAR) / monthlyDownsideStd : null;
+  const sharpeMonthlyAnnualized = sharpeMonthly === null ? null : sharpeMonthly * Math.sqrt(12);
+  const sortinoMonthlyAnnualized = sortinoMonthly === null ? null : sortinoMonthly * Math.sqrt(12);
+  const positiveMonths = monthlyReturns.filter((r) => r > 0).length;
+  const maxMonthlyGain = n ? Math.max(...monthlyReturns) : 0;
+  const maxMonthlyDrop = n ? Math.min(...monthlyReturns) : 0;
+  return {
+    eomSeries,
+    monthlyReturns,
+    monthlyMean,
+    monthlyStd,
+    monthlyDownsideStd,
+    sharpeMonthly,
+    sharpeMonthlyAnnualized,
+    sortinoMonthly,
+    sortinoMonthlyAnnualized,
+    positiveMonths,
+    maxMonthlyGain,
+    maxMonthlyDrop
+  };
+};
+var calculateStatsFull = (positionLogData) => {
+  if (!positionLogData.length) return null;
+  const retsAbs = absReturns(positionLogData);
+  const retsRel = relReturns(positionLogData);
+  const points = equityPoints(positionLogData);
+  const startTs = points[0].ts;
+  const endTs = points[points.length - 1].ts;
+  const periodMs = (0, import_date_fns3.differenceInMilliseconds)(new Date(endTs), new Date(startTs));
+  const periodDays = periodMs / (1e3 * 60 * 60 * 24);
+  const periodMonths = periodDays / 30.4375;
+  const trades = positionLogData.length;
+  const tradesPerMonth = periodMonths > 0 ? trades / periodMonths : 0;
+  const durations = positionLogData.map(
+    (p) => p.close.timestamp - p.open.timestamp
+  );
+  const totalTime = endTs - startTs;
+  const exposure = totalTime > 0 ? sum(durations) / totalTime * 100 : 0;
+  const initialAmount = points[0].amount;
+  const finalAmount = points[points.length - 1].amount;
+  const netProfit = finalAmount - initialAmount;
+  const totalReturn = initialAmount > 0 ? (finalAmount / initialAmount - 1) * 100 : 0;
+  const cagr = periodMonths > 0 && initialAmount > 0 ? (Math.pow(finalAmount / initialAmount, 12 / periodMonths) - 1) * 100 : 0;
+  const allAmounts = points.map((p) => p.amount);
+  const maxDrawdown = calculateMaxDrawdown(allAmounts);
+  const calmar = maxDrawdown > 0 ? cagr / maxDrawdown : null;
+  const wins = retsAbs.filter((x) => x > 0).length;
+  const losses = retsAbs.filter((x) => x <= 0).length;
+  const winRate = trades ? wins / trades * 100 : 0;
+  const avgWinAbs = mean(retsAbs.filter((x) => x > 0));
+  const avgLossAbs = Math.abs(mean(retsAbs.filter((x) => x < 0)));
+  const payoff = avgLossAbs > 0 ? avgWinAbs / avgLossAbs : null;
+  const avgWinRel = mean(retsRel.filter((x) => x > 0));
+  const avgLossRel = Math.abs(mean(retsRel.filter((x) => x < 0)));
+  const pWin = trades ? wins / trades : 0;
+  const expectancyPerTrade = (pWin * avgWinRel - (1 - pWin) * avgLossRel) * 100;
+  const { maxConsecutiveWins, maxConsecutiveLosses } = calcStreaks(retsAbs);
+  const monthly = computeMonthlyEquityStats(positionLogData, {
+    mar: 0,
+    // MAR=0, при желании можно параметризовать
+    sampleStd: false,
+    // population std
+    tsUnit: "ms"
+    // timestamps в миллисекундах
+  });
+  const sharpe = (monthly.sharpeMonthly ?? null) !== null ? monthly.sharpeMonthly * Math.sqrt(12) : null;
+  const res = {
+    // Период и частота
+    periodDays: round(periodDays),
+    periodMonths: round(periodMonths),
+    orders: trades,
+    wins,
+    losses,
+    ordersPerMonth: round(tradesPerMonth),
+    exposure: round(exposure),
+    // Доходность
+    amount: round(finalAmount),
+    maxAmount: round(Math.max(...allAmounts)),
+    minAmount: round(Math.min(...allAmounts)),
+    netProfit: round(netProfit),
+    totalReturn: round(totalReturn),
+    cagr: round(cagr),
+    // Риск и Calmar
+    maxDrawdown: round(maxDrawdown),
+    calmar: calmar === null ? null : round(calmar),
+    // Качество сделок
+    winRate: round(winRate),
+    riskRewardRatio: payoff === null ? null : round(payoff),
+    expectancy: round(expectancyPerTrade),
+    maxConsecutiveWins,
+    maxConsecutiveLosses,
+    // Sharpe (годовой) по месячным ретёрнам equity
+    sharpeRatio: sharpe === null ? null : round(sharpe)
+  };
+  const score = getBacktestScore(res);
+  return {
+    ...res,
+    score
+  };
+};
+var classifyMetric = (name, value) => {
+  const { thresholds, direction } = TestThresholdsConfig[name];
+  if (direction === "higher") {
+    if (value >= thresholds[1]) return "success";
+    if (value >= thresholds[0]) return "warning";
+    return "error";
+  } else {
+    if (value <= thresholds[1]) return "success";
+    if (value <= thresholds[0]) return "warning";
+    return "error";
+  }
+};
+var getBacktestScore = (stat) => {
+  if (!stat) {
+    return 0;
+  }
+  const netProfit = Number(stat.netProfit ?? 0);
+  const winRate = Number(stat.winRate ?? 0);
+  if (!Number.isFinite(netProfit) || !Number.isFinite(winRate)) {
+    return 0;
+  }
+  return Math.round(netProfit * winRate);
+};
+var sortBestTests = (results, limit = 5) => {
+  return results.sort((a, b) => (b.stat.amount ?? 0) - (a.stat.amount ?? 0)).slice(0, limit);
+};
+var getFormatted = (stat, key) => {
+  if (!stat) {
+    return {
+      formatted: "0",
+      level: "error"
+    };
+  }
+  const raw = stat[key];
+  if (raw == null || typeof raw === "string") {
+    return {
+      formatted: String(raw ?? "-"),
+      level: "error"
+    };
+  }
+  const config = TestThresholdsConfig[key];
+  const level = config ? classifyMetric(key, raw) : "success";
+  const formatted = config ? `${raw.toFixed(config.precision)}${config.isPercent ? "%" : ""}${config.isAmount ? "$" : ""}` : String(raw);
+  return {
+    formatted,
+    level
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateMaxDrawdown,
+  calculateStatsFull,
+  classifyMetric,
+  compactOrderLog,
+  createTestSuite,
+  generateName,
+  generateParamGrid,
+  getBacktestScore,
+  getFormatted,
+  getTimeline,
+  mergeConfigs,
+  parseTestName,
+  sortBestTests
+});