@tradejs/app 1.0.8 → 1.0.10

package/src/app/api/user/runtime-deployments/[deploymentId]/route.ts

@@ -0,0 +1,25 @@
+import { NextResponse } from 'next/server';
+import {
+  deleteRuntimeDeployment,
+  getRuntimeDeployment,
+} from '@tradejs/infra/tradingAccounts';
+import { getCurrentUserName } from '#app/lib/currentUser';
+
+export const DELETE = async (
+  _request: Request,
+  { params }: { params: Promise<{ deploymentId: string }> },
+) => {
+  const userName = await getCurrentUserName();
+  if (!userName) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+  const { deploymentId } = await params;
+  if (!(await getRuntimeDeployment(userName, deploymentId))) {
+    return NextResponse.json(
+      { error: 'Deployment not found' },
+      { status: 404 },
+    );
+  }
+  await deleteRuntimeDeployment(userName, deploymentId);
+  return NextResponse.json({ deleted: true });
+};

package/src/app/api/user/runtime-deployments/route.ts

@@ -0,0 +1,94 @@
+import { NextRequest, NextResponse } from 'next/server';
+import {
+  getTradingAccount,
+  getRuntimeDeploymentHeartbeat,
+  listRuntimeDeployments,
+  saveRuntimeDeployment,
+} from '@tradejs/infra/tradingAccounts';
+import { isMarketUniverse, type RuntimeDeployment } from '@tradejs/types';
+import { getCurrentUserName } from '#app/lib/currentUser';
+
+export const dynamic = 'force-dynamic';
+
+export const GET = async () => {
+  const userName = await getCurrentUserName();
+  if (!userName) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+  const deployments = await listRuntimeDeployments(userName);
+  const withHeartbeats = await Promise.all(
+    deployments.map(async (deployment) => ({
+      ...deployment,
+      heartbeat: await getRuntimeDeploymentHeartbeat(userName, deployment.id),
+    })),
+  );
+  return NextResponse.json({ deployments: withHeartbeats });
+};
+
+export const POST = async (request: NextRequest) => {
+  const userName = await getCurrentUserName();
+  if (!userName) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+  try {
+    const body = (await request.json()) as Partial<RuntimeDeployment>;
+    const universe = body.universe;
+    if (
+      !body.id ||
+      !body.label ||
+      !body.connectorName ||
+      !body.provider ||
+      !body.accountId ||
+      !body.interval ||
+      !isMarketUniverse(universe) ||
+      !Array.isArray(body.strategies) ||
+      !body.strategies.length ||
+      body.strategies.some(
+        (strategy) =>
+          !String(strategy.strategyName ?? '').trim() ||
+          !String(strategy.policyProfileId ?? '').trim(),
+      )
+    ) {
+      return NextResponse.json(
+        { error: 'Invalid runtime deployment' },
+        { status: 400 },
+      );
+    }
+    const account = await getTradingAccount(userName, body.accountId);
+    if (
+      !account ||
+      !account.enabled ||
+      account.provider !== body.provider.toLowerCase()
+    ) {
+      return NextResponse.json(
+        { error: 'Deployment trading account is unavailable' },
+        { status: 400 },
+      );
+    }
+    if (!account.universes.includes(universe)) {
+      return NextResponse.json(
+        { error: `Account ${account.id} does not support ${universe}` },
+        { status: 400 },
+      );
+    }
+    const deployment = await saveRuntimeDeployment(userName, {
+      id: body.id,
+      label: body.label,
+      connectorName: body.connectorName,
+      provider: body.provider,
+      accountId: body.accountId,
+      universe,
+      interval: String(body.interval),
+      enabled: body.enabled !== false,
+      strategies: body.strategies,
+      assetClasses: body.assetClasses,
+      tickers: body.tickers,
+    });
+    return NextResponse.json({ deployment });
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : String(error) },
+      { status: 400 },
+    );
+  }
+};

package/src/app/api/user/runtime-strategy-configs/route.ts

@@ -0,0 +1,241 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getAvailableStrategyNames } from '@tradejs/node/strategies';
+import {
+  listTradingAccounts,
+  resolveTradingAccount,
+} from '@tradejs/infra/tradingAccounts';
+import { getData, getKeys, redisKeys, setData } from '@tradejs/infra/redis';
+import type { Interval, MarketUniverse, StrategyConfig } from '@tradejs/types';
+import { getCurrentUserName } from '#app/lib/currentUser';
+import { resolveStrategyConfigIdentityByKey } from '#app/lib/runtimeStrategies';
+
+export const dynamic = 'force-dynamic';
+
+const projectRoot =
+  String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+const INTERVALS = new Set([
+  '1',
+  '3',
+  '5',
+  '15',
+  '30',
+  '60',
+  '120',
+  '240',
+  '360',
+  '720',
+  '1440',
+]);
+
+type StoredRuntimeConfig = {
+  key: string;
+  strategyName: string;
+  configId: string;
+  config: StrategyConfig;
+};
+
+const loadConfigs = async (
+  userName: string,
+): Promise<StoredRuntimeConfig[]> => {
+  const keys = await getKeys(`${redisKeys.strategies(userName)}:`);
+  const rows = await Promise.all(
+    keys.map(async (key): Promise<StoredRuntimeConfig | null> => {
+      const identity = resolveStrategyConfigIdentityByKey(userName, key);
+      if (!identity) return null;
+      const config = (await getData(key, null)) as StrategyConfig | null;
+      if (!config || typeof config !== 'object' || Array.isArray(config)) {
+        return null;
+      }
+      return { key, ...identity, config };
+    }),
+  );
+  return rows.filter((row): row is StoredRuntimeConfig => row != null);
+};
+
+const normalizeConfigId = (value: unknown) => {
+  const configId = String(value ?? '').trim();
+  if (!configId) throw new Error('Config id is required');
+  if (!/^[a-zA-Z0-9_-]+$/.test(configId)) {
+    throw new Error('Config id may contain only letters, numbers, _ and -');
+  }
+  if (configId === 'results')
+    throw new Error('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 (!INTERVALS.has(interval))
+    throw new Error(`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 Error(
+      `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 Error(
+        `${strategyName} config "${candidate.configId}" already uses account "${accountId}". One strategy can run only once per account.`,
+      );
+    }
+  }
+};
+
+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 GET = async () => {
+  const userName = await getCurrentUserName();
+  if (!userName)
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  const [configs, strategyNames, accounts] = await Promise.all([
+    loadConfigs(userName),
+    getAvailableStrategyNames(projectRoot),
+    listTradingAccounts(userName),
+  ]);
+  return NextResponse.json({
+    configs: await Promise.all(
+      configs.map((row) => toResponseConfig(userName, row)),
+    ),
+    strategyNames,
+    accounts: accounts.map(
+      ({ apiKey: _apiKey, apiSecret: _apiSecret, ...account }) => account,
+    ),
+    intervals: [...INTERVALS],
+  });
+};
+
+const save = async (request: NextRequest, editing: boolean) => {
+  const userName = await getCurrentUserName();
+  if (!userName)
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  try {
+    const body = (await request.json()) as Record<string, unknown>;
+    const strategyName = String(body.strategyName ?? '').trim();
+    const configId = normalizeConfigId(body.configId);
+    const availableStrategies = await getAvailableStrategyNames(projectRoot);
+    if (!strategyName || !availableStrategies.includes(strategyName)) {
+      throw new Error(`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 Error('Runtime strategy config not found');
+    if (!editing && existing)
+      throw new Error('Runtime strategy config already exists');
+    const parameters = body.parameters;
+    if (
+      !parameters ||
+      typeof parameters !== 'object' ||
+      Array.isArray(parameters)
+    ) {
+      throw new Error('Strategy parameters must be a JSON object');
+    }
+    const interval = normalizeInterval(body.interval);
+    const universe = normalizeUniverse(body.universe);
+    const accountId = normalizeAccountId(body.accountId);
+    const config: StrategyConfig = {
+      ...(parameters as StrategyConfig),
+      ENABLE: body.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 key = redisKeys.strategyConfig(userName, strategyName, configId);
+    await setData(key, config, { expire: 0 });
+    return NextResponse.json({
+      config: await toResponseConfig(userName, {
+        key,
+        strategyName,
+        configId,
+        config,
+      }),
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const status = message.includes('already') ? 409 : 400;
+    return NextResponse.json({ error: message }, { status });
+  }
+};
+
+export const POST = (request: NextRequest) => save(request, false);
+export const PATCH = (request: NextRequest) => save(request, true);

package/src/app/api/user/settings/route.ts

@@ -10,7 +10,7 @@ import {
   type UserRecord,
   type UserSettings,
 } from '@tradejs/infra/userSettings';
-import { getCurrentUserName } from '@app/lib/currentUser';
+import { getCurrentUserName } from '#app/lib/currentUser';
 
 export const dynamic = 'force-dynamic';
 
@@ -28,6 +28,12 @@ type UpdateBody =
         apiKey?: string;
       };
     }
+  | {
+      section: 'coinmarketcap';
+      data?: {
+        apiKey?: string;
+      };
+    }
   | {
       section: 'ai';
       data?: {
@@ -83,6 +89,9 @@ const toResponse = (settings: UserSettings) => ({
     coinalyze: {
       apiKey: maskSecret(settings.COINALYZE_API_KEY),
     },
+    coinmarketcap: {
+      apiKey: maskSecret(settings.COINMARKETCAP_API_KEY),
+    },
     ai: {
       apiKey: maskSecret(settings.AI_API_KEY),
       apiEndpoint: settings.AI_API_ENDPOINT,
@@ -180,6 +189,14 @@ export const PATCH = async (request: Request) => {
     }
   }
 
+  if (body.section === 'coinmarketcap') {
+    const apiKey = cleanOptionalText(body.data?.apiKey);
+
+    if (apiKey) {
+      await updateUserRecord(userName, { COINMARKETCAP_API_KEY: apiKey });
+    }
+  }
+
   if (body.section === 'ai') {
     const currentSettings = await getUserSettings(userName);
     const patch: Partial<UserRecord> = {};

package/src/app/api/user/trading-accounts/[accountId]/route.ts

@@ -0,0 +1,35 @@
+import { NextResponse } from 'next/server';
+import {
+  deleteTradingAccount,
+  getTradingAccount,
+  listRuntimeDeployments,
+} from '@tradejs/infra/tradingAccounts';
+import { getCurrentUserName } from '#app/lib/currentUser';
+
+export const DELETE = async (
+  _request: Request,
+  { params }: { params: Promise<{ accountId: string }> },
+) => {
+  const userName = await getCurrentUserName();
+  if (!userName) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+  const { accountId } = await params;
+  const account = await getTradingAccount(userName, accountId);
+  if (!account) {
+    return NextResponse.json({ error: 'Account not found' }, { status: 404 });
+  }
+  const referencedBy = (await listRuntimeDeployments(userName)).filter(
+    (deployment) => deployment.accountId === account.id,
+  );
+  if (referencedBy.length) {
+    return NextResponse.json(
+      {
+        error: `Account is used by deployments: ${referencedBy.map(({ id }) => id).join(', ')}`,
+      },
+      { status: 409 },
+    );
+  }
+  await deleteTradingAccount(userName, accountId);
+  return NextResponse.json({ deleted: true });
+};

package/src/app/api/user/trading-accounts/route.ts

@@ -0,0 +1,134 @@
+import { NextRequest, NextResponse } from 'next/server';
+import {
+  getTradingAccount,
+  listTradingAccounts,
+  saveTradingAccount,
+} from '@tradejs/infra/tradingAccounts';
+import { getUserSettings } from '@tradejs/infra/userSettings';
+import { isMarketUniverse, type TradingAccountRef } from '@tradejs/types';
+import { getCurrentUserName } from '#app/lib/currentUser';
+
+export const dynamic = 'force-dynamic';
+
+const maskSecret = (value?: string) => {
+  const trimmed = String(value ?? '').trim();
+  return trimmed ? `${'*'.repeat(12)}${trimmed.slice(-4)}` : '';
+};
+
+const toPublicAccount = (account: TradingAccountRef) => {
+  const { apiKey, apiSecret, ...safe } = account;
+  return {
+    ...safe,
+    hasApiKey: Boolean(apiKey),
+    hasApiSecret: Boolean(apiSecret),
+    maskedApiKey: maskSecret(apiKey),
+    maskedApiSecret: maskSecret(apiSecret),
+  };
+};
+
+const migrateLegacyBybitAccount = async (
+  userName: string,
+  accounts: TradingAccountRef[],
+) => {
+  const upgradedAccounts = await Promise.all(
+    accounts.map((account) =>
+      account.provider === 'bybit' && !account.universes?.includes('tradfi')
+        ? saveTradingAccount(userName, {
+            ...account,
+            universes: ['crypto', 'tradfi'],
+          })
+        : account,
+    ),
+  );
+  if (upgradedAccounts.some(({ provider }) => provider === 'bybit')) {
+    return upgradedAccounts;
+  }
+  const settings = await getUserSettings(userName);
+  if (!settings.BYBIT_API_KEY || !settings.BYBIT_API_SECRET) {
+    return upgradedAccounts;
+  }
+  const migrated = await saveTradingAccount(userName, {
+    id: 'bybit-default',
+    label: 'Bybit',
+    provider: 'bybit',
+    enabled: true,
+    isDefault: true,
+    universes: ['crypto', 'tradfi'],
+    environment: 'mainnet',
+    apiKey: settings.BYBIT_API_KEY,
+    apiSecret: settings.BYBIT_API_SECRET,
+  });
+  return [...upgradedAccounts, migrated].sort((left, right) =>
+    left.label.localeCompare(right.label),
+  );
+};
+
+export const GET = async () => {
+  const userName = await getCurrentUserName();
+  if (!userName) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+  const accounts = await migrateLegacyBybitAccount(
+    userName,
+    await listTradingAccounts(userName),
+  );
+  return NextResponse.json({ accounts: accounts.map(toPublicAccount) });
+};
+
+export const POST = async (request: NextRequest) => {
+  const userName = await getCurrentUserName();
+  if (!userName) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+  try {
+    const body = (await request.json()) as Partial<TradingAccountRef>;
+    const id = String(body.id ?? '').trim();
+    const label = String(body.label ?? '').trim();
+    const provider = String(body.provider ?? '')
+      .trim()
+      .toLowerCase();
+    const universes = Array.isArray(body.universes)
+      ? body.universes.filter(isMarketUniverse)
+      : [];
+    if (!id || !label || !provider || !universes.length) {
+      return NextResponse.json(
+        { error: 'id, label, provider and universes are required' },
+        { status: 400 },
+      );
+    }
+    const existing = await getTradingAccount(userName, id);
+    const apiKey =
+      typeof body.apiKey === 'string' && body.apiKey.trim()
+        ? body.apiKey.trim()
+        : existing?.apiKey;
+    const apiSecret =
+      typeof body.apiSecret === 'string' && body.apiSecret.trim()
+        ? body.apiSecret.trim()
+        : existing?.apiSecret;
+    if (!apiKey || !apiSecret) {
+      return NextResponse.json(
+        { error: 'apiKey and apiSecret are required for a new account' },
+        { status: 400 },
+      );
+    }
+    const account = await saveTradingAccount(userName, {
+      ...existing,
+      id,
+      label,
+      provider,
+      enabled: body.enabled !== false,
+      isDefault: Boolean(body.isDefault),
+      universes,
+      environment: body.environment === 'testnet' ? 'testnet' : 'mainnet',
+      readOnly: Boolean(body.readOnly),
+      apiKey,
+      apiSecret,
+    });
+    return NextResponse.json({ account: toPublicAccount(account) });
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : String(error) },
+      { status: 400 },
+    );
+  }
+};

package/src/app/components/Backtest/CompareList/index.tsx

@@ -1,6 +1,6 @@
 import { For, Tag, HStack, Text } from '@chakra-ui/react';
 import _ from 'lodash';
-import { useTestsCompare } from '@store';
+import { useTestsCompare } from '#store';
 
 export const CompareList = () => {
   const { compareList, onChangeCompare } = useTestsCompare();