@tradejs/node 1.0.2 → 1.0.4

package/dist/backtest.mjs

@@ -1,17 +1,19 @@
 import {
   BUILTIN_CONNECTOR_NAMES,
   getConnectorCreatorByName
-} from "./chunk-E2QNOA5M.mjs";
+} from "./chunk-CIY64D57.mjs";
 import {
   buildMlPayload
-} from "./chunk-PXJJPAQT.mjs";
+} from "./chunk-RBE4PZER.mjs";
 import {
   require_lodash
 } from "./chunk-GKDBAF3A.mjs";
 import {
   getStrategyCreator
-} from "./chunk-MHCXPD2B.mjs";
-import "./chunk-DE7ADBIR.mjs";
+} from "./chunk-ZY6ULOWK.mjs";
+import {
+  getTradejsProjectCwd
+} from "./chunk-P2ZUWONT.mjs";
 import {
   __toESM
 } from "./chunk-6DZX6EAA.mjs";
@@ -231,10 +233,25 @@ var createTestConnector = (connector, context) => {
 
 // src/testing.ts
 var preloadStart = getTimestamp(PRELOAD_DAYS);
-var coinKlineCache = /* @__PURE__ */ new Map();
-var btcKlineCache = /* @__PURE__ */ new Map();
-var btcBinanceKlineCache = /* @__PURE__ */ new Map();
-var btcCoinbaseKlineCache = /* @__PURE__ */ new Map();
+var createTestingKlineCacheState = () => ({
+  coinKlineCache: /* @__PURE__ */ new Map(),
+  btcKlineCache: /* @__PURE__ */ new Map(),
+  btcBinanceKlineCache: /* @__PURE__ */ new Map(),
+  btcCoinbaseKlineCache: /* @__PURE__ */ new Map()
+});
+var testingKlineCacheStateByProjectRoot = /* @__PURE__ */ new Map();
+var getTestingKlineCacheState = (cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  let state = testingKlineCacheStateByProjectRoot.get(projectRoot);
+  if (!state) {
+    state = createTestingKlineCacheState();
+    testingKlineCacheStateByProjectRoot.set(projectRoot, state);
+  }
+  return {
+    projectRoot,
+    state
+  };
+};
 var getKlineCacheKey = (params) => {
   const { userName, connectorName, symbol, end, interval, cacheOnly } = params;
   return [
@@ -247,11 +264,15 @@ var getKlineCacheKey = (params) => {
     cacheOnly ? 1 : 0
   ].join(":");
 };
-var resetTestingKlineCache = () => {
-  coinKlineCache.clear();
-  btcKlineCache.clear();
-  btcBinanceKlineCache.clear();
-  btcCoinbaseKlineCache.clear();
+var resetTestingKlineCache = (cwd) => {
+  const normalizedCwd = String(cwd ?? "").trim();
+  if (!normalizedCwd) {
+    testingKlineCacheStateByProjectRoot.clear();
+    return;
+  }
+  testingKlineCacheStateByProjectRoot.delete(
+    getTradejsProjectCwd(normalizedCwd)
+  );
 };
 var testing = async ({
   userName,
@@ -269,22 +290,28 @@ var testing = async ({
   if (!start) {
     throw new Error("no start");
   }
-  const connectorCreator = await getConnectorCreatorByName(connectorName);
+  const { projectRoot, state } = getTestingKlineCacheState();
+  const connectorCreator = await getConnectorCreatorByName(
+    connectorName,
+    projectRoot
+  );
   if (!connectorCreator) {
     throw new Error(`Unknown connector: ${connectorName}`);
   }
   const connector = await connectorCreator({
     userName
   });
-  const strategyCreator = await getStrategyCreator(strategyName);
+  const strategyCreator = await getStrategyCreator(strategyName, projectRoot);
   if (!strategyCreator) {
     throw new Error(`Unknown strategy: ${strategyName}`);
   }
   const binanceCreator = await getConnectorCreatorByName(
-    BUILTIN_CONNECTOR_NAMES.Binance
+    BUILTIN_CONNECTOR_NAMES.Binance,
+    projectRoot
   );
   const coinbaseCreator = await getConnectorCreatorByName(
-    BUILTIN_CONNECTOR_NAMES.Coinbase
+    BUILTIN_CONNECTOR_NAMES.Coinbase,
+    projectRoot
   );
   if (!binanceCreator || !coinbaseCreator) {
     logger.warn(
@@ -310,8 +337,8 @@ var testing = async ({
     interval,
     cacheOnly
   });
-  const cachedCoinData = coinKlineCache.get(coinCacheKey);
-  const cachedBtcData = btcKlineCache.get(btcCacheKey);
+  const cachedCoinData = state.coinKlineCache.get(coinCacheKey);
+  const cachedBtcData = state.btcKlineCache.get(btcCacheKey);
   const btcBinanceCacheKey = getKlineCacheKey({
     userName,
     connectorName: binanceCreator ? BUILTIN_CONNECTOR_NAMES.Binance : connectorName,
@@ -328,8 +355,8 @@ var testing = async ({
     interval,
     cacheOnly
   });
-  const cachedBtcBinanceData = btcBinanceKlineCache.get(btcBinanceCacheKey);
-  const cachedBtcCoinbaseData = btcCoinbaseKlineCache.get(btcCoinbaseCacheKey);
+  const cachedBtcBinanceData = state.btcBinanceKlineCache.get(btcBinanceCacheKey);
+  const cachedBtcCoinbaseData = state.btcCoinbaseKlineCache.get(btcCoinbaseCacheKey);
   const [data, btcData, btcBinanceData, btcCoinbaseData] = await Promise.all([
     cachedCoinData ? Promise.resolve(cachedCoinData) : connector.kline({
       symbol,
@@ -383,16 +410,16 @@ var testing = async ({
     })
   ]);
   if (!cachedCoinData) {
-    coinKlineCache.set(coinCacheKey, data);
+    state.coinKlineCache.set(coinCacheKey, data);
   }
   if (!cachedBtcData) {
-    btcKlineCache.set(btcCacheKey, btcData);
+    state.btcKlineCache.set(btcCacheKey, btcData);
   }
   if (!cachedBtcBinanceData) {
-    btcBinanceKlineCache.set(btcBinanceCacheKey, btcBinanceData);
+    state.btcBinanceKlineCache.set(btcBinanceCacheKey, btcBinanceData);
   }
   if (!cachedBtcCoinbaseData) {
-    btcCoinbaseKlineCache.set(btcCoinbaseCacheKey, btcCoinbaseData);
+    state.btcCoinbaseKlineCache.set(btcCoinbaseCacheKey, btcCoinbaseData);
   }
   const prevDataRaw = data.filter(
     (candle) => candle.timestamp >= preloadStart && candle.timestamp < start

package/dist/{chunk-OB4CSYDJ.mjs → chunk-7ICOZAKA.mjs}

@@ -5,8 +5,6 @@ import {
 // src/pine.ts
 import fs from "fs";
 import path from "path";
-
-// src/pineShared.ts
 var getPinePlotSeries = (context, plotName) => {
   const name = String(plotName || "").trim();
   if (!name) return [];
@@ -29,8 +27,6 @@ var asPineBoolean = (value) => {
   if (typeof value === "number") return Number.isFinite(value) && value !== 0;
   return false;
 };
-
-// src/pine.ts
 var loadPinets = () => {
   const resolvedPath = __require.resolve("pinets");
   const cjsPath = resolvedPath.includes("pinets.min.browser") ? resolvedPath.replace(/pinets\.min\.browser(\.es)?\.js$/, "pinets.min.cjs") : resolvedPath;

package/dist/chunk-CIY64D57.mjs

@@ -0,0 +1,271 @@
+import {
+  getTradejsProjectCwd,
+  importTradejsModule,
+  loadTradejsConfig,
+  resolvePluginModuleSpecifier
+} from "./chunk-P2ZUWONT.mjs";
+
+// src/connectorsRegistry.ts
+import { logger } 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) {
+    logger.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) {
+    logger.warn("Skip connector entry without name from %s", source);
+    return;
+  }
+  if (typeof entry.creator !== "function") {
+    logger.warn(
+      'Skip connector entry "%s" from %s: creator must be a function',
+      connectorName,
+      source
+    );
+    return;
+  }
+  const existingByName = findConnectorNameInsensitive(
+    connectorName,
+    state.connectorCreators
+  );
+  if (existingByName) {
+    logger.warn(
+      'Skip duplicate connector "%s" from %s: already registered as %s',
+      connectorName,
+      source,
+      existingByName
+    );
+    return;
+  }
+  state.connectorCreators.set(connectorName, 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) {
+            logger.warn(
+              'Skip connector plugin "%s": export { connectorEntries } is missing',
+              moduleName
+            );
+            continue;
+          }
+          registerEntries(pluginDefinition.connectorEntries, moduleName, state);
+        } catch (error) {
+          logger.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 {
+  BUILTIN_CONNECTOR_NAMES,
+  ensureConnectorPluginsLoaded,
+  getConnectorCreatorByName,
+  getConnectorNameByProvider,
+  getConnectorCreatorByProvider,
+  resolveConnectorName,
+  getAvailableConnectorNames,
+  getAvailableConnectorProviders,
+  registerConnectorEntries,
+  resetConnectorRegistryCache,
+  DEFAULT_CONNECTOR_NAME
+};

package/dist/{chunk-ZIMX3JX2.mjs → chunk-LMAKIC3C.mjs}

@@ -1,6 +1,6 @@
 import {
   getStrategyManifest
-} from "./chunk-MHCXPD2B.mjs";
+} from "./chunk-ZY6ULOWK.mjs";
 
 // src/ai.ts
 import { setData, redisKeys } from "@tradejs/infra/redis";

package/dist/{chunk-DE7ADBIR.mjs → chunk-P2ZUWONT.mjs}

@@ -15,6 +15,7 @@ var TS_MODULE_RE = /\.(cts|mts|ts)$/i;
 var cachedByCwd = /* @__PURE__ */ new Map();
 var announcedConfigFile = /* @__PURE__ */ new Set();
 var tsNodeRegistered = false;
+var tsconfigPathsRegisteredByCwd = /* @__PURE__ */ new Set();
 var getTradejsProjectCwd = (cwd) => {
   const explicit = String(cwd ?? "").trim();
   if (explicit) {
@@ -56,6 +57,28 @@ var ensureTsNodeRegistered = async () => {
   });
   tsNodeRegistered = true;
 };
+var ensureTsconfigPathsRegistered = async (cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  if (tsconfigPathsRegisteredByCwd.has(projectRoot)) {
+    return;
+  }
+  const tsconfigPathsModule = await import("tsconfig-paths");
+  const loadConfig = tsconfigPathsModule.loadConfig;
+  const register = tsconfigPathsModule.register;
+  if (typeof loadConfig !== "function" || typeof register !== "function") {
+    return;
+  }
+  const loadedConfig = loadConfig(projectRoot);
+  if (loadedConfig.resultType !== "success") {
+    return;
+  }
+  register({
+    baseUrl: loadedConfig.absoluteBaseUrl,
+    paths: loadedConfig.paths,
+    addMatchAll: false
+  });
+  tsconfigPathsRegisteredByCwd.add(projectRoot);
+};
 var toImportSpecifier = (moduleName) => {
   if (moduleName.startsWith("file://")) {
     return moduleName;
@@ -83,6 +106,7 @@ var importConfigFile = async (configFilePath) => {
   if (ext === ".ts" || ext === ".mts") {
     const requireFn = getRequireFn(path.dirname(configFilePath));
     await ensureTsNodeRegistered();
+    await ensureTsconfigPathsRegistered(path.dirname(configFilePath));
     return requireFn(configFilePath);
   }
   return import(
@@ -90,7 +114,7 @@ var importConfigFile = async (configFilePath) => {
     configFileUrl
   );
 };
-var importTradejsModule = async (moduleName) => {
+var importTradejsModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
   const normalized = String(moduleName ?? "").trim();
   if (!normalized) {
     return {};
@@ -104,13 +128,15 @@ var importTradejsModule = async (moduleName) => {
     }
   }
   const requireFn = getRequireFn(
-    path.isAbsolute(modulePath) ? path.dirname(modulePath) : getTradejsProjectCwd()
+    path.isAbsolute(modulePath) ? path.dirname(modulePath) : cwd
   );
   if (isTsModulePath(modulePath)) {
     await ensureTsNodeRegistered();
+    await ensureTsconfigPathsRegistered(cwd);
     return requireFn(modulePath);
   }
   if (isBareModuleSpecifier(normalized)) {
+    await ensureTsconfigPathsRegistered(cwd);
     return requireFn(normalized);
   }
   try {
@@ -121,6 +147,7 @@ var importTradejsModule = async (moduleName) => {
   } catch (error) {
     if (isTsModulePath(modulePath)) {
       await ensureTsNodeRegistered();
+      await ensureTsconfigPathsRegistered(cwd);
       return requireFn(modulePath);
     }
     throw error;
@@ -198,6 +225,7 @@ var loadTradejsConfig = async (cwd = getTradejsProjectCwd()) => {
 };
 
 export {
+  getTradejsProjectCwd,
   importTradejsModule,
   resolvePluginModuleSpecifier,
   loadTradejsConfig

package/dist/{chunk-PXJJPAQT.mjs → chunk-RBE4PZER.mjs}

@@ -1,6 +1,6 @@
 import {
   getStrategyManifest
-} from "./chunk-MHCXPD2B.mjs";
+} from "./chunk-ZY6ULOWK.mjs";
 
 // src/strategyAdapters/ml.ts
 var defaultMlAdapter = {