@tradejs/infra 1.0.8 → 1.0.10

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
+};