@tradejs/node 3.1.11 → 3.1.12-beta.218

package/dist/chunk-NQO2MFP6.mjs

@@ -0,0 +1,552 @@
+import {
+  getStrategyCreator,
+  getStrategyEntry,
+  getStrategyPluginSource
+} from "./chunk-IKRSNRP6.mjs";
+import {
+  loadTradejsConfig
+} from "./chunk-LZDXRXIU.mjs";
+
+// src/runtimeStrategies.ts
+import { createHash } from "crypto";
+import { readFile } from "fs/promises";
+import path from "path";
+import { getRuntimeControls } from "@tradejs/infra/runtimeControls";
+import { resolveTradingAccount } from "@tradejs/infra/tradingAccounts";
+var RUNTIME_PACKAGE_MANIFEST_SCHEMA = "tradejs-runtime-package-manifest/v1";
+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(["generation", "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 normalizeForCanonicalJson = (value) => {
+  if (Array.isArray(value)) return value.map(normalizeForCanonicalJson);
+  if (isRecord(value)) {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, nestedValue]) => [
+        key,
+        normalizeForCanonicalJson(nestedValue)
+      ])
+    );
+  }
+  return value;
+};
+var revision = (prefix, value) => `${prefix}:${createHash("sha256").update(JSON.stringify(normalizeForCanonicalJson(value))).digest("hex").slice(0, 16)}`;
+var computeStrategyRevision = ({
+  strategyName,
+  strategyPackage,
+  strategyPackageVersion,
+  strategyDependencyVersions,
+  runtimePackageVersion,
+  strategyConfig
+}) => revision("sr1", {
+  schema: "tradejs-strategy-revision/v1",
+  strategyName,
+  strategyPackage,
+  strategyPackageVersion,
+  strategyDependencyVersions,
+  runtimePackageVersion,
+  strategyConfig
+});
+var computeDeploymentCompositionId = (value) => revision("dc1", {
+  schema: "tradejs-deployment-composition/v1",
+  ...value,
+  assetClasses: value.assetClasses ? [...value.assetClasses].sort((left, right) => left.localeCompare(right)) : void 0,
+  strategies: [...value.strategies].sort(
+    (left, right) => left.strategyName.localeCompare(right.strategyName)
+  ).map((strategy) => ({
+    ...strategy,
+    selection: strategy.selection ? {
+      tickers: [...strategy.selection.tickers].sort(
+        (left, right) => left.localeCompare(right)
+      )
+    } : void 0
+  }))
+});
+var readRuntimePackageManifest = async (projectRoot) => {
+  const manifestPath = process.env.TRADEJS_RUNTIME_PACKAGE_MANIFEST?.trim() || path.join(projectRoot, "runtime-package-manifest.json");
+  let value;
+  try {
+    value = JSON.parse(await readFile(manifestPath, "utf8"));
+  } catch (error) {
+    throw new Error(
+      `Unable to read runtime package manifest ${manifestPath}: ${String(error)}`
+    );
+  }
+  if (!isRecord(value) || Object.keys(value).some(
+    (key) => !["schema", "projectSha", "packages"].includes(key)
+  ) || value.schema !== RUNTIME_PACKAGE_MANIFEST_SCHEMA || typeof value.projectSha !== "string" || !/^[a-f0-9]{40}$/.test(value.projectSha) || !isRecord(value.packages) || Object.keys(value.packages).length === 0 || Object.entries(value.packages).some(
+    ([packageName, version]) => !packageName.trim() || typeof version !== "string" || !version.trim()
+  )) {
+    throw new Error(`Invalid runtime package manifest: ${manifestPath}`);
+  }
+  return value;
+};
+var readInstalledPackageMetadata = async ({
+  projectRoot,
+  packageName,
+  projectPackage
+}) => {
+  const packageJsonPath = projectPackage ? path.join(projectRoot, "package.json") : path.join(
+    projectRoot,
+    "node_modules",
+    ...packageName.split("/"),
+    "package.json"
+  );
+  try {
+    const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+    if (packageJson.name !== void 0 && packageJson.name !== packageName || typeof packageJson.version !== "string" || !packageJson.version.trim()) {
+      throw new Error("name or version is invalid");
+    }
+    const dependencyNames = [
+      ...isRecord(packageJson.dependencies) ? Object.keys(packageJson.dependencies) : [],
+      ...isRecord(packageJson.peerDependencies) ? Object.keys(packageJson.peerDependencies) : []
+    ];
+    return {
+      version: packageJson.version,
+      runtimeDependencies: [...new Set(dependencyNames)].filter((name) => name.startsWith("@tradejs/")).sort((left, right) => left.localeCompare(right))
+    };
+  } catch (error) {
+    throw new Error(
+      `Installed package manifest not found for ${packageName}: ${String(error)}`
+    );
+  }
+};
+var resolveVerifiedPackageVersion = async ({
+  projectRoot,
+  packageName,
+  manifest,
+  projectPackage = false
+}) => {
+  const declaredVersion = manifest.packages[packageName];
+  if (!declaredVersion) {
+    throw new Error(`Runtime package manifest is missing ${packageName}`);
+  }
+  const installed = await readInstalledPackageMetadata({
+    projectRoot,
+    packageName,
+    projectPackage
+  });
+  if (declaredVersion !== installed.version) {
+    throw new Error(
+      `Runtime package manifest mismatch for ${packageName}: declared=${declaredVersion} installed=${installed.version}`
+    );
+  }
+  return installed.version;
+};
+var resolveVerifiedStrategyDependencyVersions = async ({
+  projectRoot,
+  strategyPackage,
+  manifest
+}) => {
+  const metadata = await readInstalledPackageMetadata({
+    projectRoot,
+    packageName: strategyPackage.name,
+    projectPackage: strategyPackage.projectPackage
+  });
+  return Object.fromEntries(
+    await Promise.all(
+      metadata.runtimeDependencies.map(async (packageName) => [
+        packageName,
+        await resolveVerifiedPackageVersion({
+          projectRoot,
+          packageName,
+          manifest
+        })
+      ])
+    )
+  );
+};
+var resolveStrategyPackage = async ({
+  pluginSource,
+  projectRoot
+}) => {
+  if (!pluginSource) return null;
+  if (!pluginSource.startsWith(".") && !path.isAbsolute(pluginSource)) {
+    return { name: pluginSource, projectPackage: false };
+  }
+  try {
+    const packageJson = JSON.parse(
+      await readFile(path.join(projectRoot, "package.json"), "utf8")
+    );
+    return typeof packageJson.name === "string" && packageJson.name.trim() ? { name: packageJson.name, projectPackage: true } : null;
+  } catch {
+    return null;
+  }
+};
+var verifyStringSet = (value) => value === void 0 || Array.isArray(value) && value.length > 0 && value.every(
+  (item) => typeof item === "string" && item.length > 0 && item === item.trim()
+) && new Set(value).size === value.length;
+var verifyStrategySelection = (value) => value === void 0 || isRecord(value) && Object.keys(value).length === 1 && Object.keys(value).every((key) => SELECTION_KEYS.has(key)) && value.tickers !== void 0 && verifyStringSet(value.tickers);
+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" || !verifyStringSet(value.assetClasses) || !verifyStringSet(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)) || strategyValue.generation !== void 0 && (typeof strategyValue.generation !== "string" || !strategyValue.generation.trim()) || 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 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 resolveStrategyComposition = async ({
+  strategyName,
+  declaration,
+  deployment,
+  projectRoot,
+  packageManifest
+}) => {
+  const [strategyEntry, strategyCreator, pluginSource] = await Promise.all([
+    getStrategyEntry(strategyName, projectRoot),
+    getStrategyCreator(strategyName, projectRoot),
+    getStrategyPluginSource(strategyName, projectRoot)
+  ]);
+  if (!strategyEntry || !strategyCreator) {
+    throw new Error(`Unknown strategy: ${strategyName}`);
+  }
+  if (typeof strategyEntry.parseConfig !== "function") {
+    throw new Error(`Strategy config parser is missing: ${strategyName}`);
+  }
+  const strategyPackage = await resolveStrategyPackage({
+    pluginSource: pluginSource ?? null,
+    projectRoot
+  });
+  if (!strategyPackage) {
+    throw new Error(`Installed strategy package not found: ${strategyName}`);
+  }
+  const [
+    strategyPackageVersion,
+    strategyDependencyVersions,
+    runtimePackageVersion
+  ] = await Promise.all([
+    resolveVerifiedPackageVersion({
+      projectRoot,
+      packageName: strategyPackage.name,
+      projectPackage: strategyPackage.projectPackage,
+      manifest: packageManifest
+    }),
+    resolveVerifiedStrategyDependencyVersions({
+      projectRoot,
+      strategyPackage,
+      manifest: packageManifest
+    }),
+    resolveVerifiedPackageVersion({
+      projectRoot,
+      packageName: "@tradejs/node",
+      manifest: packageManifest
+    })
+  ]);
+  const parsedConfig = strategyEntry.parseConfig(declaration.config);
+  if (!isRecord(parsedConfig)) {
+    throw new Error(
+      `Strategy config parser returned a non-object: ${strategyName}`
+    );
+  }
+  const strategyConfig = parsedConfig;
+  const selection = resolveStrategySelection({
+    deployment,
+    strategy: declaration
+  });
+  return {
+    strategyName,
+    strategyRevision: computeStrategyRevision({
+      strategyName,
+      strategyPackage: strategyPackage.name,
+      strategyPackageVersion,
+      strategyDependencyVersions,
+      runtimePackageVersion,
+      strategyConfig
+    }),
+    ...declaration.generation ? { generation: declaration.generation } : {},
+    enabled: declaration.enabled,
+    interval: String(strategyConfig.INTERVAL),
+    universe: strategyConfig.UNIVERSE,
+    strategyPackage: strategyPackage.name,
+    strategyPackageVersion,
+    strategyDependencyVersions,
+    runtimePackageVersion,
+    strategyCreator,
+    sourceStrategyConfig: declaration.config,
+    strategyConfig,
+    ...selection ? { selection } : {}
+  };
+};
+var resolveRuntimeComposition = async ({
+  projectRoot
+}) => {
+  const [runtime, packageManifest] = await Promise.all([
+    loadRuntimeDeclaration(projectRoot),
+    readRuntimePackageManifest(projectRoot)
+  ]);
+  const deployments = await Promise.all(
+    Object.entries(runtime.deployments).map(
+      async ([deploymentId, declaration]) => {
+        const strategies = await Promise.all(
+          Object.entries(declaration.strategies).map(
+            ([strategyName, strategyDeclaration]) => resolveStrategyComposition({
+              strategyName,
+              declaration: strategyDeclaration,
+              deployment: declaration,
+              projectRoot,
+              packageManifest
+            })
+          )
+        );
+        const provider = (declaration.provider || declaration.connectorName).trim().toLowerCase();
+        return {
+          deploymentId,
+          deploymentCompositionId: computeDeploymentCompositionId({
+            deploymentId,
+            connectorName: declaration.connectorName.trim(),
+            provider,
+            accountId: declaration.accountId.trim(),
+            enabled: declaration.enabled ?? true,
+            ...declaration.assetClasses ? { assetClasses: declaration.assetClasses } : {},
+            strategies: strategies.map((strategy) => ({
+              strategyName: strategy.strategyName,
+              strategyRevision: strategy.strategyRevision,
+              enabled: strategy.enabled,
+              ...strategy.selection ? { selection: strategy.selection } : {}
+            }))
+          }),
+          declaration,
+          strategies
+        };
+      }
+    )
+  );
+  return {
+    deployments: deployments.sort(
+      (left, right) => left.deploymentId.localeCompare(right.deploymentId)
+    )
+  };
+};
+var toRuntimeDeployment = ({
+  composition,
+  controls
+}) => {
+  const { declaration, deploymentId } = composition;
+  const deploymentEnabled = declaration.enabled ?? true;
+  return {
+    id: deploymentId,
+    deploymentCompositionId: composition.deploymentCompositionId,
+    label: declaration.label?.trim() || deploymentId,
+    connectorName: declaration.connectorName.trim(),
+    provider: (declaration.provider || declaration.connectorName).trim().toLowerCase(),
+    accountId: declaration.accountId.trim(),
+    enabled: deploymentEnabled,
+    strategies: composition.strategies.map((strategy) => ({
+      strategyName: strategy.strategyName,
+      strategyRevision: strategy.strategyRevision,
+      enabled: strategy.enabled,
+      controlState: deploymentEnabled && strategy.enabled && !controls.deployments[deploymentId]?.[strategy.strategyName]?.entriesPaused ? "active" : "entries_paused",
+      ...strategy.selection ? { selection: strategy.selection } : {}
+    })),
+    ...declaration.assetClasses ? { assetClasses: declaration.assetClasses } : {},
+    ...declaration.tickers ? { tickers: declaration.tickers } : {}
+  };
+};
+var listRuntimeDeployments = async ({
+  userName,
+  projectRoot
+}) => {
+  const [composition, controls] = await Promise.all([
+    resolveRuntimeComposition({ projectRoot }),
+    getRuntimeControls(userName)
+  ]);
+  return composition.deployments.map(
+    (deploymentComposition) => toRuntimeDeployment({ composition: deploymentComposition, 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 [composition, controls] = await Promise.all([
+    resolveRuntimeComposition({ projectRoot }),
+    getRuntimeControls(userName)
+  ]);
+  const deploymentComposition = composition.deployments.find(
+    (candidate) => candidate.deploymentId === deploymentId
+  );
+  if (!deploymentComposition) {
+    throw new Error(`Runtime deployment not found: ${deploymentId}`);
+  }
+  const deployment = toRuntimeDeployment({
+    composition: deploymentComposition,
+    controls
+  });
+  const strategies = await Promise.all(
+    deploymentComposition.strategies.map(async (strategy) => {
+      const strategyView = deployment.strategies.find(
+        (candidate) => candidate.strategyName === strategy.strategyName
+      );
+      const resolvedAccountId = await resolveAccountId({
+        userName,
+        deployment,
+        universe: strategy.universe
+      });
+      return {
+        ...strategy,
+        deploymentCompositionId: deploymentComposition.deploymentCompositionId,
+        accountId: resolvedAccountId,
+        controlState: strategyView?.controlState ?? "entries_paused"
+      };
+    })
+  );
+  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, pluginSource] = await Promise.all([
+    readRuntimePackageManifest(projectRoot),
+    getStrategyPluginSource(strategyName, projectRoot)
+  ]);
+  const strategyPackage = await resolveStrategyPackage({
+    pluginSource: pluginSource ?? null,
+    projectRoot
+  });
+  if (!strategyPackage) {
+    throw new Error(`Installed strategy package not found: ${strategyName}`);
+  }
+  const [
+    strategyPackageVersion,
+    strategyDependencyVersions,
+    runtimePackageVersion
+  ] = await Promise.all([
+    resolveVerifiedPackageVersion({
+      projectRoot,
+      packageName: strategyPackage.name,
+      projectPackage: strategyPackage.projectPackage,
+      manifest: packageManifest
+    }),
+    resolveVerifiedStrategyDependencyVersions({
+      projectRoot,
+      strategyPackage,
+      manifest: packageManifest
+    }),
+    resolveVerifiedPackageVersion({
+      projectRoot,
+      packageName: "@tradejs/node",
+      manifest: packageManifest
+    })
+  ]);
+  return {
+    strategyPackage: strategyPackage.name,
+    strategyPackageVersion,
+    strategyDependencyVersions,
+    runtimePackageVersion
+  };
+};
+
+export {
+  RUNTIME_PACKAGE_MANIFEST_SCHEMA,
+  computeStrategyRevision,
+  computeDeploymentCompositionId,
+  verifyRuntimeDeclaration,
+  resolveRuntimeComposition,
+  listRuntimeDeployments,
+  getRuntimeDeployment,
+  loadResolvedRuntimeStrategies,
+  getRuntimeStrategyPackageMetadata
+};