@tradejs/infra 1.0.0

package/dist/redis.mjs

@@ -0,0 +1,296 @@
+// src/redis.ts
+import Redis from "ioredis";
+var TTL_1D = 86400;
+var toJson = (value) => JSON.stringify(value);
+var logger = {
+  log: (level, message, ...args) => {
+    const method = level === "error" ? "error" : level === "warn" ? "warn" : "log";
+    console[method](`[infra:redis] ${message}`, ...args);
+  }
+};
+var redisConnectionWarningShown = false;
+var redisUnavailable = false;
+var isRedisConnectivityError = (error) => /ECONNREFUSED|ENOTFOUND|EAI_AGAIN|ETIMEDOUT|MaxRetriesPerRequestError|Connection is closed|Stream isn't writeable/i.test(
+  error.message
+);
+var toNonNegativeInt = (value, fallback) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+};
+var toPositiveInt = (value, fallback) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var markRedisUnavailable = (error) => {
+  redisUnavailable = true;
+  if (redisConnectionWarningShown) return;
+  redisConnectionWarningShown = true;
+  logger.log(
+    "warn",
+    "Redis is unavailable: %s. Cache-dependent features are temporarily disabled.",
+    error.message
+  );
+};
+var getRedis = () => {
+  if (!global.__redis__) {
+    const host = process.env.REDIS_HOST || "127.0.0.1";
+    const port = toPositiveInt(process.env.REDIS_PORT, 6379);
+    const connectTimeout = toPositiveInt(
+      process.env.REDIS_CONNECT_TIMEOUT_MS,
+      3e3
+    );
+    const maxRetriesPerRequest = toNonNegativeInt(
+      process.env.REDIS_MAX_RETRIES_PER_REQUEST,
+      1
+    );
+    global.__redis__ = new Redis({
+      host,
+      port,
+      connectTimeout,
+      maxRetriesPerRequest,
+      enableOfflineQueue: false,
+      retryStrategy: (attempt) => Math.min(attempt * 200, 2e3)
+    });
+    global.__redis__.on("error", (error) => {
+      if (isRedisConnectivityError(error)) {
+        markRedisUnavailable(error);
+        return;
+      }
+      logger.log("error", "Redis client error: %s", String(error));
+    });
+    global.__redis__.on("ready", () => {
+      redisUnavailable = false;
+      if (redisConnectionWarningShown) {
+        redisConnectionWarningShown = false;
+        logger.log("info", "Redis connection restored");
+      }
+    });
+  }
+  return global.__redis__;
+};
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var getRedisStatus = (redis) => String(redis.status ?? "ready");
+var waitForRedisReady = async (redis) => {
+  if (getRedisStatus(redis) === "ready") {
+    return true;
+  }
+  const readyTimeoutMs = toPositiveInt(
+    process.env.REDIS_READY_TIMEOUT_MS,
+    toPositiveInt(process.env.REDIS_CONNECT_TIMEOUT_MS, 3e3)
+  );
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < readyTimeoutMs) {
+    if (getRedisStatus(redis) === "ready") {
+      return true;
+    }
+    if (getRedisStatus(redis) === "end") {
+      return false;
+    }
+    await sleep(50);
+  }
+  return getRedisStatus(redis) === "ready";
+};
+var getReadyRedis = async () => {
+  if (redisUnavailable) return null;
+  const redis = getRedis();
+  const ready = await waitForRedisReady(redis);
+  if (ready) {
+    return redis;
+  }
+  markRedisUnavailable(
+    new Error(`Redis is not ready (status=${getRedisStatus(redis)})`)
+  );
+  return null;
+};
+var toResultString = (result) => {
+  if (result == null) return null;
+  if (typeof result === "string") return result;
+  if (Buffer.isBuffer(result)) return result.toString("utf8");
+  return String(result);
+};
+var DEFAULT_OPTIONS = {
+  expire: TTL_1D
+};
+var parseJsonOrDeleteKey = async (redis, key, raw, fallback) => {
+  try {
+    return JSON.parse(raw);
+  } catch (e) {
+    logger.log("error", "failed JSON.parse(%s): %s", key, String(e));
+    await redis.del(key);
+    return fallback;
+  }
+};
+var getKeys = async (prefix) => {
+  if (redisUnavailable) return [];
+  const redis = await getReadyRedis();
+  if (!redis) return [];
+  const keys = [];
+  try {
+    let cursor = "0";
+    do {
+      const [nextCursor, batch] = await redis.scan(
+        cursor,
+        "MATCH",
+        `${prefix}*`,
+        "COUNT",
+        "200"
+      );
+      cursor = nextCursor;
+      for (const key of batch) {
+        if (key.startsWith(prefix)) {
+          keys.push(key);
+        }
+      }
+    } while (cursor !== "0");
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return [];
+    }
+    logger.log("warn", "failed SCAN for %s: %s", prefix, String(e));
+    return [];
+  }
+  return keys;
+};
+var getData = async (key, fallback = []) => {
+  if (redisUnavailable) return fallback;
+  const redis = await getReadyRedis();
+  if (!redis) return fallback;
+  try {
+    const rawJson = await redis.call("JSON.GET", key);
+    const raw = toResultString(rawJson);
+    if (raw == null) return fallback;
+    return parseJsonOrDeleteKey(redis, key, raw, fallback);
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return fallback;
+    }
+    logger.log(
+      "error",
+      "failed JSON.GET %s: %s (fallback to GET)",
+      key,
+      String(e)
+    );
+  }
+  try {
+    const raw = await redis.get(key);
+    if (raw == null) return fallback;
+    return parseJsonOrDeleteKey(redis, key, raw, fallback);
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return fallback;
+    }
+    logger.log("error", "failed GET %s: %s", key, String(e));
+    return fallback;
+  }
+};
+var delKey = async (key) => {
+  return delKeyWithOptions(key);
+};
+var RedisWriteBlockedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RedisWriteBlockedError";
+  }
+};
+var delKeyWithOptions = async (key, options = {}) => {
+  if (redisUnavailable) return false;
+  const { raiseOnMisconf = false } = options;
+  const redis = await getReadyRedis();
+  if (!redis) return false;
+  try {
+    const result = await redis.del(key);
+    if (result === 1) {
+      return true;
+    }
+    return false;
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return false;
+    }
+    const msg = String(e);
+    if (raiseOnMisconf && msg.includes("MISCONF")) {
+      throw new RedisWriteBlockedError(msg);
+    }
+    logger.log("error", "failed DEL %s: %s", key, String(e));
+    return false;
+  }
+};
+var setData = async (key, data, options = {}) => {
+  if (redisUnavailable) return;
+  const { expire } = { ...DEFAULT_OPTIONS, ...options };
+  const redis = await getReadyRedis();
+  if (!redis) return;
+  const value = toJson(data);
+  try {
+    await redis.call("JSON.SET", key, "$", value);
+    if (expire) {
+      await redis.expire(key, expire);
+    }
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return;
+    }
+    logger.log(
+      "error",
+      "failed JSON.SET %s: %s (fallback to SET)",
+      key,
+      String(e)
+    );
+    try {
+      if (expire) {
+        await redis.set(key, value, "EX", expire);
+      } else {
+        await redis.set(key, value);
+      }
+    } catch (e2) {
+      if (e2 instanceof Error && isRedisConnectivityError(e2)) {
+        markRedisUnavailable(e2);
+        return;
+      }
+      logger.log("error", "failed SET %s: %s", key, String(e2));
+    }
+  }
+};
+var redisKeys = {
+  users: () => "users:index:",
+  user: (userName) => `users:index:${userName}`,
+  bots: (userName) => `users:${userName}:bots`,
+  botsPrefix: () => "users:",
+  bot: (userName, botId) => `users:${userName}:bots:${botId}`,
+  backtestConfig: (userName, config) => `users:${userName}:backtests:configs:${config}`,
+  strategies: (userName) => `users:${userName}:strategies`,
+  strategyConfig: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:config`,
+  strategyResults: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:results`,
+  tests: (userName, strategyName) => strategyName ? `users:${userName}:tests:${strategyName}` : `users:${userName}:tests:`,
+  testOrders: (userName, strategyName, testName) => `users:${userName}:tests:${strategyName}:${testName}:orders`,
+  testConfig: (userName, strategyName, testName) => `users:${userName}:tests:${strategyName}:${testName}:config`,
+  testStat: (userName, strategyName, testName) => `users:${userName}:tests:${strategyName}:${testName}:stat`,
+  cacheChunk: (userName, chunkId) => `users:${userName}:cache:tests:chunks:${chunkId}`,
+  cacheOrders: (userName, orderLogId) => `users:${userName}:cache:tests:orders:${orderLogId}`,
+  cachePositions: (userName, orderLogId) => `users:${userName}:cache:tests:positions:${orderLogId}`,
+  signal: (symbol, signalId) => `signals:${symbol}:${signalId}`,
+  signalsBySymbol: (symbol) => `signals:${symbol}:`,
+  storeSignal: (symbol, signalId) => `store:signals:${symbol}:${signalId}`,
+  analysis: (symbol, signalId) => `analysis:${symbol}:${signalId}`,
+  backtestResults: (userName, config, timestamp) => `users:${userName}:backtests:results:${config}:${timestamp}`,
+  mlSignalsByStrategy: (strategyName) => `ml:${strategyName}:signals:`,
+  mlSignals: () => "ml:",
+  mlSignal: (strategyName, signalId) => `ml:${strategyName}:signals:${signalId}`,
+  mlResultsByStrategy: (strategyName) => `ml:${strategyName}:results:`,
+  mlResults: () => "ml:",
+  mlResult: (strategyName, signalId) => `ml:${strategyName}:results:${signalId}`
+};
+export {
+  RedisWriteBlockedError,
+  delKey,
+  delKeyWithOptions,
+  getData,
+  getKeys,
+  redisKeys,
+  setData
+};

package/dist/timescale.d.mts

@@ -0,0 +1,68 @@
+import { Pool } from 'pg';
+import { KlineChartData } from '@tradejs/types';
+
+declare global {
+    var __pgPool__: Pool | undefined;
+}
+type CandleRow = {
+    symbol: string;
+    interval: number;
+    ts: Date;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number | null;
+    turnover?: number | null;
+};
+type DerivativesInterval = '15m' | '1h';
+type DerivativesRow = {
+    symbol: string;
+    interval: DerivativesInterval;
+    ts: Date;
+    openInterest?: number | null;
+    fundingRate?: number | null;
+    liqLong?: number | null;
+    liqShort?: number | null;
+    liqTotal?: number | null;
+    source?: string | null;
+};
+type SpreadRow = {
+    symbol: string;
+    interval: DerivativesInterval;
+    ts: Date;
+    binancePrice?: number | null;
+    coinbasePrice?: number | null;
+    spread?: number | null;
+    source?: string | null;
+};
+declare const toRows: (symbol: string, interval: number, data: KlineChartData) => CandleRow[];
+declare function upsertCandles(rows: CandleRow[]): Promise<void>;
+declare function upsertDerivatives(rows: DerivativesRow[]): Promise<void>;
+declare function getDerivativesRangeForSymbols(symbols: string[], interval: DerivativesInterval, startMs: number, endMs: number): Promise<any[]>;
+declare function getDerivativesSummary(hours?: number, limit?: number): Promise<{
+    rows: any[];
+    aggregates: any[];
+    hours: number;
+}>;
+declare function upsertSpreadRows(rows: SpreadRow[]): Promise<void>;
+declare function getSpreadRangeForSymbols(symbols: string[], interval: DerivativesInterval, startMs: number, endMs: number): Promise<any[]>;
+declare function getSpreadSummary(hours?: number, limit?: number): Promise<{
+    rows: any[];
+    aggregates: any[];
+    hours: number;
+}>;
+declare function getCandlesRange(symbol: string, interval: number, startMs: number, endMs: number): Promise<any[]>;
+declare function getDataEdges(symbol: string, interval: number): Promise<{
+    min: number | undefined;
+    max: number | undefined;
+}>;
+declare function waitForDbReady(attempts?: number, delayMs?: number): Promise<void>;
+declare function deleteCandles(symbol: string, interval: number): Promise<void>;
+declare function findContinuityGap(symbol: string, interval: number): Promise<{
+    ts: number;
+    prevTs: number;
+    diffSeconds: number;
+} | null>;
+
+export { type CandleRow, type DerivativesInterval, type DerivativesRow, type SpreadRow, deleteCandles, findContinuityGap, getCandlesRange, getDataEdges, getDerivativesRangeForSymbols, getDerivativesSummary, getSpreadRangeForSymbols, getSpreadSummary, toRows, upsertCandles, upsertDerivatives, upsertSpreadRows, waitForDbReady };

package/dist/timescale.d.ts

@@ -0,0 +1,68 @@
+import { Pool } from 'pg';
+import { KlineChartData } from '@tradejs/types';
+
+declare global {
+    var __pgPool__: Pool | undefined;
+}
+type CandleRow = {
+    symbol: string;
+    interval: number;
+    ts: Date;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number | null;
+    turnover?: number | null;
+};
+type DerivativesInterval = '15m' | '1h';
+type DerivativesRow = {
+    symbol: string;
+    interval: DerivativesInterval;
+    ts: Date;
+    openInterest?: number | null;
+    fundingRate?: number | null;
+    liqLong?: number | null;
+    liqShort?: number | null;
+    liqTotal?: number | null;
+    source?: string | null;
+};
+type SpreadRow = {
+    symbol: string;
+    interval: DerivativesInterval;
+    ts: Date;
+    binancePrice?: number | null;
+    coinbasePrice?: number | null;
+    spread?: number | null;
+    source?: string | null;
+};
+declare const toRows: (symbol: string, interval: number, data: KlineChartData) => CandleRow[];
+declare function upsertCandles(rows: CandleRow[]): Promise<void>;
+declare function upsertDerivatives(rows: DerivativesRow[]): Promise<void>;
+declare function getDerivativesRangeForSymbols(symbols: string[], interval: DerivativesInterval, startMs: number, endMs: number): Promise<any[]>;
+declare function getDerivativesSummary(hours?: number, limit?: number): Promise<{
+    rows: any[];
+    aggregates: any[];
+    hours: number;
+}>;
+declare function upsertSpreadRows(rows: SpreadRow[]): Promise<void>;
+declare function getSpreadRangeForSymbols(symbols: string[], interval: DerivativesInterval, startMs: number, endMs: number): Promise<any[]>;
+declare function getSpreadSummary(hours?: number, limit?: number): Promise<{
+    rows: any[];
+    aggregates: any[];
+    hours: number;
+}>;
+declare function getCandlesRange(symbol: string, interval: number, startMs: number, endMs: number): Promise<any[]>;
+declare function getDataEdges(symbol: string, interval: number): Promise<{
+    min: number | undefined;
+    max: number | undefined;
+}>;
+declare function waitForDbReady(attempts?: number, delayMs?: number): Promise<void>;
+declare function deleteCandles(symbol: string, interval: number): Promise<void>;
+declare function findContinuityGap(symbol: string, interval: number): Promise<{
+    ts: number;
+    prevTs: number;
+    diffSeconds: number;
+} | null>;
+
+export { type CandleRow, type DerivativesInterval, type DerivativesRow, type SpreadRow, deleteCandles, findContinuityGap, getCandlesRange, getDataEdges, getDerivativesRangeForSymbols, getDerivativesSummary, getSpreadRangeForSymbols, getSpreadSummary, toRows, upsertCandles, upsertDerivatives, upsertSpreadRows, waitForDbReady };