@tradejs/node 3.1.11 → 3.1.12-beta.218

package/dist/chunk-7BAL7EN3.mjs

@@ -1,345 +0,0 @@
-import {
-  getStrategyCreator,
-  getStrategyPluginSource
-} from "./chunk-C3KRBNUR.mjs";
-import {
-  loadTradejsConfig
-} from "./chunk-LZDXRXIU.mjs";
-
-// src/runtimeStrategies.ts
-import { readFile } from "fs/promises";
-import path from "path";
-import { getRuntimeControls } from "@tradejs/infra/runtimeControls";
-import { resolveTradingAccount } from "@tradejs/infra/tradingAccounts";
-var INTERVALS = /* @__PURE__ */ new Set([
-  "1",
-  "3",
-  "5",
-  "15",
-  "30",
-  "60",
-  "120",
-  "240",
-  "360",
-  "720",
-  "D",
-  "W",
-  "M"
-]);
-var RUNTIME_KEYS = /* @__PURE__ */ new Set(["deployments"]);
-var DEPLOYMENT_KEYS = /* @__PURE__ */ new Set([
-  "label",
-  "connectorName",
-  "provider",
-  "accountId",
-  "enabled",
-  "strategies",
-  "assetClasses",
-  "tickers"
-]);
-var STRATEGY_KEYS = /* @__PURE__ */ new Set(["version", "enabled", "selection", "config"]);
-var SELECTION_KEYS = /* @__PURE__ */ new Set(["tickers"]);
-var FORBIDDEN_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  "ACCOUNT_ID",
-  "DEPLOYMENT_ID",
-  "CONNECTOR_NAME",
-  "ENABLE"
-]);
-var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
-var readPackageManifest = async (projectRoot) => {
-  const candidates = [
-    process.env.TRADEJS_RUNTIME_PACKAGE_MANIFEST,
-    path.join(projectRoot, "runtime-package-manifest.json"),
-    "/app/runtime-package-manifest.json"
-  ].filter((candidate) => Boolean(candidate));
-  for (const candidate of candidates) {
-    try {
-      return JSON.parse(
-        await readFile(candidate, "utf8")
-      );
-    } catch {
-    }
-  }
-  return { packages: {} };
-};
-var resolveInstalledPackageVersion = async (projectRoot, packageName, manifest) => {
-  if (!packageName || packageName === "runtime") return null;
-  const manifestVersion = manifest.packages?.[packageName];
-  if (manifestVersion) return manifestVersion;
-  try {
-    const packageJsonPath = path.join(
-      projectRoot,
-      "node_modules",
-      ...packageName.split("/"),
-      "package.json"
-    );
-    const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
-    return packageJson.version ?? null;
-  } catch {
-    return null;
-  }
-};
-var resolveStrategyPackageName = async ({
-  pluginSource,
-  projectRoot
-}) => {
-  if (!pluginSource) return null;
-  if (!pluginSource.startsWith(".") && !path.isAbsolute(pluginSource)) {
-    return pluginSource;
-  }
-  try {
-    const packageJson = JSON.parse(
-      await readFile(path.join(projectRoot, "package.json"), "utf8")
-    );
-    return typeof packageJson.name === "string" && packageJson.name.trim() ? packageJson.name : null;
-  } catch {
-    return null;
-  }
-};
-var verifyStringArray = (value) => value === void 0 || Array.isArray(value) && value.every((item) => typeof item === "string");
-var verifyStrategySelection = (value) => value === void 0 || isRecord(value) && Object.keys(value).length === 1 && Object.keys(value).every((key) => SELECTION_KEYS.has(key)) && Array.isArray(value.tickers) && value.tickers.length > 0 && value.tickers.every(
-  (ticker) => typeof ticker === "string" && ticker.trim().length > 0
-);
-var cloneSelection = (selection) => selection ? { tickers: [...selection.tickers] } : void 0;
-var resolveStrategySelection = ({
-  deployment,
-  strategy
-}) => cloneSelection(
-  strategy.selection ?? (deployment.tickers ? { tickers: deployment.tickers } : void 0)
-);
-var verifyDeploymentDeclaration = (deploymentId, value) => {
-  if (!deploymentId.trim() || !isRecord(value) || Object.keys(value).some((key) => !DEPLOYMENT_KEYS.has(key)) || typeof value.connectorName !== "string" || !value.connectorName.trim() || typeof value.accountId !== "string" || !value.accountId.trim() || value.label !== void 0 && typeof value.label !== "string" || value.provider !== void 0 && typeof value.provider !== "string" || value.enabled !== void 0 && typeof value.enabled !== "boolean" || !verifyStringArray(value.assetClasses) || !verifyStringArray(value.tickers) || !isRecord(value.strategies) || !Object.keys(value.strategies).length) {
-    throw new Error(`Invalid runtime deployment declaration: ${deploymentId}`);
-  }
-  for (const [strategyName, strategyValue] of Object.entries(
-    value.strategies
-  )) {
-    if (!strategyName.trim() || !isRecord(strategyValue) || Object.keys(strategyValue).some((key) => !STRATEGY_KEYS.has(key)) || !Number.isSafeInteger(strategyValue.version) || Number(strategyValue.version) <= 0 || typeof strategyValue.enabled !== "boolean" || !verifyStrategySelection(strategyValue.selection) || !isRecord(strategyValue.config) || Object.keys(strategyValue.config).some(
-      (key) => FORBIDDEN_CONFIG_KEYS.has(key)
-    ) || !INTERVALS.has(String(strategyValue.config.INTERVAL)) || !["crypto", "tradfi"].includes(String(strategyValue.config.UNIVERSE))) {
-      throw new Error(
-        `Invalid runtime strategy declaration: ${deploymentId}/${strategyName}`
-      );
-    }
-  }
-  return value;
-};
-var verifyRuntimeDeclaration = (value) => {
-  if (!isRecord(value) || Object.keys(value).some((key) => !RUNTIME_KEYS.has(key)) || !isRecord(value.deployments) || !Object.keys(value.deployments).length) {
-    throw new Error("Invalid runtime declaration");
-  }
-  for (const [deploymentId, deployment] of Object.entries(value.deployments)) {
-    verifyDeploymentDeclaration(deploymentId, deployment);
-  }
-  return value;
-};
-var toRuntimeDeployment = ({
-  id,
-  declaration,
-  controls
-}) => {
-  const deploymentEnabled = declaration.enabled ?? true;
-  return {
-    id,
-    label: declaration.label?.trim() || id,
-    connectorName: declaration.connectorName.trim(),
-    provider: (declaration.provider || declaration.connectorName).trim().toLowerCase(),
-    accountId: declaration.accountId.trim(),
-    enabled: deploymentEnabled,
-    strategies: Object.entries(declaration.strategies).map(
-      ([strategyName, strategy]) => {
-        const selection = resolveStrategySelection({
-          deployment: declaration,
-          strategy
-        });
-        return {
-          strategyName,
-          version: strategy.version,
-          enabled: strategy.enabled,
-          controlState: deploymentEnabled && strategy.enabled && !controls.deployments[id]?.[strategyName]?.entriesPaused ? "active" : "entries_paused",
-          ...selection ? { selection } : {}
-        };
-      }
-    ),
-    ...declaration.assetClasses ? { assetClasses: declaration.assetClasses } : {},
-    ...declaration.tickers ? { tickers: declaration.tickers } : {}
-  };
-};
-var loadRuntimeDeclaration = async (projectRoot) => {
-  const projectConfig = await loadTradejsConfig(projectRoot);
-  if (!projectConfig.runtime) {
-    throw new Error("Runtime declaration is required in tradejs.config.ts");
-  }
-  return verifyRuntimeDeclaration(projectConfig.runtime);
-};
-var listRuntimeDeployments = async ({
-  userName,
-  projectRoot
-}) => {
-  const [runtime, controls] = await Promise.all([
-    loadRuntimeDeclaration(projectRoot),
-    getRuntimeControls(userName)
-  ]);
-  return Object.entries(runtime.deployments).map(
-    ([id, declaration]) => toRuntimeDeployment({ id, declaration, controls })
-  ).sort((left, right) => left.label.localeCompare(right.label));
-};
-var getRuntimeDeployment = async ({
-  userName,
-  projectRoot,
-  deploymentId
-}) => {
-  const deployments = await listRuntimeDeployments({ userName, projectRoot });
-  return deployments.find((deployment) => deployment.id === deploymentId) ?? null;
-};
-var resolveAccountId = async ({
-  userName,
-  deployment,
-  universe
-}) => {
-  const account = await resolveTradingAccount({
-    userName,
-    accountId: deployment.accountId,
-    provider: deployment.provider,
-    universe
-  });
-  if (!account) {
-    throw new Error(`Trading account not found: ${deployment.accountId}`);
-  }
-  return account.id;
-};
-var loadResolvedRuntimeStrategies = async ({
-  userName,
-  projectRoot,
-  deploymentId,
-  universe,
-  accountId,
-  interval
-}) => {
-  const [runtime, controls, packageManifest] = await Promise.all([
-    loadRuntimeDeclaration(projectRoot),
-    getRuntimeControls(userName),
-    readPackageManifest(projectRoot)
-  ]);
-  const declaration = runtime.deployments[deploymentId];
-  if (!declaration) {
-    throw new Error(`Runtime deployment not found: ${deploymentId}`);
-  }
-  const deployment = toRuntimeDeployment({
-    id: deploymentId,
-    declaration,
-    controls
-  });
-  const strategies = await Promise.all(
-    Object.entries(declaration.strategies).map(
-      async ([strategyName, strategyDeclaration]) => {
-        const strategyCreator = await getStrategyCreator(
-          strategyName,
-          projectRoot
-        );
-        if (!strategyCreator) {
-          throw new Error(`Unknown strategy: ${strategyName}`);
-        }
-        const pluginSource = await getStrategyPluginSource(strategyName, projectRoot) ?? null;
-        const strategyPackage = await resolveStrategyPackageName({
-          pluginSource,
-          projectRoot
-        });
-        const [strategyPackageVersion, runtimePackageVersion] = await Promise.all([
-          resolveInstalledPackageVersion(
-            projectRoot,
-            strategyPackage,
-            packageManifest
-          ),
-          resolveInstalledPackageVersion(
-            projectRoot,
-            "@tradejs/node",
-            packageManifest
-          )
-        ]);
-        if (!strategyPackage || !strategyPackageVersion) {
-          throw new Error(
-            `Installed strategy package not found: ${strategyName}`
-          );
-        }
-        if (!runtimePackageVersion) {
-          throw new Error("Installed @tradejs/node package version not found");
-        }
-        const strategyView = deployment.strategies.find(
-          (candidate) => candidate.strategyName === strategyName
-        );
-        const selection = resolveStrategySelection({
-          deployment: declaration,
-          strategy: strategyDeclaration
-        });
-        const strategyConfig = strategyDeclaration.config;
-        const strategyUniverse = strategyConfig.UNIVERSE;
-        const resolvedAccountId = await resolveAccountId({
-          userName,
-          deployment,
-          universe: strategyUniverse
-        });
-        return {
-          strategyName,
-          version: strategyDeclaration.version,
-          enabled: strategyDeclaration.enabled,
-          controlState: strategyView?.controlState ?? "entries_paused",
-          interval: String(strategyConfig.INTERVAL),
-          universe: strategyUniverse,
-          accountId: resolvedAccountId,
-          strategyPackage,
-          strategyPackageVersion,
-          runtimePackageVersion,
-          strategyCreator,
-          sourceStrategyConfig: strategyConfig,
-          strategyConfig,
-          ...selection ? { selection } : {}
-        };
-      }
-    )
-  );
-  const filtered = strategies.filter(
-    (candidate) => (!universe || candidate.universe === universe) && (!interval || String(candidate.interval) === String(interval)) && (!accountId || candidate.accountId === accountId)
-  );
-  const identities = /* @__PURE__ */ new Set();
-  for (const candidate of filtered) {
-    const identity = `${candidate.strategyName}:${candidate.accountId ?? "default"}`;
-    if (identities.has(identity)) {
-      throw new Error(`Runtime strategy conflict: ${identity}`);
-    }
-    identities.add(identity);
-  }
-  return filtered;
-};
-var getRuntimeStrategyPackageMetadata = async ({
-  strategyName,
-  projectRoot
-}) => {
-  const packageManifest = await readPackageManifest(projectRoot);
-  const pluginSource = await getStrategyPluginSource(strategyName, projectRoot) ?? null;
-  const strategyPackage = await resolveStrategyPackageName({
-    pluginSource,
-    projectRoot
-  });
-  return {
-    strategyPackage,
-    strategyPackageVersion: await resolveInstalledPackageVersion(
-      projectRoot,
-      strategyPackage,
-      packageManifest
-    ),
-    runtimePackageVersion: await resolveInstalledPackageVersion(
-      projectRoot,
-      "@tradejs/node",
-      packageManifest
-    )
-  };
-};
-
-export {
-  verifyRuntimeDeclaration,
-  listRuntimeDeployments,
-  getRuntimeDeployment,
-  loadResolvedRuntimeStrategies,
-  getRuntimeStrategyPackageMetadata
-};