@tradejs/node 1.0.0

package/dist/chunk-DE7ADBIR.mjs

@@ -0,0 +1,204 @@
+// src/tradejsConfig.ts
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+import { fileURLToPath, pathToFileURL } from "url";
+import { logger } from "@tradejs/infra/logger";
+var CONFIG_FILE_NAMES = [
+  "tradejs.config.ts",
+  "tradejs.config.mts",
+  "tradejs.config.js",
+  "tradejs.config.mjs",
+  "tradejs.config.cjs"
+];
+var TS_MODULE_RE = /\.(cts|mts|ts)$/i;
+var cachedByCwd = /* @__PURE__ */ new Map();
+var announcedConfigFile = /* @__PURE__ */ new Set();
+var tsNodeRegistered = false;
+var getTradejsProjectCwd = (cwd) => {
+  const explicit = String(cwd ?? "").trim();
+  if (explicit) {
+    return path.resolve(explicit);
+  }
+  const fromEnv = String(process.env.PROJECT_CWD || "").trim();
+  if (fromEnv) {
+    return path.resolve(fromEnv);
+  }
+  return process.cwd();
+};
+var normalizeConfig = (rawConfig) => {
+  if (!rawConfig || typeof rawConfig !== "object") {
+    return {};
+  }
+  const config = rawConfig;
+  const strategies = Array.isArray(config.strategies) ? config.strategies.map((value) => String(value || "").trim()).filter(Boolean) : [];
+  const indicators = Array.isArray(config.indicators) ? config.indicators.map((value) => String(value || "").trim()).filter(Boolean) : [];
+  const connectors = Array.isArray(config.connectors) ? config.connectors.map((value) => String(value || "").trim()).filter(Boolean) : [];
+  return {
+    strategies,
+    indicators,
+    connectors
+  };
+};
+var getRequireFn = (cwd = getTradejsProjectCwd()) => createRequire(path.join(path.resolve(cwd), "__tradejs_loader__.js"));
+var ensureTsNodeRegistered = async () => {
+  if (tsNodeRegistered) {
+    return;
+  }
+  const tsNodeModule = await import("ts-node");
+  const tsNode = tsNodeModule.default ?? tsNodeModule;
+  tsNode.register?.({
+    transpileOnly: true,
+    compilerOptions: {
+      module: "commonjs",
+      moduleResolution: "node"
+    }
+  });
+  tsNodeRegistered = true;
+};
+var toImportSpecifier = (moduleName) => {
+  if (moduleName.startsWith("file://")) {
+    return moduleName;
+  }
+  if (path.isAbsolute(moduleName)) {
+    return pathToFileURL(moduleName).href;
+  }
+  return moduleName;
+};
+var isTsModulePath = (moduleName) => TS_MODULE_RE.test(moduleName.split("?")[0]);
+var isRelativeModulePath = (moduleName) => moduleName.startsWith("./") || moduleName.startsWith("../");
+var isBareModuleSpecifier = (moduleName) => {
+  const normalized = String(moduleName ?? "").trim();
+  if (!normalized) {
+    return false;
+  }
+  if (normalized.startsWith("file://") || path.isAbsolute(normalized) || isRelativeModulePath(normalized)) {
+    return false;
+  }
+  return true;
+};
+var importConfigFile = async (configFilePath) => {
+  const ext = path.extname(configFilePath).toLowerCase();
+  const configFileUrl = `${toImportSpecifier(configFilePath)}?t=${Date.now()}`;
+  if (ext === ".ts" || ext === ".mts") {
+    const requireFn = getRequireFn(path.dirname(configFilePath));
+    await ensureTsNodeRegistered();
+    return requireFn(configFilePath);
+  }
+  return import(
+    /* webpackIgnore: true */
+    configFileUrl
+  );
+};
+var importTradejsModule = async (moduleName) => {
+  const normalized = String(moduleName ?? "").trim();
+  if (!normalized) {
+    return {};
+  }
+  let modulePath = normalized;
+  if (normalized.startsWith("file://")) {
+    try {
+      modulePath = fileURLToPath(normalized);
+    } catch {
+      modulePath = normalized;
+    }
+  }
+  const requireFn = getRequireFn(
+    path.isAbsolute(modulePath) ? path.dirname(modulePath) : getTradejsProjectCwd()
+  );
+  if (isTsModulePath(modulePath)) {
+    await ensureTsNodeRegistered();
+    return requireFn(modulePath);
+  }
+  if (isBareModuleSpecifier(normalized)) {
+    return requireFn(normalized);
+  }
+  try {
+    return await import(
+      /* webpackIgnore: true */
+      toImportSpecifier(normalized)
+    );
+  } catch (error) {
+    if (isTsModulePath(modulePath)) {
+      await ensureTsNodeRegistered();
+      return requireFn(modulePath);
+    }
+    throw error;
+  }
+};
+var resolveExportedConfig = (moduleExports) => {
+  const candidate = moduleExports && typeof moduleExports === "object" && "default" in moduleExports ? moduleExports.default : moduleExports;
+  return normalizeConfig(candidate);
+};
+var findConfigFilePath = (cwd) => {
+  let currentDir = path.resolve(cwd);
+  while (true) {
+    for (const fileName of CONFIG_FILE_NAMES) {
+      const fullPath = path.join(currentDir, fileName);
+      if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+        return fullPath;
+      }
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+};
+var resolvePluginModuleSpecifier = (moduleName, cwd = getTradejsProjectCwd()) => {
+  const normalized = String(moduleName ?? "").trim();
+  if (!normalized) {
+    return "";
+  }
+  if (normalized.startsWith("file://")) {
+    try {
+      return fileURLToPath(normalized);
+    } catch {
+      return normalized;
+    }
+  }
+  if (path.isAbsolute(normalized)) {
+    return normalized;
+  }
+  if (isRelativeModulePath(normalized)) {
+    return path.resolve(cwd, normalized);
+  }
+  return normalized;
+};
+var loadTradejsConfig = async (cwd = getTradejsProjectCwd()) => {
+  const cached = cachedByCwd.get(cwd);
+  if (cached) {
+    return cached;
+  }
+  const configFilePath = findConfigFilePath(cwd);
+  if (!configFilePath) {
+    cachedByCwd.set(cwd, {});
+    return {};
+  }
+  try {
+    const moduleExports = await importConfigFile(configFilePath);
+    const config = resolveExportedConfig(moduleExports);
+    cachedByCwd.set(cwd, config);
+    if (!announcedConfigFile.has(configFilePath)) {
+      announcedConfigFile.add(configFilePath);
+      logger.log("info", "Loaded TradeJS config: %s", configFilePath);
+    }
+    return config;
+  } catch (error) {
+    logger.log(
+      "warn",
+      "Failed to load TradeJS config from %s: %s",
+      configFilePath,
+      String(error)
+    );
+    cachedByCwd.set(cwd, {});
+    return {};
+  }
+};
+
+export {
+  importTradejsModule,
+  resolvePluginModuleSpecifier,
+  loadTradejsConfig
+};

package/dist/chunk-E2QNOA5M.mjs

@@ -0,0 +1,227 @@
+import {
+  importTradejsModule,
+  loadTradejsConfig,
+  resolvePluginModuleSpecifier
+} from "./chunk-DE7ADBIR.mjs";
+
+// src/connectorsRegistry.ts
+import { logger } from "@tradejs/infra/logger";
+var connectorCreators = /* @__PURE__ */ new Map();
+var providerToConnectorName = /* @__PURE__ */ new Map();
+var pluginsLoadPromise = null;
+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) => {
+  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) => {
+  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) => {
+  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);
+  if (existingByName) {
+    logger.warn(
+      'Skip duplicate connector "%s" from %s: already registered as %s',
+      connectorName,
+      source,
+      existingByName
+    );
+    return;
+  }
+  connectorCreators.set(connectorName, entry.creator);
+  const providers = normalizeProviders(entry.providers, connectorName);
+  for (const provider of providers) {
+    registerProvider(provider, connectorName, source);
+  }
+};
+var registerEntries = (entries, source) => {
+  for (const entry of entries) {
+    registerEntry(entry, source);
+  }
+};
+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) => {
+  if (typeof importTradejsModule === "function") {
+    return importTradejsModule(moduleName);
+  }
+  return import(
+    /* webpackIgnore: true */
+    moduleName
+  );
+};
+var ensureConnectorPluginsLoaded = async () => {
+  if (pluginsLoadPromise) {
+    return pluginsLoadPromise;
+  }
+  pluginsLoadPromise = (async () => {
+    const config = await loadTradejsConfig();
+    const connectorModules = toUniqueModules(config.connectors);
+    if (!connectorModules.length) {
+      return;
+    }
+    for (const moduleName of connectorModules) {
+      try {
+        const resolvedModuleName = resolvePluginModuleSpecifier(moduleName);
+        const moduleExport = await importConnectorPluginModule(resolvedModuleName);
+        const pluginDefinition = extractConnectorPluginDefinition(moduleExport);
+        if (!pluginDefinition) {
+          logger.warn(
+            'Skip connector plugin "%s": export { connectorEntries } is missing',
+            moduleName
+          );
+          continue;
+        }
+        registerEntries(pluginDefinition.connectorEntries, moduleName);
+      } catch (error) {
+        logger.warn(
+          'Failed to load connector plugin "%s": %s',
+          moduleName,
+          String(error)
+        );
+      }
+    }
+  })();
+  return pluginsLoadPromise;
+};
+var getConnectorCreatorByName = async (connectorName) => {
+  await ensureConnectorPluginsLoaded();
+  const raw = String(connectorName ?? "").trim();
+  if (!raw) {
+    return void 0;
+  }
+  const direct = connectorCreators.get(raw);
+  if (direct) {
+    return direct;
+  }
+  const existing = findConnectorNameInsensitive(raw);
+  if (!existing) {
+    return void 0;
+  }
+  return connectorCreators.get(existing);
+};
+var getConnectorNameByProvider = async (provider) => {
+  await ensureConnectorPluginsLoaded();
+  const normalized = normalizeProvider(provider);
+  if (!normalized) {
+    return void 0;
+  }
+  return providerToConnectorName.get(normalized);
+};
+var getConnectorCreatorByProvider = async (provider) => {
+  const connectorName = await getConnectorNameByProvider(provider);
+  if (!connectorName) {
+    return void 0;
+  }
+  return connectorCreators.get(connectorName);
+};
+var resolveConnectorName = async (providerOrName) => {
+  const raw = String(providerOrName ?? "").trim();
+  if (!raw) {
+    return void 0;
+  }
+  const byProvider = await getConnectorNameByProvider(raw);
+  if (byProvider) {
+    return byProvider;
+  }
+  const byName = await getConnectorCreatorByName(raw);
+  if (!byName) {
+    return void 0;
+  }
+  return findConnectorNameInsensitive(raw) ?? void 0;
+};
+var getAvailableConnectorNames = async () => {
+  await ensureConnectorPluginsLoaded();
+  return [...connectorCreators.keys()].sort((a, b) => a.localeCompare(b));
+};
+var getAvailableConnectorProviders = async () => {
+  await ensureConnectorPluginsLoaded();
+  return [...providerToConnectorName.keys()].sort((a, b) => a.localeCompare(b));
+};
+var registerConnectorEntries = (entries) => {
+  registerEntries(entries, "runtime");
+};
+var resetConnectorRegistryCache = () => {
+  connectorCreators.clear();
+  providerToConnectorName.clear();
+  pluginsLoadPromise = null;
+};
+var DEFAULT_CONNECTOR_NAME = BUILTIN_CONNECTOR_NAMES.ByBit;
+
+export {
+  BUILTIN_CONNECTOR_NAMES,
+  ensureConnectorPluginsLoaded,
+  getConnectorCreatorByName,
+  getConnectorNameByProvider,
+  getConnectorCreatorByProvider,
+  resolveConnectorName,
+  getAvailableConnectorNames,
+  getAvailableConnectorProviders,
+  registerConnectorEntries,
+  resetConnectorRegistryCache,
+  DEFAULT_CONNECTOR_NAME
+};