@tradejs/infra 1.0.9 → 1.0.11

package/dist/backtestArtifacts.js

@@ -0,0 +1,255 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/backtestArtifacts.ts
+var backtestArtifacts_exports = {};
+__export(backtestArtifacts_exports, {
+  deleteCachedBacktestArtifacts: () => deleteCachedBacktestArtifacts,
+  deletePersistedBacktestOrderLog: () => deletePersistedBacktestOrderLog,
+  getBacktestArtifactsRootDir: () => getBacktestArtifactsRootDir,
+  getBacktestCacheArtifactsDirForUser: () => getBacktestCacheArtifactsDirForUser,
+  getPersistedBacktestArtifactsDirForUser: () => getPersistedBacktestArtifactsDirForUser,
+  parseBacktestArtifactRef: () => parseBacktestArtifactRef,
+  readCachedBacktestArtifacts: () => readCachedBacktestArtifacts,
+  readPersistedBacktestOrderLog: () => readPersistedBacktestOrderLog,
+  writeCachedBacktestArtifacts: () => writeCachedBacktestArtifacts,
+  writePersistedBacktestOrderLog: () => writePersistedBacktestOrderLog
+});
+module.exports = __toCommonJS(backtestArtifacts_exports);
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+var BACKTEST_ARTIFACTS_DIR = import_path.default.join("data", "backtests");
+var resolveProjectRoot = (projectRoot) => {
+  const explicit = String(projectRoot || "").trim();
+  if (explicit) {
+    return import_path.default.resolve(explicit);
+  }
+  const fromEnv = String(process.env.PROJECT_CWD || "").trim();
+  if (fromEnv) {
+    return import_path.default.resolve(fromEnv);
+  }
+  return process.cwd();
+};
+var encodeSegment = (value) => encodeURIComponent(String(value));
+var toProjectRelativePath = (projectRoot, absolutePath) => import_path.default.relative(projectRoot, absolutePath);
+var resolveArtifactPath = (relativePath, projectRoot) => {
+  const root = resolveProjectRoot(projectRoot);
+  return import_path.default.isAbsolute(relativePath) ? relativePath : import_path.default.resolve(root, relativePath);
+};
+var isEnoentError = (error) => error?.code === "ENOENT";
+var createRef = (absolutePath, projectRoot) => ({
+  kind: "file",
+  version: 1,
+  path: toProjectRelativePath(resolveProjectRoot(projectRoot), absolutePath)
+});
+var isBacktestArtifactRef = (value) => Boolean(
+  value && typeof value === "object" && value.kind === "file" && value.version === 1 && typeof value.path === "string"
+);
+var getCachedArtifactPath = (userName, orderLogId, artifactName, projectRoot) => import_path.default.join(
+  resolveProjectRoot(projectRoot),
+  BACKTEST_ARTIFACTS_DIR,
+  "cache",
+  encodeSegment(userName),
+  artifactName,
+  `${encodeSegment(orderLogId)}.json`
+);
+var getPersistedOrderLogPath = (userName, strategyName, testName, projectRoot) => import_path.default.join(
+  resolveProjectRoot(projectRoot),
+  BACKTEST_ARTIFACTS_DIR,
+  "tests",
+  encodeSegment(userName),
+  encodeSegment(strategyName),
+  `${encodeSegment(testName)}.json`
+);
+var readJsonFile = async (absolutePath, fallback) => {
+  try {
+    const raw = await import_promises.default.readFile(absolutePath, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (isEnoentError(error)) {
+      return fallback;
+    }
+    throw error;
+  }
+};
+var writeJsonFile = async (absolutePath, value) => {
+  await import_promises.default.mkdir(import_path.default.dirname(absolutePath), { recursive: true });
+  await import_promises.default.writeFile(absolutePath, JSON.stringify(value), "utf8");
+};
+var removeFileIfExists = async (absolutePath) => {
+  try {
+    await import_promises.default.rm(absolutePath, { force: true });
+    return true;
+  } catch (error) {
+    if (isEnoentError(error)) {
+      return false;
+    }
+    throw error;
+  }
+};
+var writeCachedBacktestArtifacts = async ({
+  orderLog,
+  orderLogId,
+  positionLog,
+  projectRoot,
+  userName
+}) => {
+  const orderPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "orders",
+    projectRoot
+  );
+  const positionPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "positions",
+    projectRoot
+  );
+  await Promise.all([
+    writeJsonFile(orderPath, orderLog),
+    writeJsonFile(positionPath, positionLog)
+  ]);
+  return {
+    orderLog: createRef(orderPath, projectRoot),
+    positionLog: createRef(positionPath, projectRoot)
+  };
+};
+var readCachedBacktestArtifacts = async ({
+  orderLogId,
+  projectRoot,
+  userName
+}) => {
+  const orderPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "orders",
+    projectRoot
+  );
+  const positionPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "positions",
+    projectRoot
+  );
+  const [orderLog, positionLog] = await Promise.all([
+    readJsonFile(orderPath, null),
+    readJsonFile(positionPath, null)
+  ]);
+  return { orderLog, positionLog };
+};
+var deleteCachedBacktestArtifacts = async ({
+  orderLogId,
+  projectRoot,
+  userName
+}) => {
+  const orderPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "orders",
+    projectRoot
+  );
+  const positionPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "positions",
+    projectRoot
+  );
+  const [removedOrderLog, removedPositionLog] = await Promise.all([
+    removeFileIfExists(orderPath),
+    removeFileIfExists(positionPath)
+  ]);
+  return removedOrderLog || removedPositionLog;
+};
+var writePersistedBacktestOrderLog = async ({
+  orderLog,
+  projectRoot,
+  strategyName,
+  testName,
+  userName
+}) => {
+  const absolutePath = getPersistedOrderLogPath(
+    userName,
+    strategyName,
+    testName,
+    projectRoot
+  );
+  await writeJsonFile(absolutePath, orderLog);
+  return createRef(absolutePath, projectRoot);
+};
+var readPersistedBacktestOrderLog = async ({
+  projectRoot,
+  ref,
+  strategyName,
+  testName,
+  userName
+}) => {
+  const absolutePath = ref ? resolveArtifactPath(ref.path, projectRoot) : getPersistedOrderLogPath(userName, strategyName, testName, projectRoot);
+  return readJsonFile(absolutePath, null);
+};
+var deletePersistedBacktestOrderLog = async ({
+  projectRoot,
+  ref,
+  strategyName,
+  testName,
+  userName
+}) => {
+  const absolutePath = ref ? resolveArtifactPath(ref.path, projectRoot) : getPersistedOrderLogPath(userName, strategyName, testName, projectRoot);
+  return removeFileIfExists(absolutePath);
+};
+var parseBacktestArtifactRef = (value) => {
+  if (isBacktestArtifactRef(value)) {
+    return value;
+  }
+  return null;
+};
+var getBacktestArtifactsRootDir = (projectRoot) => import_path.default.join(resolveProjectRoot(projectRoot), BACKTEST_ARTIFACTS_DIR);
+var getBacktestCacheArtifactsDirForUser = (userName, projectRoot) => import_path.default.join(
+  getBacktestArtifactsRootDir(projectRoot),
+  "cache",
+  encodeSegment(userName)
+);
+var getPersistedBacktestArtifactsDirForUser = (userName, projectRoot) => import_path.default.join(
+  getBacktestArtifactsRootDir(projectRoot),
+  "tests",
+  encodeSegment(userName)
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deleteCachedBacktestArtifacts,
+  deletePersistedBacktestOrderLog,
+  getBacktestArtifactsRootDir,
+  getBacktestCacheArtifactsDirForUser,
+  getPersistedBacktestArtifactsDirForUser,
+  parseBacktestArtifactRef,
+  readCachedBacktestArtifacts,
+  readPersistedBacktestOrderLog,
+  writeCachedBacktestArtifacts,
+  writePersistedBacktestOrderLog
+});

package/dist/backtestArtifacts.mjs

@@ -0,0 +1,211 @@
+// src/backtestArtifacts.ts
+import fs from "fs/promises";
+import path from "path";
+var BACKTEST_ARTIFACTS_DIR = path.join("data", "backtests");
+var resolveProjectRoot = (projectRoot) => {
+  const explicit = String(projectRoot || "").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 encodeSegment = (value) => encodeURIComponent(String(value));
+var toProjectRelativePath = (projectRoot, absolutePath) => path.relative(projectRoot, absolutePath);
+var resolveArtifactPath = (relativePath, projectRoot) => {
+  const root = resolveProjectRoot(projectRoot);
+  return path.isAbsolute(relativePath) ? relativePath : path.resolve(root, relativePath);
+};
+var isEnoentError = (error) => error?.code === "ENOENT";
+var createRef = (absolutePath, projectRoot) => ({
+  kind: "file",
+  version: 1,
+  path: toProjectRelativePath(resolveProjectRoot(projectRoot), absolutePath)
+});
+var isBacktestArtifactRef = (value) => Boolean(
+  value && typeof value === "object" && value.kind === "file" && value.version === 1 && typeof value.path === "string"
+);
+var getCachedArtifactPath = (userName, orderLogId, artifactName, projectRoot) => path.join(
+  resolveProjectRoot(projectRoot),
+  BACKTEST_ARTIFACTS_DIR,
+  "cache",
+  encodeSegment(userName),
+  artifactName,
+  `${encodeSegment(orderLogId)}.json`
+);
+var getPersistedOrderLogPath = (userName, strategyName, testName, projectRoot) => path.join(
+  resolveProjectRoot(projectRoot),
+  BACKTEST_ARTIFACTS_DIR,
+  "tests",
+  encodeSegment(userName),
+  encodeSegment(strategyName),
+  `${encodeSegment(testName)}.json`
+);
+var readJsonFile = async (absolutePath, fallback) => {
+  try {
+    const raw = await fs.readFile(absolutePath, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (isEnoentError(error)) {
+      return fallback;
+    }
+    throw error;
+  }
+};
+var writeJsonFile = async (absolutePath, value) => {
+  await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+  await fs.writeFile(absolutePath, JSON.stringify(value), "utf8");
+};
+var removeFileIfExists = async (absolutePath) => {
+  try {
+    await fs.rm(absolutePath, { force: true });
+    return true;
+  } catch (error) {
+    if (isEnoentError(error)) {
+      return false;
+    }
+    throw error;
+  }
+};
+var writeCachedBacktestArtifacts = async ({
+  orderLog,
+  orderLogId,
+  positionLog,
+  projectRoot,
+  userName
+}) => {
+  const orderPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "orders",
+    projectRoot
+  );
+  const positionPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "positions",
+    projectRoot
+  );
+  await Promise.all([
+    writeJsonFile(orderPath, orderLog),
+    writeJsonFile(positionPath, positionLog)
+  ]);
+  return {
+    orderLog: createRef(orderPath, projectRoot),
+    positionLog: createRef(positionPath, projectRoot)
+  };
+};
+var readCachedBacktestArtifacts = async ({
+  orderLogId,
+  projectRoot,
+  userName
+}) => {
+  const orderPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "orders",
+    projectRoot
+  );
+  const positionPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "positions",
+    projectRoot
+  );
+  const [orderLog, positionLog] = await Promise.all([
+    readJsonFile(orderPath, null),
+    readJsonFile(positionPath, null)
+  ]);
+  return { orderLog, positionLog };
+};
+var deleteCachedBacktestArtifacts = async ({
+  orderLogId,
+  projectRoot,
+  userName
+}) => {
+  const orderPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "orders",
+    projectRoot
+  );
+  const positionPath = getCachedArtifactPath(
+    userName,
+    orderLogId,
+    "positions",
+    projectRoot
+  );
+  const [removedOrderLog, removedPositionLog] = await Promise.all([
+    removeFileIfExists(orderPath),
+    removeFileIfExists(positionPath)
+  ]);
+  return removedOrderLog || removedPositionLog;
+};
+var writePersistedBacktestOrderLog = async ({
+  orderLog,
+  projectRoot,
+  strategyName,
+  testName,
+  userName
+}) => {
+  const absolutePath = getPersistedOrderLogPath(
+    userName,
+    strategyName,
+    testName,
+    projectRoot
+  );
+  await writeJsonFile(absolutePath, orderLog);
+  return createRef(absolutePath, projectRoot);
+};
+var readPersistedBacktestOrderLog = async ({
+  projectRoot,
+  ref,
+  strategyName,
+  testName,
+  userName
+}) => {
+  const absolutePath = ref ? resolveArtifactPath(ref.path, projectRoot) : getPersistedOrderLogPath(userName, strategyName, testName, projectRoot);
+  return readJsonFile(absolutePath, null);
+};
+var deletePersistedBacktestOrderLog = async ({
+  projectRoot,
+  ref,
+  strategyName,
+  testName,
+  userName
+}) => {
+  const absolutePath = ref ? resolveArtifactPath(ref.path, projectRoot) : getPersistedOrderLogPath(userName, strategyName, testName, projectRoot);
+  return removeFileIfExists(absolutePath);
+};
+var parseBacktestArtifactRef = (value) => {
+  if (isBacktestArtifactRef(value)) {
+    return value;
+  }
+  return null;
+};
+var getBacktestArtifactsRootDir = (projectRoot) => path.join(resolveProjectRoot(projectRoot), BACKTEST_ARTIFACTS_DIR);
+var getBacktestCacheArtifactsDirForUser = (userName, projectRoot) => path.join(
+  getBacktestArtifactsRootDir(projectRoot),
+  "cache",
+  encodeSegment(userName)
+);
+var getPersistedBacktestArtifactsDirForUser = (userName, projectRoot) => path.join(
+  getBacktestArtifactsRootDir(projectRoot),
+  "tests",
+  encodeSegment(userName)
+);
+export {
+  deleteCachedBacktestArtifacts,
+  deletePersistedBacktestOrderLog,
+  getBacktestArtifactsRootDir,
+  getBacktestCacheArtifactsDirForUser,
+  getPersistedBacktestArtifactsDirForUser,
+  parseBacktestArtifactRef,
+  readCachedBacktestArtifacts,
+  readPersistedBacktestOrderLog,
+  writeCachedBacktestArtifacts,
+  writePersistedBacktestOrderLog
+};

package/dist/{chunk-KVEZORMS.mjs → chunk-RQP5VSTH.mjs}

@@ -3,15 +3,26 @@ import { once } from "events";
 import { createReadStream, createWriteStream } from "fs";
 import fs from "fs/promises";
 import path from "path";
+import readline from "readline";
 var DEFAULT_DIR = "data/ml/export";
 var ML_DATASET_WRITE_BATCH_SIZE = 200;
 var ML_CHUNK_FILE_RE = /^ml-dataset-(.+)-chunk-[^.]+\.jsonl$/;
+var BACKTEST_RUN_CHUNK_ID_RE = /^(\d{12}-[a-f0-9]{8})-/;
 var writerByPath = /* @__PURE__ */ new Map();
 var toFileToken = (value) => value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "") || "any";
 var getMlChunkFilePath = (strategyName, chunkId, outDir = DEFAULT_DIR) => path.join(
   outDir,
   `ml-dataset-${toFileToken(strategyName)}-chunk-${toFileToken(chunkId)}.jsonl`
 );
+var getMlChunkFilePrefix = (strategyName, runId) => `ml-dataset-${toFileToken(strategyName)}-chunk-${runId ? `${toFileToken(runId)}-` : ""}`;
+var getRunIdFromMlChunkFileName = (strategyName, fileName) => {
+  const prefix = getMlChunkFilePrefix(strategyName);
+  if (!fileName.startsWith(prefix) || !fileName.endsWith(".jsonl")) {
+    return "";
+  }
+  const chunkToken = fileName.slice(prefix.length, -".jsonl".length);
+  return chunkToken.match(BACKTEST_RUN_CHUNK_ID_RE)?.[1] ?? "";
+};
 var appendMlDatasetRow = async (params) => {
   const { strategyName, chunkId, row, outDir = DEFAULT_DIR } = params;
   const filePath = getMlChunkFilePath(strategyName, chunkId, outDir);
@@ -85,8 +96,8 @@ var closeAllMlDatasetWriters = async () => {
   }
 };
 var listMlChunkFiles = async (params) => {
-  const { strategyName, outDir = DEFAULT_DIR } = params;
-  const prefix = `ml-dataset-${toFileToken(strategyName)}-chunk-`;
+  const { strategyName, outDir = DEFAULT_DIR, runId } = params;
+  const prefix = getMlChunkFilePrefix(strategyName, runId);
   let entries = [];
   try {
     entries = await fs.readdir(outDir);
@@ -95,6 +106,20 @@ var listMlChunkFiles = async (params) => {
   }
   return entries.filter((name) => name.startsWith(prefix) && name.endsWith(".jsonl")).map((name) => path.join(outDir, name)).sort();
 };
+var listMlChunkRunIds = async (params) => {
+  const { strategyName, outDir = DEFAULT_DIR } = params;
+  let entries = [];
+  try {
+    entries = await fs.readdir(outDir);
+  } catch {
+    return [];
+  }
+  return [
+    ...new Set(
+      entries.map((name) => getRunIdFromMlChunkFileName(strategyName, name)).filter(Boolean)
+    )
+  ].sort();
+};
 var listMlChunkStrategies = async (params) => {
   const outDir = params?.outDir ?? DEFAULT_DIR;
   let entries = [];
@@ -110,12 +135,37 @@ var listMlChunkStrategies = async (params) => {
   ].sort();
 };
 var mergeJsonlFiles = async (params) => {
-  const { filePaths, outPath } = params;
+  const { filePaths, outPath, shouldIncludeRow } = params;
   await fs.mkdir(path.dirname(outPath), { recursive: true });
   const stream = createWriteStream(outPath, { encoding: "utf8" });
   const done = Promise.all([once(stream, "finish"), once(stream, "close")]);
   try {
     for (const filePath of filePaths) {
+      if (shouldIncludeRow) {
+        const reader2 = readline.createInterface({
+          input: createReadStream(filePath, { encoding: "utf8" }),
+          crlfDelay: Infinity
+        });
+        try {
+          for await (const line of reader2) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+              continue;
+            }
+            const row = JSON.parse(trimmed);
+            if (!shouldIncludeRow(row)) {
+              continue;
+            }
+            if (!stream.write(`${trimmed}
+`)) {
+              await once(stream, "drain");
+            }
+          }
+        } finally {
+          reader2.close();
+        }
+        continue;
+      }
       const reader = createReadStream(filePath, { encoding: "utf8" });
       for await (const chunk of reader) {
         if (!stream.write(chunk)) {
@@ -137,6 +187,7 @@ export {
   closeMlDatasetWriter,
   closeAllMlDatasetWriters,
   listMlChunkFiles,
+  listMlChunkRunIds,
   listMlChunkStrategies,
   mergeJsonlFiles
 };