@tradejs/app 1.0.0

package/src/app/api/cron/route.ts

@@ -0,0 +1,4 @@
+import { NextResponse } from 'next/server';
+
+export const GET = () =>
+  NextResponse.json({ error: 'Not implemented' }, { status: 404 });

package/src/app/api/derivatives/[symbol]/[interval]/route.ts

@@ -0,0 +1,57 @@
+import { NextRequest, NextResponse } from 'next/server';
+import {
+  DerivativesInterval,
+  getDerivativesRangeForSymbols,
+} from '@tradejs/infra/timescale';
+import { logger } from '@tradejs/infra/logger';
+
+export const dynamic = 'force-dynamic';
+
+interface Params {
+  symbol: string;
+  interval: string;
+}
+
+const asInterval = (value: string): DerivativesInterval | null => {
+  if (value === '15m' || value === '1h') return value;
+  return null;
+};
+
+export const GET = async (
+  request: NextRequest,
+  { params }: { params: Promise<Params> },
+) => {
+  try {
+    const { symbol, interval } = await params;
+    const tf = asInterval(interval);
+    if (!tf) {
+      return NextResponse.json({ error: 'Invalid interval' }, { status: 400 });
+    }
+
+    const fromRaw = Number(request.nextUrl.searchParams.get('from') ?? 0);
+    const toRaw = Number(request.nextUrl.searchParams.get('to') ?? Date.now());
+    const startMs =
+      Number.isFinite(fromRaw) && fromRaw > 0
+        ? fromRaw
+        : Date.now() - 7 * 24 * 60 * 60 * 1000;
+    const endMs = Number.isFinite(toRaw) ? toRaw : Date.now();
+
+    const rows = await getDerivativesRangeForSymbols(
+      [String(symbol).toUpperCase()],
+      tf,
+      startMs,
+      endMs,
+    );
+    return NextResponse.json({
+      rows,
+      symbol: String(symbol).toUpperCase(),
+      interval: tf,
+    });
+  } catch (error) {
+    logger.log('error', 'Derivatives range error: %o', error);
+    return NextResponse.json(
+      { error: 'Failed to load derivatives data' },
+      { status: 500 },
+    );
+  }
+};

package/src/app/api/derivatives/summary/route.ts

@@ -0,0 +1,20 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { logger } from '@tradejs/infra/logger';
+import { getDerivativesSummary } from '@tradejs/infra/timescale';
+
+export const dynamic = 'force-dynamic';
+
+export const GET = async (request: NextRequest) => {
+  try {
+    const hoursRaw = Number(request.nextUrl.searchParams.get('hours') ?? 24);
+    const limitRaw = Number(request.nextUrl.searchParams.get('limit') ?? 500);
+    const summary = await getDerivativesSummary(hoursRaw, limitRaw);
+    return NextResponse.json(summary);
+  } catch (error) {
+    logger.log('error', 'Derivatives summary error: %o', error);
+    return NextResponse.json(
+      { error: 'Failed to load derivatives summary' },
+      { status: 500 },
+    );
+  }
+};

package/src/app/api/files/screenshot/[name]/route.ts

@@ -0,0 +1,42 @@
+import { NextResponse } from 'next/server';
+import fs from 'fs/promises';
+import path from 'path';
+
+export const runtime = 'nodejs';
+
+const getProjectRoot = (): string => {
+  const fromEnv = String(process.env.PROJECT_CWD || '').trim();
+  return fromEnv ? path.resolve(fromEnv) : process.cwd();
+};
+
+interface Params {
+  name: string;
+}
+
+export async function GET(
+  _req: Request,
+  { params }: { params: Promise<Params> },
+) {
+  try {
+    const { name } = await params;
+    const filePath = path.join(
+      getProjectRoot(),
+      'data',
+      'screenshots',
+      `${name}.png`,
+    );
+    const file = await fs.readFile(filePath);
+
+    const body = new Uint8Array(file);
+
+    return new NextResponse(body, {
+      headers: {
+        'Content-Type': 'image/png',
+        'Content-Length': String(file.byteLength),
+        'Cache-Control': 'public, max-age=60, immutable',
+      },
+    });
+  } catch {
+    return NextResponse.json({ error: 'Not found' }, { status: 404 });
+  }
+}

package/src/app/api/indicators/route.ts

@@ -0,0 +1,24 @@
+import { NextResponse } from 'next/server';
+import {
+  getPluginIndicatorCatalog,
+  getPluginIndicatorRenderers,
+} from '@tradejs/core/indicators';
+import { ensureIndicatorPluginsLoaded } from '@tradejs/node/registry';
+import { logger } from '@tradejs/infra/logger';
+
+export const dynamic = 'force-dynamic';
+
+export const GET = async () => {
+  try {
+    await ensureIndicatorPluginsLoaded();
+    const data = getPluginIndicatorCatalog();
+    const renderers = getPluginIndicatorRenderers();
+    return NextResponse.json({ data, renderers });
+  } catch (error) {
+    logger.log('error', 'Indicators catalog error: %o', error);
+    return NextResponse.json(
+      { error: 'Internal Server Error' },
+      { status: 500 },
+    );
+  }
+};

package/src/app/api/kline/[provider]/[symbol]/[interval]/route.ts

@@ -0,0 +1,123 @@
+import { NextRequest, NextResponse } from 'next/server';
+import {
+  createIndicators,
+  getRegisteredIndicatorEntries,
+} from '@tradejs/core/indicators';
+import { getConnectorCreatorByProvider } from '@tradejs/node/connectors';
+import { ensureIndicatorPluginsLoaded } from '@tradejs/node/registry';
+import { logger } from '@tradejs/infra/logger';
+import {
+  KlineChartData,
+  KlineRequest,
+  Interval,
+  ConnectorCreator,
+} from '@tradejs/types';
+
+export const dynamic = 'force-dynamic';
+
+interface Params {
+  provider: string;
+  symbol: string;
+  interval: string;
+}
+
+const enrichWithPluginIndicators = (
+  data: KlineChartData,
+  btcData: KlineChartData,
+  pluginKeys: string[],
+): KlineChartData => {
+  if (!pluginKeys.length || !data.length) {
+    return data;
+  }
+
+  const history = createIndicators(data, btcData, {
+    includeMlPayload: false,
+  }).result() as Record<string, number[]>;
+
+  const nextData = data.map((candle) => ({ ...candle }));
+
+  for (const pluginKey of pluginKeys) {
+    const series = history[pluginKey];
+    if (!Array.isArray(series) || !series.length) {
+      continue;
+    }
+
+    const startIdx = nextData.length - series.length;
+    for (let i = 0; i < series.length; i += 1) {
+      const candleIndex = startIdx + i;
+      if (candleIndex < 0 || candleIndex >= nextData.length) {
+        continue;
+      }
+      const value = series[i];
+      if (!Number.isFinite(value)) {
+        continue;
+      }
+      (nextData[candleIndex] as Record<string, unknown>)[pluginKey] = value;
+    }
+  }
+
+  return nextData;
+};
+
+export const POST = async (
+  request: NextRequest,
+  { params }: { params: Promise<Params> },
+) => {
+  try {
+    const { provider, symbol, interval } = await params;
+    const body = await request.json();
+    const options = body as
+      | Omit<KlineRequest, 'symbol' | 'interval'>
+      | undefined;
+
+    if (!options || !symbol || !interval || !options.end) {
+      return NextResponse.json(
+        { error: 'Missing required kline parameters' },
+        { status: 400 },
+      );
+    }
+
+    const connectorCreator =
+      (await getConnectorCreatorByProvider(provider)) ||
+      (await getConnectorCreatorByProvider('bybit'));
+    if (!connectorCreator) {
+      throw new Error('No connector available for provider');
+    }
+    const connector = await (connectorCreator as ConnectorCreator)({
+      userName: 'root',
+    });
+
+    const baseData = await connector.kline({
+      symbol,
+      interval: interval as Interval,
+      ...options,
+    });
+
+    await ensureIndicatorPluginsLoaded();
+    const pluginKeys = getRegisteredIndicatorEntries().map(
+      (entry) => entry.historyKey || entry.indicator.id,
+    );
+    if (!pluginKeys.length) {
+      return NextResponse.json({ data: baseData });
+    }
+
+    const btcData =
+      symbol === 'BTCUSDT'
+        ? baseData
+        : await connector.kline({
+            symbol: 'BTCUSDT',
+            interval: interval as Interval,
+            ...options,
+          });
+
+    const data = enrichWithPluginIndicators(baseData, btcData, pluginKeys);
+
+    return NextResponse.json({ data });
+  } catch (error) {
+    logger.log('error', `Kline fetch error: %o`, error);
+    return NextResponse.json(
+      { error: 'Internal Server Error' },
+      { status: 500 },
+    );
+  }
+};

package/src/app/api/scanner/[provider]/route.ts

@@ -0,0 +1,41 @@
+import { NextResponse } from 'next/server';
+import { ConnectorCreator } from '@tradejs/types';
+import { getConnectorCreatorByProvider } from '@tradejs/node/connectors';
+import { getTopTickers } from '@tradejs/core/tickers';
+import { logger } from '@tradejs/infra/logger';
+
+export const dynamic = 'force-dynamic';
+
+interface Params {
+  provider: string;
+}
+
+export const GET = async (
+  _request: Request,
+  { params }: { params: Promise<Params> },
+) => {
+  try {
+    const { provider } = await params;
+    const connectorCreator =
+      (await getConnectorCreatorByProvider(provider)) ||
+      (await getConnectorCreatorByProvider('bybit'));
+    if (!connectorCreator) {
+      throw new Error('No connector available for provider');
+    }
+
+    const connector = await (connectorCreator as ConnectorCreator)({
+      userName: 'root',
+    });
+
+    const data = await connector.getTickers();
+    const tickers = getTopTickers(data);
+
+    return NextResponse.json({ tickers });
+  } catch (error) {
+    logger.log('error', `Scanner error: %o`, error);
+    return NextResponse.json(
+      { error: 'Internal Server Error' },
+      { status: 500 },
+    );
+  }
+};

package/src/app/api/scanner/route.ts

@@ -0,0 +1,31 @@
+import { NextResponse } from 'next/server';
+import { getTopTickers } from '@tradejs/core/tickers';
+import { getConnectorCreatorByProvider } from '@tradejs/node/connectors';
+import { logger } from '@tradejs/infra/logger';
+import { ConnectorCreator } from '@tradejs/types';
+
+export const dynamic = 'force-dynamic';
+
+export const GET = async () => {
+  try {
+    const connectorCreator = await getConnectorCreatorByProvider('bybit');
+    if (!connectorCreator) {
+      throw new Error('No connector available for provider');
+    }
+
+    const byBitConnector = await (connectorCreator as ConnectorCreator)({
+      userName: 'root',
+    });
+
+    const data = await byBitConnector.getTickers();
+    const tickers = getTopTickers(data);
+
+    return NextResponse.json({ tickers });
+  } catch (error) {
+    logger.log('error', `Scanner error: %o`, error);
+    return NextResponse.json(
+      { error: 'Internal Server Error' },
+      { status: 500 },
+    );
+  }
+};

package/src/app/api/signal/[symbol]/[signalId]/route.ts

@@ -0,0 +1,42 @@
+import _ from 'lodash';
+import { NextResponse } from 'next/server';
+import { getData, redisKeys } from '@tradejs/infra/redis';
+import { logger } from '@tradejs/infra/logger';
+import { Signal } from '@tradejs/types';
+
+export const dynamic = 'force-dynamic';
+
+interface Params {
+  symbol: string;
+  signalId: string;
+}
+
+export const GET = async (
+  _req: Request,
+  { params }: { params: Promise<Params> },
+) => {
+  try {
+    const { symbol, signalId } = await params;
+
+    if (!symbol || !signalId) {
+      return NextResponse.json(
+        { error: 'Missing required parameters: symbol, signalId' },
+        { status: 400 },
+      );
+    }
+
+    let signal: Signal = await getData(redisKeys.signal(symbol, signalId));
+
+    if (!signal || _.isEmpty(signal)) {
+      signal = await getData(redisKeys.storeSignal(symbol, signalId));
+    }
+
+    return NextResponse.json({ signal });
+  } catch (error) {
+    logger.log('error', `Signal load error: %o`, error);
+    return NextResponse.json(
+      { error: 'Internal Server Error' },
+      { status: 500 },
+    );
+  }
+};

package/src/app/api/spread/[symbol]/[interval]/route.ts

@@ -0,0 +1,57 @@
+import { NextRequest, NextResponse } from 'next/server';
+import {
+  DerivativesInterval,
+  getSpreadRangeForSymbols,
+} from '@tradejs/infra/timescale';
+import { logger } from '@tradejs/infra/logger';
+
+export const dynamic = 'force-dynamic';
+
+interface Params {
+  symbol: string;
+  interval: string;
+}
+
+const asInterval = (value: string): DerivativesInterval | null => {
+  if (value === '15m' || value === '1h') return value;
+  return null;
+};
+
+export const GET = async (
+  request: NextRequest,
+  { params }: { params: Promise<Params> },
+) => {
+  try {
+    const { symbol, interval } = await params;
+    const tf = asInterval(interval);
+    if (!tf) {
+      return NextResponse.json({ error: 'Invalid interval' }, { status: 400 });
+    }
+
+    const fromRaw = Number(request.nextUrl.searchParams.get('from') ?? 0);
+    const toRaw = Number(request.nextUrl.searchParams.get('to') ?? Date.now());
+    const startMs =
+      Number.isFinite(fromRaw) && fromRaw > 0
+        ? fromRaw
+        : Date.now() - 7 * 24 * 60 * 60 * 1000;
+    const endMs = Number.isFinite(toRaw) ? toRaw : Date.now();
+
+    const rows = await getSpreadRangeForSymbols(
+      [String(symbol).toUpperCase()],
+      tf,
+      startMs,
+      endMs,
+    );
+    return NextResponse.json({
+      rows,
+      symbol: String(symbol).toUpperCase(),
+      interval: tf,
+    });
+  } catch (error) {
+    logger.log('error', 'Spread range error: %o', error);
+    return NextResponse.json(
+      { error: 'Failed to load spread data' },
+      { status: 500 },
+    );
+  }
+};

package/src/app/api/spread/summary/route.ts

@@ -0,0 +1,20 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { logger } from '@tradejs/infra/logger';
+import { getSpreadSummary } from '@tradejs/infra/timescale';
+
+export const dynamic = 'force-dynamic';
+
+export const GET = async (request: NextRequest) => {
+  try {
+    const hoursRaw = Number(request.nextUrl.searchParams.get('hours') ?? 24);
+    const limitRaw = Number(request.nextUrl.searchParams.get('limit') ?? 500);
+    const summary = await getSpreadSummary(hoursRaw, limitRaw);
+    return NextResponse.json(summary);
+  } catch (error) {
+    logger.log('error', 'Spread summary error: %o', error);
+    return NextResponse.json(
+      { error: 'Failed to load spread summary' },
+      { status: 500 },
+    );
+  }
+};

package/src/app/auth.ts

@@ -0,0 +1,76 @@
+import NextAuth from 'next-auth';
+import Credentials from 'next-auth/providers/credentials';
+import bcrypt from 'bcryptjs';
+import { getData, redisKeys } from '@tradejs/infra/redis';
+
+const getPasswordHash = (user: unknown): string | null => {
+  if (!user) return null;
+  if (typeof user === 'string') return user;
+  if (typeof user !== 'object') return null;
+
+  const record = user as Record<string, unknown>;
+  const direct = record.passwordHash ?? record.password;
+  if (typeof direct === 'string') return direct;
+
+  const nested = record.password as Record<string, unknown> | undefined;
+  const nestedHash = nested?.hash;
+  if (typeof nestedHash === 'string') return nestedHash;
+
+  const alt = record.hash;
+  if (typeof alt === 'string') return alt;
+
+  return null;
+};
+
+export const { handlers, auth, signIn, signOut } = NextAuth({
+  trustHost: true,
+  providers: [
+    Credentials({
+      name: 'Credentials',
+      credentials: {
+        username: { label: 'Username', type: 'text' },
+        password: { label: 'Password', type: 'password' },
+      },
+      authorize: async (credentials) => {
+        const username = credentials?.username?.toString().trim();
+        const password = credentials?.password?.toString();
+
+        if (!username || !password) return null;
+
+        const user = await getData(redisKeys.user(username), null);
+        const passwordHash = getPasswordHash(user);
+        if (!passwordHash) return null;
+
+        const isValid = await bcrypt.compare(password, passwordHash);
+        if (!isValid) return null;
+
+        return { id: username, name: username };
+      },
+    }),
+  ],
+  pages: {
+    signIn: '/routes/signin',
+  },
+  session: {
+    strategy: 'jwt',
+  },
+  callbacks: {
+    authorized: ({ auth: session }) => Boolean(session?.user),
+    jwt: ({ token, user }) => {
+      if (user) {
+        token.id = user.id;
+        token.name = user.name;
+      }
+      return token;
+    },
+    session: ({ session, token }) => {
+      if (token?.id) {
+        session.user = {
+          ...session.user,
+          id: String(token.id),
+        };
+      }
+      return session;
+    },
+  },
+});

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

@@ -0,0 +1,34 @@
+import { For, Tag, HStack, Text } from '@chakra-ui/react';
+import _ from 'lodash';
+import { useTestsCompare } from '@store';
+
+export const CompareList = () => {
+  const { compareList, onChangeCompare } = useTestsCompare();
+
+  if (_.isEmpty(compareList)) {
+    return (
+      <HStack p={2} gap={4}>
+        <Text color="gray.400">No compare tests</Text>
+      </HStack>
+    );
+  }
+
+  return (
+    <HStack p={2} gap={4}>
+      <For each={compareList}>
+        {({ testResult, color }) => (
+          <Tag.Root key={testResult.test.testId} size="lg" colorPalette={color}>
+            <Tag.Label>
+              {testResult.test.symbol}-{testResult.test.testId}
+            </Tag.Label>
+            <Tag.EndElement>
+              <Tag.CloseTrigger
+                onClick={() => onChangeCompare(testResult.test.name)}
+              />
+            </Tag.EndElement>
+          </Tag.Root>
+        )}
+      </For>
+    </HStack>
+  );
+};