@tradejs/app 2.0.17 → 2.0.19

package/src/app/lib/runtimeStrategyConfigService.ts

@@ -0,0 +1,279 @@
+import {
+  loadRuntimeStrategyConfigs,
+  saveRuntimeStrategyConfig,
+  type RuntimeStrategyConfigRecord,
+} from '@tradejs/infra/runtimeStrategyConfigs';
+import {
+  listTradingAccounts,
+  resolveTradingAccount,
+} from '@tradejs/infra/tradingAccounts';
+import { getAvailableStrategyNames } from '@tradejs/node/strategies';
+import type { Interval, MarketUniverse, StrategyConfig } from '@tradejs/types';
+
+export const RUNTIME_STRATEGY_INTERVALS = [
+  '1',
+  '3',
+  '5',
+  '15',
+  '30',
+  '60',
+  '120',
+  '240',
+  '360',
+  '720',
+  '1440',
+] as const;
+
+const intervalSet = new Set<string>(RUNTIME_STRATEGY_INTERVALS);
+
+export class RuntimeStrategyConfigServiceError extends Error {
+  constructor(
+    message: string,
+    readonly code: 'conflict' | 'not_found' | 'validation' = 'validation',
+  ) {
+    super(message);
+    this.name = 'RuntimeStrategyConfigServiceError';
+  }
+}
+
+type StoredRuntimeConfig = RuntimeStrategyConfigRecord & {
+  config: StrategyConfig;
+};
+
+export interface SaveRuntimeStrategyConfigInput {
+  strategyName?: unknown;
+  configId?: unknown;
+  interval?: unknown;
+  universe?: unknown;
+  accountId?: unknown;
+  enabled?: unknown;
+  parameters?: unknown;
+}
+
+const loadConfigs = async (userName: string): Promise<StoredRuntimeConfig[]> =>
+  (await loadRuntimeStrategyConfigs(userName)).map(
+    ({ strategyConfig, ...record }) => ({
+      ...record,
+      strategyConfig,
+      config: strategyConfig,
+    }),
+  );
+
+const normalizeConfigId = (value: unknown) => {
+  const configId = String(value ?? '').trim();
+  if (!configId)
+    throw new RuntimeStrategyConfigServiceError('Config id is required');
+  if (!/^[a-zA-Z0-9_-]+$/.test(configId)) {
+    throw new RuntimeStrategyConfigServiceError(
+      'Config id may contain only letters, numbers, _ and -',
+    );
+  }
+  if (configId === 'results') {
+    throw new RuntimeStrategyConfigServiceError(
+      'Config id "results" is reserved',
+    );
+  }
+  return configId;
+};
+
+const normalizeUniverse = (value: unknown): MarketUniverse =>
+  value === 'tradfi' ? 'tradfi' : 'crypto';
+
+const normalizeInterval = (value: unknown): Interval => {
+  const interval = String(value ?? '15');
+  if (!intervalSet.has(interval)) {
+    throw new RuntimeStrategyConfigServiceError(
+      `Unsupported timeframe: ${interval}`,
+    );
+  }
+  return interval as Interval;
+};
+
+const normalizeAccountId = (value: unknown) => {
+  const accountId = String(value ?? '').trim();
+  return accountId || undefined;
+};
+
+const resolveEffectiveAccountId = async ({
+  userName,
+  config,
+}: {
+  userName: string;
+  config: StrategyConfig;
+}) => {
+  const universe = normalizeUniverse(config.UNIVERSE);
+  const account = await resolveTradingAccount({
+    userName,
+    accountId: normalizeAccountId(config.ACCOUNT_ID),
+    provider: 'bybit',
+    universe,
+  });
+  return account?.id ?? null;
+};
+
+const assertNoEnabledAccountConflict = async ({
+  userName,
+  strategyName,
+  configId,
+  config,
+  existingConfigs,
+}: {
+  userName: string;
+  strategyName: string;
+  configId: string;
+  config: StrategyConfig;
+  existingConfigs: StoredRuntimeConfig[];
+}) => {
+  if (config.ENABLE === false) return;
+
+  const accountId = await resolveEffectiveAccountId({ userName, config });
+  if (!accountId) {
+    throw new RuntimeStrategyConfigServiceError(
+      `No enabled Bybit account supports ${normalizeUniverse(config.UNIVERSE)}. Connect an account or save this config as disabled.`,
+    );
+  }
+
+  for (const candidate of existingConfigs) {
+    if (
+      candidate.strategyName !== strategyName ||
+      candidate.configId === configId ||
+      candidate.config.ENABLE === false
+    ) {
+      continue;
+    }
+
+    const candidateAccountId = await resolveEffectiveAccountId({
+      userName,
+      config: candidate.config,
+    });
+    if (candidateAccountId === accountId) {
+      throw new RuntimeStrategyConfigServiceError(
+        `${strategyName} config "${candidate.configId}" already uses account "${accountId}". One strategy can run only once per account.`,
+        'conflict',
+      );
+    }
+  }
+};
+
+const toResponseConfig = async (
+  userName: string,
+  row: StoredRuntimeConfig,
+) => ({
+  strategyName: row.strategyName,
+  configId: row.configId,
+  interval: normalizeInterval(row.config.INTERVAL),
+  universe: normalizeUniverse(row.config.UNIVERSE),
+  accountId: normalizeAccountId(row.config.ACCOUNT_ID) ?? null,
+  effectiveAccountId: await resolveEffectiveAccountId({
+    userName,
+    config: row.config,
+  }).catch(() => null),
+  enabled: row.config.ENABLE !== false,
+  config: row.config,
+});
+
+export const getRuntimeStrategyConfigOptions = async ({
+  userName,
+  projectRoot,
+}: {
+  userName: string;
+  projectRoot: string;
+}) => {
+  const [configs, strategyNames, accounts] = await Promise.all([
+    loadConfigs(userName),
+    getAvailableStrategyNames(projectRoot),
+    listTradingAccounts(userName),
+  ]);
+
+  return {
+    configs: await Promise.all(
+      configs.map((row) => toResponseConfig(userName, row)),
+    ),
+    strategyNames,
+    accounts: accounts.map(
+      ({ apiKey: _apiKey, apiSecret: _apiSecret, ...account }) => account,
+    ),
+    intervals: [...RUNTIME_STRATEGY_INTERVALS],
+  };
+};
+
+export const saveRuntimeStrategyConfigForUser = async ({
+  userName,
+  projectRoot,
+  input,
+  editing,
+}: {
+  userName: string;
+  projectRoot: string;
+  input: SaveRuntimeStrategyConfigInput;
+  editing: boolean;
+}) => {
+  const strategyName = String(input.strategyName ?? '').trim();
+  const configId = normalizeConfigId(input.configId);
+  const availableStrategies = await getAvailableStrategyNames(projectRoot);
+  if (!strategyName || !availableStrategies.includes(strategyName)) {
+    throw new RuntimeStrategyConfigServiceError(
+      `Unknown strategy: ${strategyName || '(empty)'}`,
+    );
+  }
+
+  const existingConfigs = await loadConfigs(userName);
+  const existing = existingConfigs.find(
+    (row) => row.strategyName === strategyName && row.configId === configId,
+  );
+  if (editing && !existing) {
+    throw new RuntimeStrategyConfigServiceError(
+      'Runtime strategy config not found',
+      'not_found',
+    );
+  }
+  if (!editing && existing) {
+    throw new RuntimeStrategyConfigServiceError(
+      'Runtime strategy config already exists',
+      'conflict',
+    );
+  }
+
+  if (
+    !input.parameters ||
+    typeof input.parameters !== 'object' ||
+    Array.isArray(input.parameters)
+  ) {
+    throw new RuntimeStrategyConfigServiceError(
+      'Strategy parameters must be a JSON object',
+    );
+  }
+
+  const interval = normalizeInterval(input.interval);
+  const universe = normalizeUniverse(input.universe);
+  const accountId = normalizeAccountId(input.accountId);
+  const config: StrategyConfig = {
+    ...(input.parameters as StrategyConfig),
+    ENABLE: input.enabled !== false,
+    INTERVAL: interval,
+    UNIVERSE: universe,
+  };
+  if (accountId) config.ACCOUNT_ID = accountId;
+  else delete config.ACCOUNT_ID;
+
+  await assertNoEnabledAccountConflict({
+    userName,
+    strategyName,
+    configId,
+    config,
+    existingConfigs,
+  });
+  const saved = await saveRuntimeStrategyConfig({
+    userName,
+    strategyName,
+    configId,
+    strategyConfig: config,
+  });
+
+  return {
+    config: await toResponseConfig(userName, {
+      ...saved,
+      config,
+    }),
+  };
+};

package/src/app/lib/runtimeStrategyLineage.ts

@@ -0,0 +1,264 @@
+import type {
+  MarketUniverse,
+  RuntimeLineage,
+  RuntimeTradeRecord,
+} from '@tradejs/types';
+
+export interface RuntimeStrategyLineageScope {
+  strategy: string;
+  symbol: string;
+  runtimeConfigId?: string;
+  lineage: RuntimeLineage & { maxLossValue?: number | null };
+  firstTimestamp: number;
+  lastTimestamp: number;
+}
+
+export interface RuntimeStrategyAiGateChange {
+  timestamp: number;
+  previousFingerprint: string;
+  fingerprint: string;
+}
+
+export interface RuntimeStrategyMaxLossValueChange {
+  timestamp: number;
+  previousValue: number;
+  value: number;
+}
+
+export interface RuntimeStrategyMaxLossValueTimeline {
+  observedFrom: number | null;
+  initialValue: number | null;
+  changes: RuntimeStrategyMaxLossValueChange[];
+}
+
+export interface RuntimeStrategyAccountScope {
+  strategyName: string;
+  configId: string;
+  universe: MarketUniverse;
+  accountId?: string;
+}
+
+export const buildRuntimeStrategyIdentityKey = ({
+  strategyName,
+  configId,
+  universe,
+  accountId,
+  deploymentId,
+  policyProfileId,
+}: {
+  strategyName: string;
+  configId?: string;
+  universe?: MarketUniverse;
+  accountId?: string;
+  deploymentId?: string;
+  policyProfileId?: string;
+}) =>
+  [
+    strategyName,
+    configId ?? 'config',
+    universe ?? 'crypto',
+    accountId ?? 'default',
+    deploymentId ?? 'default',
+    policyProfileId ?? 'default',
+  ].join(':');
+
+export const assignLegacyRuntimeTradeAccountScopes = (
+  trades: RuntimeTradeRecord[],
+  scopes: RuntimeStrategyAccountScope[],
+): RuntimeTradeRecord[] =>
+  trades.map((trade) => {
+    if (trade.accountId || trade.deploymentId) return trade;
+    const matchingAccountIds = new Set(
+      scopes
+        .filter(
+          (scope) =>
+            scope.strategyName === trade.strategy &&
+            scope.configId === (trade.runtimeConfigId ?? 'config') &&
+            scope.universe === (trade.universe ?? 'crypto'),
+        )
+        .map((scope) => scope.accountId)
+        .filter((accountId): accountId is string => Boolean(accountId)),
+    );
+    return matchingAccountIds.size === 1
+      ? { ...trade, accountId: [...matchingAccountIds][0] }
+      : trade;
+  });
+
+export const getRuntimeStrategyAiGateObservedFrom = ({
+  scopes,
+  strategyName,
+  configId,
+  endTime,
+}: {
+  scopes: RuntimeStrategyLineageScope[];
+  strategyName: string;
+  configId?: string;
+  endTime: number;
+}) => {
+  const normalizedConfigId = configId ?? 'config';
+  let observedFrom: number | null = null;
+  for (const scope of scopes) {
+    if (
+      scope.strategy !== strategyName ||
+      (scope.runtimeConfigId ?? 'config') !== normalizedConfigId ||
+      scope.firstTimestamp > endTime
+    ) {
+      continue;
+    }
+    observedFrom =
+      observedFrom == null
+        ? scope.firstTimestamp
+        : Math.min(observedFrom, scope.firstTimestamp);
+  }
+  return observedFrom;
+};
+
+export const buildRuntimeStrategyMaxLossValueTimeline = ({
+  scopes,
+  strategyName,
+  configId,
+  startTime,
+  endTime,
+}: {
+  scopes: RuntimeStrategyLineageScope[];
+  strategyName: string;
+  configId?: string;
+  startTime: number;
+  endTime: number;
+}): RuntimeStrategyMaxLossValueTimeline => {
+  const normalizedConfigId = configId ?? 'config';
+  const observationsByTimestamp = new Map<
+    number,
+    { value: number; lastTimestamp: number }
+  >();
+  for (const scope of scopes) {
+    const value = scope.lineage.maxLossValue;
+    if (
+      scope.strategy !== strategyName ||
+      (scope.runtimeConfigId ?? 'config') !== normalizedConfigId ||
+      scope.firstTimestamp > endTime ||
+      typeof value !== 'number' ||
+      !Number.isFinite(value)
+    ) {
+      continue;
+    }
+    const existing = observationsByTimestamp.get(scope.firstTimestamp);
+    if (
+      !existing ||
+      scope.lastTimestamp > existing.lastTimestamp ||
+      (scope.lastTimestamp === existing.lastTimestamp && value > existing.value)
+    ) {
+      observationsByTimestamp.set(scope.firstTimestamp, {
+        value,
+        lastTimestamp: scope.lastTimestamp,
+      });
+    }
+  }
+
+  const changes: RuntimeStrategyMaxLossValueChange[] = [];
+  let observedFrom: number | null = null;
+  let initialValue: number | null = null;
+  let currentValue: number | null = null;
+  for (const [timestamp, observation] of [
+    ...observationsByTimestamp.entries(),
+  ].sort(([left], [right]) => left - right)) {
+    if (currentValue == null) {
+      observedFrom = timestamp;
+      initialValue = observation.value;
+      currentValue = observation.value;
+      continue;
+    }
+    if (observation.value === currentValue) continue;
+    if (timestamp >= startTime) {
+      changes.push({
+        timestamp,
+        previousValue: currentValue,
+        value: observation.value,
+      });
+    }
+    currentValue = observation.value;
+  }
+  return { observedFrom, initialValue, changes };
+};
+
+export const isRuntimeStrategyLineageScope = (
+  value: unknown,
+): value is RuntimeStrategyLineageScope => {
+  if (!value || typeof value !== 'object') return false;
+  const record = value as Record<string, unknown>;
+  const lineage = record.lineage as Record<string, unknown> | undefined;
+  return (
+    typeof record.strategy === 'string' &&
+    typeof record.symbol === 'string' &&
+    typeof record.firstTimestamp === 'number' &&
+    Number.isFinite(record.firstTimestamp) &&
+    typeof record.lastTimestamp === 'number' &&
+    Number.isFinite(record.lastTimestamp) &&
+    lineage != null &&
+    typeof lineage.gateFingerprint === 'string' &&
+    lineage.gateFingerprint.trim().length > 0
+  );
+};
+
+export const buildRuntimeStrategyAiGateChanges = ({
+  scopes,
+  strategyName,
+  configId,
+  startTime,
+  endTime,
+}: {
+  scopes: RuntimeStrategyLineageScope[];
+  strategyName: string;
+  configId?: string;
+  startTime: number;
+  endTime: number;
+}): RuntimeStrategyAiGateChange[] => {
+  const normalizedConfigId = configId ?? 'config';
+  const observationsByTimestamp = new Map<
+    number,
+    { fingerprint: string; lastTimestamp: number }
+  >();
+  for (const scope of scopes) {
+    if (
+      scope.strategy !== strategyName ||
+      (scope.runtimeConfigId ?? 'config') !== normalizedConfigId ||
+      scope.firstTimestamp > endTime
+    ) {
+      continue;
+    }
+    const fingerprint = scope.lineage.gateFingerprint.trim();
+    const existing = observationsByTimestamp.get(scope.firstTimestamp);
+    if (
+      !existing ||
+      scope.lastTimestamp > existing.lastTimestamp ||
+      (scope.lastTimestamp === existing.lastTimestamp &&
+        fingerprint > existing.fingerprint)
+    ) {
+      observationsByTimestamp.set(scope.firstTimestamp, {
+        fingerprint,
+        lastTimestamp: scope.lastTimestamp,
+      });
+    }
+  }
+
+  const changes: RuntimeStrategyAiGateChange[] = [];
+  let currentFingerprint: string | null = null;
+  for (const [timestamp, observation] of [
+    ...observationsByTimestamp.entries(),
+  ].sort(([left], [right]) => left - right)) {
+    if (currentFingerprint == null) {
+      currentFingerprint = observation.fingerprint;
+      continue;
+    }
+    if (observation.fingerprint === currentFingerprint) continue;
+    if (timestamp >= startTime) {
+      changes.push({
+        timestamp,
+        previousFingerprint: currentFingerprint,
+        fingerprint: observation.fingerprint,
+      });
+    }
+    currentFingerprint = observation.fingerprint;
+  }
+  return changes;
+};

package/src/app/lib/runtimeTradeReconciliation.ts

@@ -0,0 +1,113 @@
+import type { ClosedPnlRecord, RuntimeTradeRecord } from '@tradejs/types';
+
+export type ClosedPnlRecordWithOrderLinkId = ClosedPnlRecord & {
+  direction?: RuntimeTradeRecord['direction'];
+  entryTimestamp?: number;
+  orderLinkId?: string;
+};
+
+const toNonEmptyString = (value: unknown) =>
+  typeof value === 'string' && value.trim() ? value.trim() : null;
+
+const removeFromExactMaps = ({
+  exactByOrderLinkId,
+  exactByOrderId,
+  row,
+}: {
+  exactByOrderLinkId: Map<string, ClosedPnlRecordWithOrderLinkId>;
+  exactByOrderId: Map<string, ClosedPnlRecordWithOrderLinkId>;
+  row: ClosedPnlRecordWithOrderLinkId;
+}) => {
+  for (const [key, value] of exactByOrderLinkId) {
+    if (value === row) exactByOrderLinkId.delete(key);
+  }
+  for (const [key, value] of exactByOrderId) {
+    if (value === row) exactByOrderId.delete(key);
+  }
+};
+
+const removeFromSymbolBuckets = (
+  buckets: Map<string, ClosedPnlRecordWithOrderLinkId[]>,
+  row: ClosedPnlRecordWithOrderLinkId,
+) => {
+  const rows = buckets.get(row.symbol);
+  const index = rows?.findIndex((candidate) => candidate === row) ?? -1;
+  if (index >= 0) rows?.splice(index, 1);
+};
+
+export const takeExactClosedPnlMatch = ({
+  exactByOrderLinkId,
+  exactByOrderId,
+  symbolBuckets,
+  orderLinkId,
+  orderId,
+}: {
+  exactByOrderLinkId: Map<string, ClosedPnlRecordWithOrderLinkId>;
+  exactByOrderId: Map<string, ClosedPnlRecordWithOrderLinkId>;
+  symbolBuckets: Map<string, ClosedPnlRecordWithOrderLinkId[]>;
+  orderLinkId?: string | null;
+  orderId?: string | null;
+}) => {
+  const exactKeys: Array<
+    [Map<string, ClosedPnlRecordWithOrderLinkId>, string | null | undefined]
+  > = [
+    [exactByOrderLinkId, orderLinkId],
+    [exactByOrderId, orderId],
+  ];
+  for (const [bucket, key] of exactKeys) {
+    const normalizedKey = toNonEmptyString(key);
+    if (!normalizedKey) continue;
+    const exactMatch = bucket.get(normalizedKey);
+    if (!exactMatch) continue;
+    removeFromExactMaps({
+      exactByOrderLinkId,
+      exactByOrderId,
+      row: exactMatch,
+    });
+    removeFromSymbolBuckets(symbolBuckets, exactMatch);
+    return exactMatch;
+  }
+  return null;
+};
+
+export const takeClosedPnlMatch = ({
+  exactByOrderLinkId,
+  exactByOrderId = new Map<string, ClosedPnlRecordWithOrderLinkId>(),
+  symbolBuckets,
+  trade,
+}: {
+  exactByOrderLinkId: Map<string, ClosedPnlRecordWithOrderLinkId>;
+  exactByOrderId?: Map<string, ClosedPnlRecordWithOrderLinkId>;
+  symbolBuckets: Map<string, ClosedPnlRecordWithOrderLinkId[]>;
+  trade: RuntimeTradeRecord;
+}) => {
+  const exactMatch = takeExactClosedPnlMatch({
+    exactByOrderLinkId,
+    exactByOrderId,
+    symbolBuckets,
+    orderLinkId: trade.orderId,
+    orderId: trade.orderId,
+  });
+  if (exactMatch) return exactMatch;
+
+  const rows = symbolBuckets.get(trade.symbol);
+  if (!rows?.length) return null;
+  const minimumClosedAt = trade.entryTimestamp - 5 * 60_000;
+  const matchIndex = rows.reduce((bestIndex, row, index) => {
+    if (
+      !Number.isFinite(row.closedAt) ||
+      row.closedAt < minimumClosedAt ||
+      (row.direction && row.direction !== trade.direction)
+    ) {
+      return bestIndex;
+    }
+    if (bestIndex < 0) return index;
+    return row.closedAt < rows[bestIndex].closedAt ? index : bestIndex;
+  }, -1);
+  if (matchIndex < 0) return null;
+  const [row] = rows.splice(matchIndex, 1);
+  if (row) {
+    removeFromExactMaps({ exactByOrderLinkId, exactByOrderId, row });
+  }
+  return row ?? null;
+};

package/src/app/lib/runtimeTradeSync.ts

@@ -13,7 +13,7 @@ import type {
   PositionPnlSnapshot,
   RuntimeTradeRecord,
 } from '@tradejs/types';
-import { takeClosedPnlMatch } from './runtimeStrategies';
+import { takeClosedPnlMatch } from './runtimeTradeReconciliation';
 
 export type ClosedPnlRecordWithOrderLinkId = ClosedPnlRecord & {
   orderLinkId?: string;