@tradejs/infra 1.0.0

package/README.md

@@ -0,0 +1,51 @@
+# @tradejs/infra
+
+Server-only infrastructure adapters for TradeJS.
+
+- Homepage: https://tradejs.dev
+- Documentation: https://docs.tradejs.dev
+- Quickstart: https://docs.tradejs.dev/getting-started/quickstart
+
+## Where It Fits
+
+`@tradejs/infra` is not part of the basic authoring surface.
+
+Most external users do not install it directly. It usually comes transitively through:
+
+- `@tradejs/app`
+- `@tradejs/cli`
+- `@tradejs/node`
+
+Install it directly only if you are building custom server/runtime integrations on top of TradeJS.
+
+## Direct Install
+
+```bash
+npm i @tradejs/infra @tradejs/types
+```
+
+## Public Surface
+
+Import only explicit subpaths:
+
+- `@tradejs/infra/files`
+- `@tradejs/infra/http`
+- `@tradejs/infra/logger`
+- `@tradejs/infra/ml`
+- `@tradejs/infra/redis`
+- `@tradejs/infra/timescale`
+
+There is no root `@tradejs/infra` import surface.
+
+## Usage
+
+```ts
+import { getData, setData } from '@tradejs/infra/redis';
+import { logger } from '@tradejs/infra/logger';
+```
+
+## Notes
+
+- `@tradejs/infra` is server-only. Do not import it into browser/client code.
+- Environment loading should happen in your app/runtime entrypoint, not inside shared library code.
+- If you are following the standard external quickstart, start with `@tradejs/app`, `@tradejs/core`, `@tradejs/node`, `@tradejs/base`, and `@tradejs/cli` instead of adding `@tradejs/infra` manually.

package/dist/chunk-LNFUOXDW.mjs

@@ -0,0 +1,42 @@
+// src/logger.ts
+import { createLogger, transports, format } from "winston";
+var baseFormat = format.combine(
+  format.timestamp({ format: "DD MMM HH:mm:ss" }),
+  format.splat()
+);
+var logger = createLogger({
+  format: baseFormat,
+  transports: [
+    new transports.Console({
+      format: format.combine(
+        format.colorize({ all: true }),
+        format.printf(
+          ({ level, timestamp, message }) => `${level}: ${timestamp}: ${message}`
+        )
+      )
+    }),
+    new transports.File({
+      filename: "service.log",
+      format: format.combine(
+        format.uncolorize(),
+        format.printf(
+          ({ level, timestamp, message }) => `${level}: ${timestamp}: ${message}`
+        )
+      )
+    }),
+    new transports.File({
+      filename: "error.log",
+      format: format.combine(
+        format.uncolorize(),
+        format.printf(
+          ({ level, timestamp, message }) => `${level}: ${timestamp}: ${message}`
+        )
+      ),
+      level: "error"
+    })
+  ]
+});
+
+export {
+  logger
+};

package/dist/files.d.mts

@@ -0,0 +1,9 @@
+interface Options {
+    stringify?: boolean;
+    lock?: boolean;
+}
+declare const getFiles: (dir: string) => Promise<string[]>;
+declare const getFile: (dir: string, file: string, fallback?: never[]) => Promise<any>;
+declare const setFile: <T>(dir: string, file: string, data: T, options?: Options) => Promise<void>;
+
+export { getFile, getFiles, setFile };

package/dist/files.d.ts

@@ -0,0 +1,9 @@
+interface Options {
+    stringify?: boolean;
+    lock?: boolean;
+}
+declare const getFiles: (dir: string) => Promise<string[]>;
+declare const getFile: (dir: string, file: string, fallback?: never[]) => Promise<any>;
+declare const setFile: <T>(dir: string, file: string, data: T, options?: Options) => Promise<void>;
+
+export { getFile, getFiles, setFile };

package/dist/files.js

@@ -0,0 +1,103 @@
+"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/files.ts
+var files_exports = {};
+__export(files_exports, {
+  getFile: () => getFile,
+  getFiles: () => getFiles,
+  setFile: () => setFile
+});
+module.exports = __toCommonJS(files_exports);
+var import_crypto = require("crypto");
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+var DEFAULT_OPTIONS = {
+  stringify: false,
+  lock: false
+};
+var toJson = (value, pretty = false) => JSON.stringify(value, null, pretty ? 2 : 0);
+var logError = (message, ...args) => {
+  console.error(`[infra:files] ${message}`, ...args);
+};
+var getPath = (dir, file, lock = false) => {
+  if (!lock) {
+    return import_path.default.join(process.cwd(), dir, `${file}.json`);
+  }
+  return import_path.default.join(
+    process.cwd(),
+    "data",
+    "cache",
+    `${file}.lock.${(0, import_crypto.randomUUID)()}.json`
+  );
+};
+var getDir = (dir) => import_path.default.join(process.cwd(), dir);
+var getFiles = async (dir) => {
+  return await import_promises.default.readdir(getDir(dir));
+};
+var getFile = async (dir, file, fallback = []) => {
+  const fullPath = getPath(dir, file);
+  try {
+    await import_promises.default.access(fullPath);
+  } catch {
+    return fallback;
+  }
+  try {
+    const fileContents = await import_promises.default.readFile(fullPath, "utf8");
+    return JSON.parse(fileContents);
+  } catch (error) {
+    logError("failed data file: %s", error);
+    await import_promises.default.unlink(fullPath);
+    return fallback;
+  }
+};
+var setFile = async (dir, file, data, options = {}) => {
+  const { stringify, lock } = {
+    ...DEFAULT_OPTIONS,
+    ...options
+  };
+  const fullPath = getPath(dir, file);
+  const lockFullPath = getPath(dir, file, true);
+  try {
+    if (!lock) {
+      await import_promises.default.writeFile(fullPath, toJson(data, stringify));
+      return;
+    }
+    await import_promises.default.writeFile(lockFullPath, toJson(data, stringify));
+    await import_promises.default.rename(lockFullPath, fullPath);
+  } catch (error) {
+    logError("failed to write file %s: %s", fullPath, error);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFile,
+  getFiles,
+  setFile
+});

package/dist/files.mjs

@@ -0,0 +1,66 @@
+// src/files.ts
+import { randomUUID } from "crypto";
+import fs from "fs/promises";
+import path from "path";
+var DEFAULT_OPTIONS = {
+  stringify: false,
+  lock: false
+};
+var toJson = (value, pretty = false) => JSON.stringify(value, null, pretty ? 2 : 0);
+var logError = (message, ...args) => {
+  console.error(`[infra:files] ${message}`, ...args);
+};
+var getPath = (dir, file, lock = false) => {
+  if (!lock) {
+    return path.join(process.cwd(), dir, `${file}.json`);
+  }
+  return path.join(
+    process.cwd(),
+    "data",
+    "cache",
+    `${file}.lock.${randomUUID()}.json`
+  );
+};
+var getDir = (dir) => path.join(process.cwd(), dir);
+var getFiles = async (dir) => {
+  return await fs.readdir(getDir(dir));
+};
+var getFile = async (dir, file, fallback = []) => {
+  const fullPath = getPath(dir, file);
+  try {
+    await fs.access(fullPath);
+  } catch {
+    return fallback;
+  }
+  try {
+    const fileContents = await fs.readFile(fullPath, "utf8");
+    return JSON.parse(fileContents);
+  } catch (error) {
+    logError("failed data file: %s", error);
+    await fs.unlink(fullPath);
+    return fallback;
+  }
+};
+var setFile = async (dir, file, data, options = {}) => {
+  const { stringify, lock } = {
+    ...DEFAULT_OPTIONS,
+    ...options
+  };
+  const fullPath = getPath(dir, file);
+  const lockFullPath = getPath(dir, file, true);
+  try {
+    if (!lock) {
+      await fs.writeFile(fullPath, toJson(data, stringify));
+      return;
+    }
+    await fs.writeFile(lockFullPath, toJson(data, stringify));
+    await fs.rename(lockFullPath, fullPath);
+  } catch (error) {
+    logError("failed to write file %s: %s", fullPath, error);
+  }
+};
+export {
+  getFile,
+  getFiles,
+  setFile
+};

package/dist/http.d.mts

@@ -0,0 +1,8 @@
+type FetchWithRetryOptions = RequestInit & {
+    attempts?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+};
+declare const fetchWithRetry: (url: string, options?: FetchWithRetryOptions) => Promise<Response>;
+
+export { fetchWithRetry };

package/dist/http.d.ts

@@ -0,0 +1,8 @@
+type FetchWithRetryOptions = RequestInit & {
+    attempts?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+};
+declare const fetchWithRetry: (url: string, options?: FetchWithRetryOptions) => Promise<Response>;
+
+export { fetchWithRetry };

package/dist/http.js

@@ -0,0 +1,79 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/http.ts
+var http_exports = {};
+__export(http_exports, {
+  fetchWithRetry: () => fetchWithRetry
+});
+module.exports = __toCommonJS(http_exports);
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var parseRetryAfterMs = (value) => {
+  if (!value) return 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) {
+    return Math.max(0, seconds * 1e3);
+  }
+  const dateMs = Date.parse(value);
+  if (Number.isFinite(dateMs)) {
+    return Math.max(0, dateMs - Date.now());
+  }
+  return 0;
+};
+var fetchWithRetry = async (url, options = {}) => {
+  const {
+    attempts = 5,
+    baseDelayMs = 300,
+    maxDelayMs = 5e3,
+    ...fetchOptions
+  } = options;
+  let lastError;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      const response = await fetch(url, fetchOptions);
+      if (response.ok) {
+        return response;
+      }
+      const shouldRetry = response.status === 429 || response.status >= 500;
+      if (!shouldRetry || i === attempts - 1) {
+        return response;
+      }
+      const retryAfterMs = parseRetryAfterMs(
+        response.headers.get("retry-after")
+      );
+      const backoffMs = Math.min(maxDelayMs, baseDelayMs * 2 ** i);
+      await sleep(Math.max(retryAfterMs, backoffMs));
+    } catch (error) {
+      lastError = error;
+      if (i === attempts - 1) {
+        throw error;
+      }
+      const backoffMs = Math.min(maxDelayMs, baseDelayMs * 2 ** i);
+      await sleep(backoffMs);
+    }
+  }
+  if (lastError) {
+    throw lastError;
+  }
+  return fetch(url, fetchOptions);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fetchWithRetry
+});

package/dist/http.mjs

@@ -0,0 +1,54 @@
+// src/http.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var parseRetryAfterMs = (value) => {
+  if (!value) return 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) {
+    return Math.max(0, seconds * 1e3);
+  }
+  const dateMs = Date.parse(value);
+  if (Number.isFinite(dateMs)) {
+    return Math.max(0, dateMs - Date.now());
+  }
+  return 0;
+};
+var fetchWithRetry = async (url, options = {}) => {
+  const {
+    attempts = 5,
+    baseDelayMs = 300,
+    maxDelayMs = 5e3,
+    ...fetchOptions
+  } = options;
+  let lastError;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      const response = await fetch(url, fetchOptions);
+      if (response.ok) {
+        return response;
+      }
+      const shouldRetry = response.status === 429 || response.status >= 500;
+      if (!shouldRetry || i === attempts - 1) {
+        return response;
+      }
+      const retryAfterMs = parseRetryAfterMs(
+        response.headers.get("retry-after")
+      );
+      const backoffMs = Math.min(maxDelayMs, baseDelayMs * 2 ** i);
+      await sleep(Math.max(retryAfterMs, backoffMs));
+    } catch (error) {
+      lastError = error;
+      if (i === attempts - 1) {
+        throw error;
+      }
+      const backoffMs = Math.min(maxDelayMs, baseDelayMs * 2 ** i);
+      await sleep(backoffMs);
+    }
+  }
+  if (lastError) {
+    throw lastError;
+  }
+  return fetch(url, fetchOptions);
+};
+export {
+  fetchWithRetry
+};

package/dist/logger.d.mts

@@ -0,0 +1,5 @@
+import * as winston from 'winston';
+
+declare const logger: winston.Logger;
+
+export { logger };

package/dist/logger.d.ts

@@ -0,0 +1,5 @@
+import * as winston from 'winston';
+
+declare const logger: winston.Logger;
+
+export { logger };

package/dist/logger.js

@@ -0,0 +1,66 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/logger.ts
+var logger_exports = {};
+__export(logger_exports, {
+  logger: () => logger
+});
+module.exports = __toCommonJS(logger_exports);
+var import_winston = require("winston");
+var baseFormat = import_winston.format.combine(
+  import_winston.format.timestamp({ format: "DD MMM HH:mm:ss" }),
+  import_winston.format.splat()
+);
+var logger = (0, import_winston.createLogger)({
+  format: baseFormat,
+  transports: [
+    new import_winston.transports.Console({
+      format: import_winston.format.combine(
+        import_winston.format.colorize({ all: true }),
+        import_winston.format.printf(
+          ({ level, timestamp, message }) => `${level}: ${timestamp}: ${message}`
+        )
+      )
+    }),
+    new import_winston.transports.File({
+      filename: "service.log",
+      format: import_winston.format.combine(
+        import_winston.format.uncolorize(),
+        import_winston.format.printf(
+          ({ level, timestamp, message }) => `${level}: ${timestamp}: ${message}`
+        )
+      )
+    }),
+    new import_winston.transports.File({
+      filename: "error.log",
+      format: import_winston.format.combine(
+        import_winston.format.uncolorize(),
+        import_winston.format.printf(
+          ({ level, timestamp, message }) => `${level}: ${timestamp}: ${message}`
+        )
+      ),
+      level: "error"
+    })
+  ]
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  logger
+});

package/dist/logger.mjs

@@ -0,0 +1,6 @@
+import {
+  logger
+} from "./chunk-LNFUOXDW.mjs";
+export {
+  logger
+};

package/dist/ml.d.mts

@@ -0,0 +1,135 @@
+declare const toFileToken: (value: string) => string;
+declare const getMlChunkFilePath: (strategyName: string, chunkId: string, outDir?: string) => string;
+declare const appendMlDatasetRow: (params: {
+    strategyName: string;
+    chunkId: string;
+    row: Record<string, number | string | null>;
+    outDir?: string;
+}) => Promise<string>;
+declare const flushMlDatasetWriter: (filePath: string) => Promise<void>;
+declare const closeMlDatasetWriter: (filePath: string) => Promise<void>;
+declare const closeAllMlDatasetWriters: () => Promise<void>;
+declare const listMlChunkFiles: (params: {
+    strategyName: string;
+    outDir?: string;
+}) => Promise<string[]>;
+declare const mergeJsonlFiles: (params: {
+    filePaths: string[];
+    outPath: string;
+}) => Promise<void>;
+
+type MlPredictResponse = {
+    probability: number;
+    threshold: number;
+    passed: boolean;
+};
+type MlPredictParams = {
+    strategy: string;
+    features: Record<string, number>;
+    threshold: number;
+    grpcAddress?: string;
+};
+declare const buildMlFeatures: (row: Record<string, unknown>) => Record<string, number>;
+declare const fetchMlThreshold: ({ strategy, features, threshold, grpcAddress, }: MlPredictParams) => Promise<MlPredictResponse | null>;
+
+type MlSignalRecord = {
+    signal: MlSignalPayload;
+    context?: {
+        strategyConfig?: Record<string, unknown>;
+        strategyName?: string;
+        symbol?: string;
+        entryTimestamp?: number;
+    };
+};
+type MlSignalPayload = {
+    signalId?: string;
+    strategy?: string;
+    symbol?: string;
+    direction?: string;
+    timestamp?: number;
+    interval?: number | string;
+    prices?: {
+        currentPrice?: number;
+        takeProfitPrice?: number;
+        stopLossPrice?: number;
+        riskRatio?: number;
+    };
+    indicators?: Record<string, unknown>;
+    additionalIndicators?: Record<string, unknown>;
+    figures?: {
+        trendLine?: {
+            mode?: 'highs' | 'lows' | string;
+            distance?: number;
+            alpha?: unknown[];
+            points?: Array<{
+                value?: number;
+                timestamp?: number;
+            }>;
+            touches?: Array<{
+                value?: number;
+                timestamp?: number;
+            }>;
+        };
+    };
+};
+type MlResultRecord = {
+    profit?: number;
+    direction?: 'LONG' | 'SHORT';
+    symbol?: string;
+};
+declare const buildMlTrainingRow: (signalRecord: MlSignalRecord, resultRecord: MlResultRecord | null) => Record<string, number | string | null>;
+declare const trimMlTrainingRowWindows: (row: Record<string, number | string | null>, keep?: 5) => Record<string, number | string | null>;
+
+declare const toIsoUtcOrNull: (value: number | null | undefined) => string | null;
+declare const isDerivedDatasetFileName: (name: string) => boolean;
+declare const computeWindowBoundaries: ({ maxLabeledTs, maxTrainTs, testDays, trainRecentDays, walkForwardFolds, }: {
+    maxLabeledTs: number;
+    maxTrainTs: number;
+    testDays: number;
+    trainRecentDays: number;
+    walkForwardFolds: number;
+}) => {
+    holdoutCutoffMs: number;
+    holdoutTrainStartMs: number;
+    wfStartMs: number;
+    prodStartMs: number;
+    folds: {
+        fold: number;
+        startTs: number;
+        endTs: number;
+    }[];
+};
+
+type LookaheadViolation = {
+    key: string;
+    entryTimestampMs: number;
+    featureTimestampMs: number;
+};
+declare const isTimestampFeatureKey: (key: string) => boolean;
+declare const findLookaheadViolations: (row: Record<string, unknown>) => LookaheadViolation[];
+
+type MlSeriesAnalysisCandle = {
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+    timestamp: number;
+};
+type MlSeriesAnalysisInput = {
+    candles: MlSeriesAnalysisCandle[];
+    benchmarkCandles?: MlSeriesAnalysisCandle[];
+    indicators?: {
+        atrPct?: number[];
+        price1hPcnt?: number[];
+        price24hPcnt?: number[];
+        macdHistogram?: number[];
+        maFast?: number[];
+        maSlow?: number[];
+    };
+};
+type MlSeriesAnalysisSummary = Record<string, number>;
+declare const analyzeMlSeriesWindow: (input: MlSeriesAnalysisInput) => MlSeriesAnalysisSummary;
+declare const buildMlSeriesAlignment: (left: MlSeriesAnalysisSummary | undefined, right: MlSeriesAnalysisSummary | undefined) => MlSeriesAnalysisSummary;
+
+export { type LookaheadViolation, type MlPredictParams, type MlPredictResponse, type MlResultRecord, type MlSeriesAnalysisCandle, type MlSeriesAnalysisSummary, type MlSignalRecord, analyzeMlSeriesWindow, appendMlDatasetRow, buildMlFeatures, buildMlSeriesAlignment, buildMlTrainingRow, closeAllMlDatasetWriters, closeMlDatasetWriter, computeWindowBoundaries, fetchMlThreshold, findLookaheadViolations, flushMlDatasetWriter, getMlChunkFilePath, isDerivedDatasetFileName, isTimestampFeatureKey, listMlChunkFiles, mergeJsonlFiles, toFileToken, toIsoUtcOrNull, trimMlTrainingRowWindows };