@tradejs/app 3.0.1 → 3.1.0

package/src/app/lib/runtimeTradeSync.ts

@@ -1,280 +0,0 @@
-import { TTL_1M } from '@tradejs/core/constants';
-import { getRuntimeStorageDayKey } from '@tradejs/core/time';
-import {
-  delKey,
-  getData,
-  redisKeys,
-  setData,
-  setHashJsonField,
-} from '@tradejs/infra/redis';
-import type {
-  ClosedPnlRecord,
-  Connector,
-  PositionPnlSnapshot,
-  RuntimeTradeRecord,
-} from '@tradejs/types';
-import { takeClosedPnlMatch } from './runtimeTradeReconciliation';
-
-export type ClosedPnlRecordWithOrderLinkId = ClosedPnlRecord & {
-  orderLinkId?: string;
-};
-
-const getRuntimeTradeScopeId = (trade: RuntimeTradeRecord) =>
-  trade.deploymentId ?? trade.accountId;
-
-export const isRuntimeTradeInConnectorScope = (
-  trade: RuntimeTradeRecord,
-  connector: Connector,
-) => {
-  if (trade.deploymentId && trade.deploymentId !== connector.deploymentId) {
-    return false;
-  }
-  if (trade.deploymentId && !connector.deploymentId) {
-    return false;
-  }
-  if (trade.accountId && trade.accountId !== connector.accountId) {
-    return false;
-  }
-  if (trade.accountId && !connector.accountId) {
-    return false;
-  }
-
-  return (trade.universe ?? 'crypto') === connector.universe;
-};
-
-const buildRiskLevelsAnalysis = (position: PositionPnlSnapshot) => {
-  const takeProfitPrice =
-    typeof position.takeProfitPrice === 'number' &&
-    Number.isFinite(position.takeProfitPrice)
-      ? position.takeProfitPrice
-      : null;
-  const stopLossPrice =
-    typeof position.stopLossPrice === 'number' &&
-    Number.isFinite(position.stopLossPrice)
-      ? position.stopLossPrice
-      : null;
-
-  if (takeProfitPrice == null && stopLossPrice == null) {
-    return null;
-  }
-
-  return {
-    ...(takeProfitPrice != null ? { takeProfitPrice } : {}),
-    ...(stopLossPrice != null ? { stopLossPrice } : {}),
-  };
-};
-
-const hasExchangeCloseDetails = (trade: RuntimeTradeRecord) =>
-  trade.status === 'closed' &&
-  typeof trade.exitPrice === 'number' &&
-  Number.isFinite(trade.exitPrice) &&
-  typeof trade.actualExitPrice === 'number' &&
-  Number.isFinite(trade.actualExitPrice) &&
-  typeof trade.closedPnl === 'number' &&
-  Number.isFinite(trade.closedPnl) &&
-  typeof trade.openFee === 'number' &&
-  Number.isFinite(trade.openFee) &&
-  typeof trade.closeFee === 'number' &&
-  Number.isFinite(trade.closeFee);
-
-export const syncRuntimeTrades = async ({
-  userName,
-  connector,
-  trades,
-  endTime,
-  openPositions,
-  openPositionsReliable,
-  closedPnlRows,
-}: {
-  userName: string;
-  connector: Connector;
-  trades: RuntimeTradeRecord[];
-  endTime: number;
-  openPositions: PositionPnlSnapshot[];
-  openPositionsReliable: boolean;
-  closedPnlRows: ClosedPnlRecordWithOrderLinkId[];
-}) => {
-  const openPositionsBySymbol = new Map(
-    openPositions.map((position) => [position.symbol, position]),
-  );
-  const activeOrderIdByKey = new Map<string, string | null>();
-  const activeTradeKeys = [
-    ...new Set(
-      trades
-        .filter((trade) => isRuntimeTradeInConnectorScope(trade, connector))
-        .map((trade) =>
-          redisKeys.runtimeActiveTrade(
-            userName,
-            trade.symbol,
-            getRuntimeTradeScopeId(trade),
-          ),
-        ),
-    ),
-  ];
-
-  await Promise.all(
-    activeTradeKeys.map(async (key) => {
-      const activeRef = (await getData(key, null)) as {
-        orderId?: string;
-      } | null;
-      activeOrderIdByKey.set(
-        key,
-        typeof activeRef?.orderId === 'string' ? activeRef.orderId : null,
-      );
-    }),
-  );
-
-  const exactByOrderLinkId = new Map(
-    closedPnlRows
-      .filter(
-        (
-          row,
-        ): row is ClosedPnlRecordWithOrderLinkId & { orderLinkId: string } =>
-          typeof row.orderLinkId === 'string' && row.orderLinkId.length > 0,
-      )
-      .map((row) => [row.orderLinkId, row]),
-  );
-  const exactByOrderId = new Map(
-    closedPnlRows
-      .filter(
-        (row): row is ClosedPnlRecordWithOrderLinkId & { orderId: string } =>
-          typeof row.orderId === 'string' && row.orderId.length > 0,
-      )
-      .map((row) => [row.orderId, row]),
-  );
-  const symbolBuckets = new Map<string, ClosedPnlRecordWithOrderLinkId[]>();
-
-  for (const row of closedPnlRows) {
-    const bucket = symbolBuckets.get(row.symbol) ?? [];
-    bucket.push(row);
-    symbolBuckets.set(row.symbol, bucket);
-  }
-
-  const syncedTrades: RuntimeTradeRecord[] = [];
-
-  for (const trade of trades) {
-    if (!isRuntimeTradeInConnectorScope(trade, connector)) {
-      syncedTrades.push(trade);
-      continue;
-    }
-
-    const activeTradeKey = redisKeys.runtimeActiveTrade(
-      userName,
-      trade.symbol,
-      getRuntimeTradeScopeId(trade),
-    );
-    const isCurrentActiveTrade =
-      activeOrderIdByKey.get(activeTradeKey) === trade.orderId;
-
-    if (hasExchangeCloseDetails(trade)) {
-      if (isCurrentActiveTrade) {
-        await delKey(activeTradeKey);
-      }
-      syncedTrades.push(trade);
-      continue;
-    }
-
-    const openPosition = openPositionsBySymbol.get(trade.symbol);
-
-    if (trade.status === 'active' && !openPositionsReliable) {
-      syncedTrades.push(trade);
-      continue;
-    }
-
-    if (
-      trade.status === 'active' &&
-      isCurrentActiveTrade &&
-      openPosition &&
-      openPosition.direction === trade.direction
-    ) {
-      const riskLevelsAnalysis = buildRiskLevelsAnalysis(openPosition);
-      const nextTrade: RuntimeTradeRecord = {
-        ...trade,
-        status: 'active',
-        currentPrice: openPosition.currentPrice,
-        currentPnl: openPosition.unrealizedPnl,
-        aiAnalysis: riskLevelsAnalysis
-          ? { ...(trade.aiAnalysis ?? {}), ...riskLevelsAnalysis }
-          : trade.aiAnalysis,
-        lastSyncedAt: endTime,
-      };
-
-      await Promise.all([
-        setData(redisKeys.runtimeTrade(userName, trade.orderId), nextTrade, {
-          expire: 0,
-        }),
-        setHashJsonField(
-          redisKeys.runtimeTradeBucket(
-            userName,
-            getRuntimeStorageDayKey(trade.entryTimestamp),
-          ),
-          trade.orderId,
-          nextTrade,
-          { expire: 0 },
-        ),
-      ]);
-      syncedTrades.push(nextTrade);
-      continue;
-    }
-
-    const matchedClosedPnl = takeClosedPnlMatch({
-      exactByOrderLinkId,
-      exactByOrderId,
-      symbolBuckets,
-      trade,
-    });
-
-    if (!matchedClosedPnl) {
-      syncedTrades.push(trade);
-      continue;
-    }
-
-    const nextTrade: RuntimeTradeRecord = {
-      ...trade,
-      status: 'closed',
-      currentPrice: matchedClosedPnl.exitPrice ?? trade.currentPrice ?? null,
-      currentPnl: matchedClosedPnl.closedPnl,
-      closedPnl: matchedClosedPnl.closedPnl,
-      actualEntryPrice:
-        matchedClosedPnl.entryPrice ?? trade.actualEntryPrice ?? null,
-      exitPrice: matchedClosedPnl.exitPrice ?? trade.exitPrice ?? null,
-      actualExitPrice:
-        matchedClosedPnl.exitPrice ?? trade.actualExitPrice ?? null,
-      exitTimestamp: matchedClosedPnl.closedAt,
-      exitType: trade.exitType ?? null,
-      openFee: matchedClosedPnl.openFee ?? trade.openFee ?? null,
-      closeFee: matchedClosedPnl.closeFee ?? trade.closeFee ?? null,
-      fundingFee: matchedClosedPnl.fundingFee ?? trade.fundingFee ?? null,
-      totalFee: matchedClosedPnl.totalFee ?? trade.totalFee ?? null,
-      lastSyncedAt: endTime,
-    };
-
-    await Promise.all([
-      setData(redisKeys.runtimeTrade(userName, trade.orderId), nextTrade, {
-        expire: TTL_1M,
-      }),
-      setHashJsonField(
-        redisKeys.runtimeTradeBucket(
-          userName,
-          getRuntimeStorageDayKey(trade.entryTimestamp),
-        ),
-        trade.orderId,
-        nextTrade,
-        { expire: TTL_1M },
-      ),
-      setHashJsonField(
-        redisKeys.runtimeClosedTradeBucket(
-          userName,
-          getRuntimeStorageDayKey(nextTrade.exitTimestamp!),
-        ),
-        trade.orderId,
-        nextTrade,
-        { expire: TTL_1M },
-      ),
-      ...(isCurrentActiveTrade ? [delKey(activeTradeKey)] : []),
-    ]);
-    syncedTrades.push(nextTrade);
-  }
-
-  return syncedTrades;
-};

package/src/app/lib/strategyEvidenceTimeline.ts

@@ -1,298 +0,0 @@
-import type { Dirent } from 'node:fs';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import {
-  canonicalStrategyEvidenceJson,
-  safeStrategyEvidenceSegment,
-  verifyStrategyEvidenceMarkerEnvelope,
-} from '@tradejs/infra/strategyReleaseEvidence';
-import {
-  type StrategyEvidenceMarker,
-  type StrategyEvidenceMarkerEnvelope,
-  type StrategyEvidenceTimeline,
-  type StrategyEvidenceTimelineSelector,
-} from '@tradejs/types';
-
-const DEFAULT_MARKER_DIRECTORY = 'data/strategy-release/markers';
-type JsonRecord = Record<string, unknown>;
-
-const asRecord = (value: unknown): JsonRecord | null =>
-  value && typeof value === 'object' && !Array.isArray(value)
-    ? (value as JsonRecord)
-    : null;
-
-const isNonEmptyString = (value: unknown): value is string =>
-  typeof value === 'string' && value.trim().length > 0;
-
-export { canonicalStrategyEvidenceJson, verifyStrategyEvidenceMarkerEnvelope };
-
-export const strategyEvidenceTimelineSelectorKey = (
-  selector: StrategyEvidenceTimelineSelector,
-) =>
-  [
-    selector.strategy,
-    selector.compositionId ?? '',
-    selector.gitSha ?? '',
-    selector.gateFingerprint ?? '',
-    selector.configFingerprint ?? '',
-    selector.contextFingerprint ?? '',
-    selector.requireCompleteLineage ? 'exact' : 'partial',
-  ].join(':');
-
-const discoverJsonFiles = async (rootDir: string): Promise<string[]> => {
-  const files: string[] = [];
-
-  const visit = async (directory: string, depth: number): Promise<void> => {
-    if (depth > 12) return;
-
-    let entries: Dirent[];
-    try {
-      entries = await fs.readdir(directory, { withFileTypes: true });
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') return;
-      throw error;
-    }
-
-    await Promise.all(
-      entries.map(async (entry) => {
-        if (entry.name.startsWith('.') || entry.name.includes('.tmp-')) return;
-        const entryPath = path.join(directory, entry.name);
-        if (entry.isDirectory()) {
-          await visit(entryPath, depth + 1);
-        } else if (entry.isFile() && entry.name.endsWith('.json')) {
-          files.push(entryPath);
-        }
-      }),
-    );
-  };
-
-  await visit(rootDir, 0);
-  return files.sort();
-};
-
-const inferMatchingStrategies = ({
-  filePath,
-  rootDir,
-  parsed,
-  strategies,
-}: {
-  filePath: string;
-  rootDir: string;
-  parsed: unknown;
-  strategies: string[];
-}) => {
-  const payload = asRecord(asRecord(parsed)?.payload);
-  const declaredStrategy = isNonEmptyString(payload?.strategy)
-    ? payload.strategy
-    : null;
-  const directoryStrategy = path.relative(rootDir, filePath).split(path.sep)[0];
-  return strategies.filter(
-    (strategy) =>
-      strategy === declaredStrategy ||
-      directoryStrategy === safeStrategyEvidenceSegment(strategy),
-  );
-};
-
-const missingTimeline = (): StrategyEvidenceTimeline => ({
-  status: 'missing',
-  observedFrom: null,
-  markers: [],
-});
-
-const invalidTimeline = (): StrategyEvidenceTimeline => ({
-  status: 'invalid',
-  observedFrom: null,
-  markers: [],
-});
-
-export const loadStrategyEvidenceTimelines = async ({
-  projectRoot,
-  markerDir,
-  selectors: requestedSelectors,
-  startTime,
-  endTime,
-}: {
-  projectRoot: string;
-  markerDir?: string | null;
-  selectors: Iterable<StrategyEvidenceTimelineSelector>;
-  startTime: number;
-  endTime: number;
-}): Promise<Map<string, StrategyEvidenceTimeline>> => {
-  const selectors = [...requestedSelectors]
-    .filter((selector) => selector.strategy.trim().length > 0)
-    .sort((left, right) =>
-      strategyEvidenceTimelineSelectorKey(left).localeCompare(
-        strategyEvidenceTimelineSelectorKey(right),
-      ),
-    );
-  const strategies = [...new Set(selectors.map(({ strategy }) => strategy))];
-  const timelines = new Map(
-    selectors.map((selector) => [
-      strategyEvidenceTimelineSelectorKey(selector),
-      missingTimeline(),
-    ]),
-  );
-  if (!selectors.length) return timelines;
-
-  const configuredDir = markerDir?.trim() || DEFAULT_MARKER_DIRECTORY;
-  const rootDir = path.isAbsolute(configuredDir)
-    ? configuredDir
-    : path.resolve(projectRoot, configuredDir);
-  let files: string[];
-  try {
-    files = await discoverJsonFiles(rootDir);
-  } catch {
-    for (const selector of selectors) {
-      timelines.set(
-        strategyEvidenceTimelineSelectorKey(selector),
-        invalidTimeline(),
-      );
-    }
-    return timelines;
-  }
-
-  const envelopesByStrategy = new Map<
-    string,
-    StrategyEvidenceMarkerEnvelope[]
-  >();
-  const invalidStrategies = new Set<string>();
-
-  for (const filePath of files) {
-    let parsed: unknown = null;
-    try {
-      parsed = JSON.parse(await fs.readFile(filePath, 'utf8')) as unknown;
-    } catch {
-      for (const strategy of inferMatchingStrategies({
-        filePath,
-        rootDir,
-        parsed,
-        strategies,
-      })) {
-        invalidStrategies.add(strategy);
-      }
-      continue;
-    }
-
-    const matchingStrategies = inferMatchingStrategies({
-      filePath,
-      rootDir,
-      parsed,
-      strategies,
-    });
-    if (!matchingStrategies.length) continue;
-
-    try {
-      const envelope = verifyStrategyEvidenceMarkerEnvelope(parsed);
-      for (const strategy of matchingStrategies) {
-        if (strategy !== envelope.payload.strategy) {
-          invalidStrategies.add(strategy);
-        }
-      }
-      if (!strategies.includes(envelope.payload.strategy)) {
-        continue;
-      }
-      const envelopes =
-        envelopesByStrategy.get(envelope.payload.strategy) ?? [];
-      envelopes.push(envelope);
-      envelopesByStrategy.set(envelope.payload.strategy, envelopes);
-    } catch {
-      for (const strategy of matchingStrategies) {
-        invalidStrategies.add(strategy);
-      }
-    }
-  }
-
-  for (const selector of selectors) {
-    const strategy = selector.strategy;
-    const selectorKey = strategyEvidenceTimelineSelectorKey(selector);
-    if (invalidStrategies.has(strategy)) {
-      timelines.set(selectorKey, invalidTimeline());
-      continue;
-    }
-
-    const envelopes = envelopesByStrategy.get(strategy) ?? [];
-    if (!envelopes.length) continue;
-    const hasCompleteSelector =
-      Boolean(selector.compositionId) &&
-      Boolean(selector.gitSha) &&
-      Boolean(selector.gateFingerprint) &&
-      Boolean(selector.configFingerprint) &&
-      Boolean(selector.contextFingerprint);
-    if (selector.requireCompleteLineage && !hasCompleteSelector) continue;
-
-    const markersById = new Map<string, StrategyEvidenceMarker>();
-    let hasConflict = false;
-    for (const envelope of envelopes) {
-      for (const marker of envelope.payload.markers) {
-        const existing = markersById.get(marker.id);
-        if (
-          existing &&
-          canonicalStrategyEvidenceJson(existing) !==
-            canonicalStrategyEvidenceJson(marker)
-        ) {
-          hasConflict = true;
-          break;
-        }
-        markersById.set(marker.id, marker);
-      }
-      if (hasConflict) break;
-    }
-
-    if (hasConflict) {
-      timelines.set(selectorKey, invalidTimeline());
-      continue;
-    }
-
-    const matchingMarkers = [...markersById.values()]
-      .filter(
-        (marker) =>
-          (!selector.compositionId ||
-            marker.compositionId === selector.compositionId) &&
-          (!selector.gitSha || marker.gitSha === selector.gitSha) &&
-          (!selector.gateFingerprint ||
-            marker.gateFingerprint === selector.gateFingerprint) &&
-          (!selector.configFingerprint ||
-            marker.configFingerprint === selector.configFingerprint) &&
-          (!selector.contextFingerprint ||
-            marker.contextFingerprint === selector.contextFingerprint) &&
-          marker.timestamp >= startTime &&
-          marker.timestamp < endTime,
-      )
-      .sort(
-        (left, right) =>
-          left.timestamp - right.timestamp ||
-          left.type.localeCompare(right.type) ||
-          left.id.localeCompare(right.id),
-      );
-    let lastLossValue: number | null | undefined;
-    let hasLastLossValue = false;
-    const markers = matchingMarkers.filter((marker) => {
-      if (marker.type !== 'L') return true;
-      if (hasLastLossValue && marker.maxLossValue === lastLossValue) {
-        return false;
-      }
-      hasLastLossValue = true;
-      lastLossValue = marker.maxLossValue;
-      return true;
-    });
-    if (
-      !markers.length &&
-      (selector.compositionId ||
-        selector.gitSha ||
-        selector.gateFingerprint ||
-        selector.configFingerprint ||
-        selector.contextFingerprint)
-    ) {
-      continue;
-    }
-    timelines.set(selectorKey, {
-      status: 'verified',
-      observedFrom: markers.length
-        ? Math.min(...markers.map((marker) => marker.timestamp))
-        : Math.min(...envelopes.map((envelope) => envelope.payload.createdAt)),
-      markers,
-    });
-  }
-
-  return timelines;
-};