@tradejs/node 3.0.1 → 3.1.0

package/dist/backtest.mjs

@@ -1,15 +1,15 @@
 import {
   BUILTIN_CONNECTOR_NAMES,
   getConnectorCreatorByName
-} from "./chunk-V3YMKE4I.mjs";
+} from "./chunk-3TWULKHV.mjs";
 import {
   buildMlPayload,
   enrichSignalWithMarketContextStages
-} from "./chunk-OGAWBO3Z.mjs";
+} from "./chunk-MKLTJQLY.mjs";
 import {
   buildAiPayload,
   getStrategyCreator
-} from "./chunk-VRXU4E4O.mjs";
+} from "./chunk-KOQSLFT2.mjs";
 import {
   getTradejsProjectCwd
 } from "./chunk-WS5DYEVZ.mjs";

package/dist/chunk-3TWULKHV.mjs

@@ -0,0 +1,595 @@
+import {
+  getTradejsProjectCwd,
+  importTradejsModule,
+  loadTradejsConfig,
+  resolvePluginModuleSpecifier
+} from "./chunk-WS5DYEVZ.mjs";
+
+// src/connectorRuntime.ts
+import { logger as logger2 } from "@tradejs/infra/logger";
+import { resolveTradingAccount } from "@tradejs/infra/tradingAccounts";
+
+// src/timescaleCachedKline.ts
+import { PRELOAD_FALLBACK_DAYS } from "@tradejs/core/constants";
+import { mergeData } from "@tradejs/core/data";
+import { getItemTimestamp, getTimestamp } from "@tradejs/core/time";
+import { delay } from "@tradejs/core/async";
+import { logger } from "@tradejs/infra/logger";
+import {
+  getCandlesRange,
+  getDataEdges,
+  toRows,
+  upsertCandles
+} from "@tradejs/infra/timescale/candles";
+var DEFAULT_LIMIT = 1e3;
+var DEFAULT_CACHE_FALLBACK_WINDOW = 1e3;
+var DEFAULT_TIMESCALE_RETRIES = 2;
+var DEFAULT_TIMESCALE_RETRY_DELAY_MS = 1e3;
+var resolveNonNegativeInt = (value, fallback) => {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return fallback;
+  }
+  return Math.floor(parsed);
+};
+var getTimescaleRetryCount = () => resolveNonNegativeInt(
+  process.env.TIMESCALE_KLINE_RETRIES,
+  DEFAULT_TIMESCALE_RETRIES
+);
+var getTimescaleRetryDelayMs = () => resolveNonNegativeInt(
+  process.env.TIMESCALE_KLINE_RETRY_DELAY_MS,
+  DEFAULT_TIMESCALE_RETRY_DELAY_MS
+);
+var intervalMsOf = (interval) => interval * 6e4;
+var clampToClosedCandle = (value, intervalMs) => Math.floor(value / intervalMs) * intervalMs;
+var normalizeRangeToClosed = (intervalMs, start, end) => {
+  const lastClosed = Math.floor(Date.now() / intervalMs) * intervalMs;
+  const normStart = start !== void 0 ? clampToClosedCandle(start, intervalMs) : 0;
+  const cappedEnd = Math.min(end ?? Date.now(), lastClosed);
+  const normEnd = clampToClosedCandle(cappedEnd, intervalMs);
+  return { normStart, normEnd };
+};
+var rowsToKline = (rows) => rows.map(({ ts, ...data }) => ({
+  timestamp: new Date(ts).getTime(),
+  ...data
+}));
+var createTimescaleCachedKline = ({
+  provider,
+  request,
+  intervalToMinutes,
+  limit = DEFAULT_LIMIT,
+  cacheFallbackWindow = DEFAULT_CACHE_FALLBACK_WINDOW
+}) => {
+  let isTimescaleFallbackMode = false;
+  const runTimescaleOperation = async (operation) => {
+    const retries = getTimescaleRetryCount();
+    const retryDelayMs = getTimescaleRetryDelayMs();
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        return await operation();
+      } catch (error) {
+        if (attempt >= retries) {
+          throw error;
+        }
+        const waitMs = retryDelayMs * 2 ** attempt;
+        if (waitMs > 0) {
+          await delay(waitMs);
+        }
+      }
+    }
+  };
+  const loadData = async (direction, pointer, limitBoundary, requestParams, intervalMs, options = {}) => {
+    if (pointer === void 0) return { data: [], loaded: false };
+    let accumulated = [];
+    let fulfilled = false;
+    let loaded = false;
+    const shouldAccumulate = options.accumulate ?? true;
+    while (!fulfilled) {
+      const currentPointer = pointer;
+      const params = {
+        symbol: requestParams.symbol,
+        interval: requestParams.interval,
+        silent: requestParams.silent,
+        end: requestParams.end
+      };
+      if (direction === "older") {
+        params.end = pointer;
+        if (limitBoundary !== void 0) params.start = limitBoundary;
+      } else {
+        params.start = pointer;
+        if (limitBoundary !== void 0) params.end = limitBoundary;
+      }
+      const partData = await request(params);
+      if (!partData.length) {
+        fulfilled = true;
+        break;
+      }
+      loaded = true;
+      if (options.onPartData) {
+        await options.onPartData(partData);
+      }
+      if (shouldAccumulate) {
+        accumulated = direction === "older" ? mergeData(partData, accumulated) : mergeData(accumulated, partData);
+      }
+      const boundaryReached = limitBoundary !== void 0 && (direction === "older" && currentPointer <= limitBoundary || direction === "newer" && currentPointer >= limitBoundary);
+      if (partData.length < limit || boundaryReached) {
+        fulfilled = true;
+        break;
+      }
+      const nextPointer = direction === "older" ? getItemTimestamp(partData[0]) - intervalMs : getItemTimestamp(partData[partData.length - 1]) + intervalMs;
+      if (!Number.isFinite(nextPointer) || nextPointer === currentPointer) {
+        fulfilled = true;
+        break;
+      }
+      pointer = nextPointer;
+    }
+    return { data: accumulated, loaded };
+  };
+  const refreshTail = async ({
+    symbol,
+    interval,
+    silent,
+    tailCount = 2
+  }) => {
+    const intMinutes = intervalToMinutes(interval);
+    if (!intMinutes) {
+      logger.log("error", "refreshTail: invalid interval %s", interval);
+      return;
+    }
+    const intervalMs = intervalMsOf(intMinutes);
+    const lastClosed = Math.floor(Date.now() / intervalMs) * intervalMs;
+    const tailEnd = lastClosed + intervalMs;
+    const tailStart = tailEnd - tailCount * intervalMs;
+    const part = await request({
+      symbol,
+      interval,
+      start: tailStart,
+      end: tailEnd,
+      silent
+    });
+    if (part.length) {
+      await runTimescaleOperation(
+        () => upsertCandles(toRows(provider, symbol, intMinutes, part))
+      );
+    }
+  };
+  return async ({
+    symbol,
+    interval,
+    start: defaultStart,
+    end: defaultEnd,
+    silent = false,
+    cacheOnly = false,
+    warmOnly = false
+  }) => {
+    const intMinutes = intervalToMinutes(interval);
+    if (!intMinutes) {
+      logger.log("error", "kline: invalid interval %s", interval);
+      return [];
+    }
+    if (defaultStart !== void 0 && defaultEnd !== void 0 && defaultEnd <= defaultStart) {
+      return [];
+    }
+    const intervalMs = intervalMsOf(intMinutes);
+    try {
+      const edges = await runTimescaleOperation(
+        () => getDataEdges(provider, symbol, intMinutes)
+      );
+      let dataStart = edges.min;
+      let dataEnd = edges.max;
+      const { normStart, normEnd } = normalizeRangeToClosed(
+        intervalMs,
+        defaultStart,
+        defaultEnd
+      );
+      if (cacheOnly) {
+        const base = edges.max ?? Date.now();
+        const s = Math.max(
+          defaultStart ?? base - cacheFallbackWindow * intervalMs,
+          0
+        );
+        const e = defaultEnd ?? base;
+        const dbData2 = await runTimescaleOperation(
+          () => getCandlesRange(provider, symbol, intMinutes, s, e)
+        );
+        return rowsToKline(dbData2);
+      }
+      const needOlderData = defaultStart !== void 0 && (dataStart === void 0 || normStart < dataStart);
+      const persistPartData = warmOnly ? (partData) => runTimescaleOperation(
+        () => upsertCandles(toRows(provider, symbol, intMinutes, partData))
+      ) : void 0;
+      if (needOlderData) {
+        const pointerForOlder = dataStart ?? normEnd ?? Date.now();
+        const olderResult = await loadData(
+          "older",
+          pointerForOlder,
+          normStart,
+          {
+            symbol,
+            interval,
+            silent,
+            start: normStart,
+            end: pointerForOlder
+          },
+          intervalMs,
+          {
+            accumulate: !warmOnly,
+            onPartData: persistPartData
+          }
+        );
+        if (warmOnly && olderResult.loaded) {
+          dataStart = normStart;
+          if (dataEnd === void 0) {
+            dataEnd = normEnd;
+          }
+        } else if (olderResult.data.length) {
+          await runTimescaleOperation(
+            () => upsertCandles(
+              toRows(provider, symbol, intMinutes, olderResult.data)
+            )
+          );
+          dataStart = normStart;
+          if (dataEnd === void 0) {
+            dataEnd = normEnd;
+          }
+        }
+      }
+      const needNewerData = defaultEnd !== void 0 && (dataEnd === void 0 || normEnd > dataEnd);
+      if (needNewerData) {
+        const fallbackStart = getTimestamp(PRELOAD_FALLBACK_DAYS);
+        const pointerForNewer = dataEnd ?? (defaultStart !== void 0 ? normStart : fallbackStart) ?? 0;
+        const newerResult = await loadData(
+          "newer",
+          pointerForNewer,
+          normEnd,
+          {
+            symbol,
+            interval,
+            silent,
+            start: pointerForNewer,
+            end: normEnd
+          },
+          intervalMs,
+          {
+            accumulate: !warmOnly,
+            onPartData: persistPartData
+          }
+        );
+        if (warmOnly && newerResult.loaded) {
+          dataEnd = normEnd;
+        } else if (newerResult.data.length) {
+          await runTimescaleOperation(
+            () => upsertCandles(
+              toRows(provider, symbol, intMinutes, newerResult.data)
+            )
+          );
+          dataEnd = normEnd;
+        }
+      }
+      const isRightEdgeQuery = defaultEnd === void 0 || defaultEnd && defaultEnd >= Date.now() - intervalMs;
+      if (!cacheOnly && isRightEdgeQuery) {
+        await refreshTail({ symbol, interval, silent });
+      }
+      if (warmOnly) {
+        if (isTimescaleFallbackMode) {
+          isTimescaleFallbackMode = false;
+          logger.log("info", "TimescaleDB connection restored for kline cache");
+        }
+        return [];
+      }
+      const rangeStart = defaultStart ?? dataStart ?? 0;
+      const rangeEnd = defaultEnd ?? dataEnd ?? Date.now();
+      const { normStart: finalStart, normEnd: finalEnd } = normalizeRangeToClosed(intervalMs, rangeStart, rangeEnd);
+      const dbData = await runTimescaleOperation(
+        () => getCandlesRange(provider, symbol, intMinutes, finalStart, finalEnd)
+      );
+      if (isTimescaleFallbackMode) {
+        isTimescaleFallbackMode = false;
+        logger.log("info", "TimescaleDB connection restored for kline cache");
+      }
+      return rowsToKline(dbData);
+    } catch (error) {
+      if (!isTimescaleFallbackMode) {
+        isTimescaleFallbackMode = true;
+        logger.log(
+          "warn",
+          "TimescaleDB unavailable for %s %s: %s. Falling back to exchange API.",
+          symbol,
+          interval,
+          String(error)
+        );
+      }
+      if (cacheOnly || warmOnly) {
+        return [];
+      }
+      return request({
+        symbol,
+        interval,
+        start: defaultStart,
+        end: defaultEnd,
+        silent
+      });
+    }
+  };
+};
+
+// src/connectorRuntime.ts
+var connectorRuntime = {
+  logger: logger2,
+  resolveTradingAccount,
+  createCachedKline: createTimescaleCachedKline
+};
+var bindConnectorRuntime = (creator, runtime = connectorRuntime) => {
+  const boundCreator = (config) => creator(config, runtime);
+  return boundCreator;
+};
+
+// src/connectorsRegistry.ts
+import { logger as logger3 } from "@tradejs/infra/logger";
+var createConnectorRegistryState = () => ({
+  connectorCreators: /* @__PURE__ */ new Map(),
+  providerToConnectorName: /* @__PURE__ */ new Map(),
+  pluginsLoadPromise: null
+});
+var registryStateByProjectRoot = /* @__PURE__ */ new Map();
+var getConnectorRegistryState = (cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  let state = registryStateByProjectRoot.get(projectRoot);
+  if (!state) {
+    state = createConnectorRegistryState();
+    registryStateByProjectRoot.set(projectRoot, state);
+  }
+  return {
+    projectRoot,
+    state
+  };
+};
+var BUILTIN_CONNECTOR_NAMES = {
+  ByBit: "ByBit",
+  Binance: "Binance",
+  Coinbase: "Coinbase",
+  Test: "Test"
+};
+var normalizeProvider = (value) => String(value ?? "").trim().toLowerCase();
+var toUniqueModules = (modules = []) => [
+  ...new Set(modules.map((moduleName) => moduleName.trim()).filter(Boolean))
+];
+var findConnectorNameInsensitive = (name, connectorCreators) => {
+  const normalized = name.trim().toLowerCase();
+  if (!normalized) {
+    return null;
+  }
+  for (const existingName of connectorCreators.keys()) {
+    if (existingName.toLowerCase() === normalized) {
+      return existingName;
+    }
+  }
+  return null;
+};
+var normalizeProviders = (providers, connectorName) => {
+  const list = Array.isArray(providers) ? providers.map((item) => normalizeProvider(item)).filter(Boolean) : [];
+  const deduped = [...new Set(list)];
+  if (deduped.length) {
+    return deduped;
+  }
+  return [normalizeProvider(connectorName)];
+};
+var registerProvider = (provider, connectorName, source, providerToConnectorName) => {
+  const existing = providerToConnectorName.get(provider);
+  if (existing && existing !== connectorName) {
+    logger3.warn(
+      'Skip duplicate connector provider "%s" from %s: already mapped to %s',
+      provider,
+      source,
+      existing
+    );
+    return;
+  }
+  providerToConnectorName.set(provider, connectorName);
+};
+var registerEntry = (entry, source, state) => {
+  const connectorName = String(entry?.name ?? "").trim();
+  if (!connectorName) {
+    logger3.warn("Skip connector entry without name from %s", source);
+    return;
+  }
+  if (typeof entry.creator !== "function") {
+    logger3.warn(
+      'Skip connector entry "%s" from %s: creator must be a function',
+      connectorName,
+      source
+    );
+    return;
+  }
+  const existingByName = findConnectorNameInsensitive(
+    connectorName,
+    state.connectorCreators
+  );
+  if (existingByName) {
+    logger3.warn(
+      'Skip duplicate connector "%s" from %s: already registered as %s',
+      connectorName,
+      source,
+      existingByName
+    );
+    return;
+  }
+  state.connectorCreators.set(
+    connectorName,
+    bindConnectorRuntime(entry.creator)
+  );
+  const providers = normalizeProviders(entry.providers, connectorName);
+  for (const provider of providers) {
+    registerProvider(
+      provider,
+      connectorName,
+      source,
+      state.providerToConnectorName
+    );
+  }
+};
+var registerEntries = (entries, source, state) => {
+  for (const entry of entries) {
+    registerEntry(entry, source, state);
+  }
+};
+var extractConnectorPluginDefinition = (moduleExport) => {
+  if (!moduleExport || typeof moduleExport !== "object") {
+    return null;
+  }
+  const candidate = moduleExport;
+  if (Array.isArray(candidate.connectorEntries)) {
+    return {
+      connectorEntries: candidate.connectorEntries
+    };
+  }
+  const defaultExport = candidate.default;
+  if (defaultExport && Array.isArray(defaultExport.connectorEntries)) {
+    return {
+      connectorEntries: defaultExport.connectorEntries
+    };
+  }
+  return null;
+};
+var importConnectorPluginModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
+  if (typeof importTradejsModule === "function") {
+    return importTradejsModule(moduleName, cwd);
+  }
+  return import(
+    /* webpackIgnore: true */
+    moduleName
+  );
+};
+var ensureConnectorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
+  const { projectRoot, state } = getConnectorRegistryState(cwd);
+  if (!state.pluginsLoadPromise) {
+    state.pluginsLoadPromise = (async () => {
+      const config = await loadTradejsConfig(projectRoot);
+      const connectorModules = toUniqueModules(config.connectors);
+      if (!connectorModules.length) {
+        return;
+      }
+      for (const moduleName of connectorModules) {
+        try {
+          const resolvedModuleName = resolvePluginModuleSpecifier(
+            moduleName,
+            projectRoot
+          );
+          const moduleExport = await importConnectorPluginModule(
+            resolvedModuleName,
+            projectRoot
+          );
+          const pluginDefinition = extractConnectorPluginDefinition(moduleExport);
+          if (!pluginDefinition) {
+            logger3.warn(
+              'Skip connector plugin "%s": export { connectorEntries } is missing',
+              moduleName
+            );
+            continue;
+          }
+          registerEntries(pluginDefinition.connectorEntries, moduleName, state);
+        } catch (error) {
+          logger3.warn(
+            'Failed to load connector plugin "%s": %s',
+            moduleName,
+            String(error)
+          );
+        }
+      }
+    })();
+  }
+  await state.pluginsLoadPromise;
+};
+var getConnectorCreatorByName = async (connectorName, cwd = getTradejsProjectCwd()) => {
+  await ensureConnectorPluginsLoaded(cwd);
+  const { state } = getConnectorRegistryState(cwd);
+  const raw = String(connectorName ?? "").trim();
+  if (!raw) {
+    return void 0;
+  }
+  const direct = state.connectorCreators.get(raw);
+  if (direct) {
+    return direct;
+  }
+  const existing = findConnectorNameInsensitive(raw, state.connectorCreators);
+  if (!existing) {
+    return void 0;
+  }
+  return state.connectorCreators.get(existing);
+};
+var getConnectorNameByProvider = async (provider, cwd = getTradejsProjectCwd()) => {
+  await ensureConnectorPluginsLoaded(cwd);
+  const { state } = getConnectorRegistryState(cwd);
+  const normalized = normalizeProvider(provider);
+  if (!normalized) {
+    return void 0;
+  }
+  return state.providerToConnectorName.get(normalized);
+};
+var getConnectorCreatorByProvider = async (provider, cwd = getTradejsProjectCwd()) => {
+  await ensureConnectorPluginsLoaded(cwd);
+  const { state } = getConnectorRegistryState(cwd);
+  const normalized = normalizeProvider(provider);
+  if (!normalized) {
+    return void 0;
+  }
+  const connectorName = state.providerToConnectorName.get(normalized);
+  if (!connectorName) {
+    return void 0;
+  }
+  return state.connectorCreators.get(connectorName);
+};
+var resolveConnectorName = async (providerOrName, cwd = getTradejsProjectCwd()) => {
+  await ensureConnectorPluginsLoaded(cwd);
+  const { state } = getConnectorRegistryState(cwd);
+  const raw = String(providerOrName ?? "").trim();
+  if (!raw) {
+    return void 0;
+  }
+  const byProvider = state.providerToConnectorName.get(normalizeProvider(raw));
+  if (byProvider) {
+    return byProvider;
+  }
+  return state.connectorCreators.get(raw) && raw ? raw : findConnectorNameInsensitive(raw, state.connectorCreators) ?? void 0;
+};
+var getAvailableConnectorNames = async (cwd = getTradejsProjectCwd()) => {
+  await ensureConnectorPluginsLoaded(cwd);
+  const { state } = getConnectorRegistryState(cwd);
+  return [...state.connectorCreators.keys()].sort((a, b) => a.localeCompare(b));
+};
+var getAvailableConnectorProviders = async (cwd = getTradejsProjectCwd()) => {
+  await ensureConnectorPluginsLoaded(cwd);
+  const { state } = getConnectorRegistryState(cwd);
+  return [...state.providerToConnectorName.keys()].sort(
+    (a, b) => a.localeCompare(b)
+  );
+};
+var registerConnectorEntries = (entries, cwd = getTradejsProjectCwd()) => {
+  const { state } = getConnectorRegistryState(cwd);
+  registerEntries(entries, "runtime", state);
+};
+var resetConnectorRegistryCache = (cwd) => {
+  const normalizedCwd = String(cwd ?? "").trim();
+  if (!normalizedCwd) {
+    registryStateByProjectRoot.clear();
+    return;
+  }
+  registryStateByProjectRoot.delete(getTradejsProjectCwd(normalizedCwd));
+};
+var DEFAULT_CONNECTOR_NAME = BUILTIN_CONNECTOR_NAMES.ByBit;
+
+export {
+  connectorRuntime,
+  bindConnectorRuntime,
+  BUILTIN_CONNECTOR_NAMES,
+  ensureConnectorPluginsLoaded,
+  getConnectorCreatorByName,
+  getConnectorNameByProvider,
+  getConnectorCreatorByProvider,
+  resolveConnectorName,
+  getAvailableConnectorNames,
+  getAvailableConnectorProviders,
+  registerConnectorEntries,
+  resetConnectorRegistryCache,
+  DEFAULT_CONNECTOR_NAME
+};