@tradejs/node 3.0.0 → 3.1.0

package/dist/connectors.js

@@ -32,6 +32,8 @@ var connectors_exports = {};
 __export(connectors_exports, {
   BUILTIN_CONNECTOR_NAMES: () => BUILTIN_CONNECTOR_NAMES,
   DEFAULT_CONNECTOR_NAME: () => DEFAULT_CONNECTOR_NAME,
+  bindConnectorRuntime: () => bindConnectorRuntime,
+  connectorRuntime: () => connectorRuntime,
   ensureConnectorPluginsLoaded: () => ensureConnectorPluginsLoaded,
   getAvailableConnectorNames: () => getAvailableConnectorNames,
   getAvailableConnectorProviders: () => getAvailableConnectorProviders,
@@ -45,7 +47,7 @@ __export(connectors_exports, {
 module.exports = __toCommonJS(connectors_exports);
 
 // src/connectorsRegistry.ts
-var import_logger2 = require("@tradejs/infra/logger");
+var import_logger4 = require("@tradejs/infra/logger");
 
 // src/tradejsConfig.ts
 var import_fs = __toESM(require("fs"));
@@ -332,6 +334,320 @@ var loadTradejsConfig = async (cwd = getTradejsProjectCwd()) => {
   }
 };
 
+// src/connectorRuntime.ts
+var import_logger3 = require("@tradejs/infra/logger");
+var import_tradingAccounts = require("@tradejs/infra/tradingAccounts");
+
+// src/timescaleCachedKline.ts
+var import_constants = require("@tradejs/core/constants");
+var import_data = require("@tradejs/core/data");
+var import_time = require("@tradejs/core/time");
+var import_async = require("@tradejs/core/async");
+var import_logger2 = require("@tradejs/infra/logger");
+var import_candles = require("@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 (0, import_async.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" ? (0, import_data.mergeData)(partData, accumulated) : (0, import_data.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" ? (0, import_time.getItemTimestamp)(partData[0]) - intervalMs : (0, import_time.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) {
+      import_logger2.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(
+        () => (0, import_candles.upsertCandles)((0, import_candles.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) {
+      import_logger2.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(
+        () => (0, import_candles.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(
+          () => (0, import_candles.getCandlesRange)(provider, symbol, intMinutes, s, e)
+        );
+        return rowsToKline(dbData2);
+      }
+      const needOlderData = defaultStart !== void 0 && (dataStart === void 0 || normStart < dataStart);
+      const persistPartData = warmOnly ? (partData) => runTimescaleOperation(
+        () => (0, import_candles.upsertCandles)((0, import_candles.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(
+            () => (0, import_candles.upsertCandles)(
+              (0, import_candles.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 = (0, import_time.getTimestamp)(import_constants.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(
+            () => (0, import_candles.upsertCandles)(
+              (0, import_candles.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;
+          import_logger2.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(
+        () => (0, import_candles.getCandlesRange)(provider, symbol, intMinutes, finalStart, finalEnd)
+      );
+      if (isTimescaleFallbackMode) {
+        isTimescaleFallbackMode = false;
+        import_logger2.logger.log("info", "TimescaleDB connection restored for kline cache");
+      }
+      return rowsToKline(dbData);
+    } catch (error) {
+      if (!isTimescaleFallbackMode) {
+        isTimescaleFallbackMode = true;
+        import_logger2.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: import_logger3.logger,
+  resolveTradingAccount: import_tradingAccounts.resolveTradingAccount,
+  createCachedKline: createTimescaleCachedKline
+};
+var bindConnectorRuntime = (creator, runtime = connectorRuntime) => {
+  const boundCreator = (config) => creator(config, runtime);
+  return boundCreator;
+};
+
 // src/connectorsRegistry.ts
 var createConnectorRegistryState = () => ({
   connectorCreators: /* @__PURE__ */ new Map(),
@@ -384,7 +700,7 @@ var normalizeProviders = (providers, connectorName) => {
 var registerProvider = (provider, connectorName, source, providerToConnectorName) => {
   const existing = providerToConnectorName.get(provider);
   if (existing && existing !== connectorName) {
-    import_logger2.logger.warn(
+    import_logger4.logger.warn(
       'Skip duplicate connector provider "%s" from %s: already mapped to %s',
       provider,
       source,
@@ -397,11 +713,11 @@ var registerProvider = (provider, connectorName, source, providerToConnectorName
 var registerEntry = (entry, source, state) => {
   const connectorName = String(entry?.name ?? "").trim();
   if (!connectorName) {
-    import_logger2.logger.warn("Skip connector entry without name from %s", source);
+    import_logger4.logger.warn("Skip connector entry without name from %s", source);
     return;
   }
   if (typeof entry.creator !== "function") {
-    import_logger2.logger.warn(
+    import_logger4.logger.warn(
       'Skip connector entry "%s" from %s: creator must be a function',
       connectorName,
       source
@@ -413,7 +729,7 @@ var registerEntry = (entry, source, state) => {
     state.connectorCreators
   );
   if (existingByName) {
-    import_logger2.logger.warn(
+    import_logger4.logger.warn(
       'Skip duplicate connector "%s" from %s: already registered as %s',
       connectorName,
       source,
@@ -421,7 +737,10 @@ var registerEntry = (entry, source, state) => {
     );
     return;
   }
-  state.connectorCreators.set(connectorName, entry.creator);
+  state.connectorCreators.set(
+    connectorName,
+    bindConnectorRuntime(entry.creator)
+  );
   const providers = normalizeProviders(entry.providers, connectorName);
   for (const provider of providers) {
     registerProvider(
@@ -485,7 +804,7 @@ var ensureConnectorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
           );
           const pluginDefinition = extractConnectorPluginDefinition(moduleExport);
           if (!pluginDefinition) {
-            import_logger2.logger.warn(
+            import_logger4.logger.warn(
               'Skip connector plugin "%s": export { connectorEntries } is missing',
               moduleName
             );
@@ -493,7 +812,7 @@ var ensureConnectorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
           }
           registerEntries(pluginDefinition.connectorEntries, moduleName, state);
         } catch (error) {
-          import_logger2.logger.warn(
+          import_logger4.logger.warn(
             'Failed to load connector plugin "%s": %s',
             moduleName,
             String(error)
@@ -585,6 +904,8 @@ var DEFAULT_CONNECTOR_NAME = BUILTIN_CONNECTOR_NAMES.ByBit;
 0 && (module.exports = {
   BUILTIN_CONNECTOR_NAMES,
   DEFAULT_CONNECTOR_NAME,
+  bindConnectorRuntime,
+  connectorRuntime,
   ensureConnectorPluginsLoaded,
   getAvailableConnectorNames,
   getAvailableConnectorProviders,

package/dist/connectors.mjs

@@ -1,6 +1,8 @@
 import {
   BUILTIN_CONNECTOR_NAMES,
   DEFAULT_CONNECTOR_NAME,
+  bindConnectorRuntime,
+  connectorRuntime,
   ensureConnectorPluginsLoaded,
   getAvailableConnectorNames,
   getAvailableConnectorProviders,
@@ -10,12 +12,14 @@ import {
   registerConnectorEntries,
   resetConnectorRegistryCache,
   resolveConnectorName
-} from "./chunk-V3YMKE4I.mjs";
+} from "./chunk-3TWULKHV.mjs";
 import "./chunk-WS5DYEVZ.mjs";
 import "./chunk-Y6FXYEAI.mjs";
 export {
   BUILTIN_CONNECTOR_NAMES,
   DEFAULT_CONNECTOR_NAME,
+  bindConnectorRuntime,
+  connectorRuntime,
   ensureConnectorPluginsLoaded,
   getAvailableConnectorNames,
   getAvailableConnectorProviders,

package/dist/registry.d.mts

@@ -3,6 +3,7 @@ import { StrategyManifest, StrategyCreator, StrategyRegistryEntry } from '@trade
 declare const ensureStrategyPluginsLoaded: (cwd?: string) => Promise<void>;
 declare const ensureIndicatorPluginsLoaded: (cwd?: string) => Promise<void>;
 declare const getStrategyCreator: (name: string, cwd?: string) => Promise<StrategyCreator | undefined>;
+declare const getStrategyDefaults: (name: string, cwd?: string) => Promise<StrategyRegistryEntry["defaults"] | undefined>;
 declare const getAvailableStrategyNames: (cwd?: string) => Promise<string[]>;
 declare const getRegisteredStrategies: (cwd?: string) => Record<string, StrategyCreator>;
 declare const getRegisteredManifests: (cwd?: string) => StrategyManifest[];
@@ -12,4 +13,4 @@ declare const registerStrategyEntries: (entries: readonly StrategyRegistryEntry[
 declare const resetStrategyRegistryCache: (cwd?: string) => void;
 declare const strategies: Record<string, StrategyCreator>;
 
-export { ensureIndicatorPluginsLoaded, ensureStrategyPluginsLoaded, getAvailableStrategyNames, getRegisteredManifests, getRegisteredStrategies, getStrategyCreator, getStrategyManifest, isKnownStrategy, registerStrategyEntries, resetStrategyRegistryCache, strategies };
+export { ensureIndicatorPluginsLoaded, ensureStrategyPluginsLoaded, getAvailableStrategyNames, getRegisteredManifests, getRegisteredStrategies, getStrategyCreator, getStrategyDefaults, getStrategyManifest, isKnownStrategy, registerStrategyEntries, resetStrategyRegistryCache, strategies };

package/dist/registry.d.ts

@@ -3,6 +3,7 @@ import { StrategyManifest, StrategyCreator, StrategyRegistryEntry } from '@trade
 declare const ensureStrategyPluginsLoaded: (cwd?: string) => Promise<void>;
 declare const ensureIndicatorPluginsLoaded: (cwd?: string) => Promise<void>;
 declare const getStrategyCreator: (name: string, cwd?: string) => Promise<StrategyCreator | undefined>;
+declare const getStrategyDefaults: (name: string, cwd?: string) => Promise<StrategyRegistryEntry["defaults"] | undefined>;
 declare const getAvailableStrategyNames: (cwd?: string) => Promise<string[]>;
 declare const getRegisteredStrategies: (cwd?: string) => Record<string, StrategyCreator>;
 declare const getRegisteredManifests: (cwd?: string) => StrategyManifest[];
@@ -12,4 +13,4 @@ declare const registerStrategyEntries: (entries: readonly StrategyRegistryEntry[
 declare const resetStrategyRegistryCache: (cwd?: string) => void;
 declare const strategies: Record<string, StrategyCreator>;
 
-export { ensureIndicatorPluginsLoaded, ensureStrategyPluginsLoaded, getAvailableStrategyNames, getRegisteredManifests, getRegisteredStrategies, getStrategyCreator, getStrategyManifest, isKnownStrategy, registerStrategyEntries, resetStrategyRegistryCache, strategies };
+export { ensureIndicatorPluginsLoaded, ensureStrategyPluginsLoaded, getAvailableStrategyNames, getRegisteredManifests, getRegisteredStrategies, getStrategyCreator, getStrategyDefaults, getStrategyManifest, isKnownStrategy, registerStrategyEntries, resetStrategyRegistryCache, strategies };