@tradejs/app 1.0.6 → 1.0.9

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

@@ -1,4 +1,5 @@
 import { NextRequest, NextResponse } from 'next/server';
+import { intervalToMs, mergeData } from '@tradejs/core/data';
 import {
   createIndicators,
   getRegisteredIndicatorEntries,
@@ -13,10 +14,14 @@ import {
   ConnectorCreator,
 } from '@tradejs/types';
 import { getCurrentUserName } from '@app/lib/currentUser';
+import { normalizeEndToIntervalBoundary } from '@app/lib/klineWindow';
 
 export const dynamic = 'force-dynamic';
 const projectRoot =
   String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+const DEFAULT_KLINE_CACHE_TTL_MS = 30_000;
+const MAX_KLINE_CACHE_ENTRIES = 500;
+const MAX_KLINE_CACHE_BYTES = 32 * 1024 * 1024;
 
 interface Params {
   provider: string;
@@ -24,6 +29,193 @@ interface Params {
   interval: string;
 }
 
+type KlineCacheEntry = {
+  expiresAt: number;
+  sizeBytes: number;
+  value: KlineChartData;
+};
+
+type ManagedKlineCache = {
+  entries: Map<string, KlineCacheEntry>;
+  totalBytes: number;
+};
+
+type PluginRegistrySnapshot = {
+  pluginKeys: string[];
+  signature: string;
+};
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __tradejsKlineRawCache__: ManagedKlineCache | undefined;
+  // eslint-disable-next-line no-var
+  var __tradejsKlineBtcRawCache__: ManagedKlineCache | undefined;
+  // eslint-disable-next-line no-var
+  var __tradejsKlineEnrichedCache__: ManagedKlineCache | undefined;
+  // eslint-disable-next-line no-var
+  var __tradejsKlineInflightRequests__:
+    | Map<string, Promise<KlineChartData>>
+    | undefined;
+  // eslint-disable-next-line no-var
+  var __tradejsPluginRegistrySnapshotPromise__:
+    | Promise<PluginRegistrySnapshot>
+    | undefined;
+}
+
+const cloneKlineData = (data: KlineChartData) =>
+  data.map((candle) => ({ ...candle })) as KlineChartData;
+
+const createManagedCache = (): ManagedKlineCache => ({
+  entries: new Map<string, KlineCacheEntry>(),
+  totalBytes: 0,
+});
+
+const getRawKlineCache = () => {
+  if (!global.__tradejsKlineRawCache__) {
+    global.__tradejsKlineRawCache__ = createManagedCache();
+  }
+
+  return global.__tradejsKlineRawCache__;
+};
+
+const getBtcKlineCache = () => {
+  if (!global.__tradejsKlineBtcRawCache__) {
+    global.__tradejsKlineBtcRawCache__ = createManagedCache();
+  }
+
+  return global.__tradejsKlineBtcRawCache__;
+};
+
+const getEnrichedKlineCache = () => {
+  if (!global.__tradejsKlineEnrichedCache__) {
+    global.__tradejsKlineEnrichedCache__ = createManagedCache();
+  }
+
+  return global.__tradejsKlineEnrichedCache__;
+};
+
+const getInflightRequestMap = () => {
+  if (!global.__tradejsKlineInflightRequests__) {
+    global.__tradejsKlineInflightRequests__ = new Map<
+      string,
+      Promise<KlineChartData>
+    >();
+  }
+
+  return global.__tradejsKlineInflightRequests__;
+};
+
+const measureKlineDataBytes = (value: KlineChartData) =>
+  Buffer.byteLength(JSON.stringify(value), 'utf8');
+
+const pruneCache = (cache: ManagedKlineCache, now: number) => {
+  for (const [key, entry] of cache.entries) {
+    if (entry.expiresAt <= now) {
+      cache.entries.delete(key);
+      cache.totalBytes -= entry.sizeBytes;
+    }
+  }
+
+  while (
+    cache.entries.size > MAX_KLINE_CACHE_ENTRIES ||
+    cache.totalBytes > MAX_KLINE_CACHE_BYTES
+  ) {
+    const oldestKey = cache.entries.keys().next().value;
+    if (!oldestKey) {
+      break;
+    }
+
+    const entry = cache.entries.get(oldestKey);
+    cache.entries.delete(oldestKey);
+    cache.totalBytes -= entry?.sizeBytes ?? 0;
+  }
+
+  cache.totalBytes = Math.max(0, cache.totalBytes);
+};
+
+const getCacheTtlMs = (interval: Interval) =>
+  Math.min(intervalToMs(interval), DEFAULT_KLINE_CACHE_TTL_MS);
+
+const buildRawCacheKey = (params: {
+  provider: string;
+  symbol: string;
+  interval: Interval;
+  start: number;
+  end: number;
+  cacheOnly?: boolean;
+}) =>
+  [
+    params.provider,
+    params.symbol,
+    params.interval,
+    params.start,
+    params.end,
+    params.cacheOnly ? 'cache' : 'live',
+  ].join(':');
+
+const buildEnrichedCacheKey = (params: {
+  userName: string;
+  provider: string;
+  symbol: string;
+  interval: Interval;
+  start: number;
+  end: number;
+  historicalEnd: number;
+  cacheOnly?: boolean;
+  pluginSignature: string;
+}) =>
+  [
+    params.userName,
+    params.provider,
+    params.symbol,
+    params.interval,
+    params.start,
+    params.end,
+    params.historicalEnd,
+    params.cacheOnly ? 'cache' : 'live',
+    params.pluginSignature,
+  ].join(':');
+
+const getCachedKline = (cache: ManagedKlineCache, key: string, now: number) => {
+  const cached = cache.entries.get(key);
+  if (!cached) {
+    return null;
+  }
+
+  if (cached.expiresAt <= now) {
+    cache.entries.delete(key);
+    cache.totalBytes -= cached.sizeBytes;
+    cache.totalBytes = Math.max(0, cache.totalBytes);
+    return null;
+  }
+
+  return cloneKlineData(cached.value);
+};
+
+const setCachedKline = (
+  cache: ManagedKlineCache,
+  key: string,
+  value: KlineChartData,
+  ttlMs: number,
+  now: number,
+) => {
+  const nextValue = cloneKlineData(value);
+  const nextSizeBytes = measureKlineDataBytes(nextValue);
+  const previous = cache.entries.get(key);
+
+  if (previous) {
+    cache.totalBytes -= previous.sizeBytes;
+  }
+
+  cache.entries.set(key, {
+    expiresAt: now + ttlMs,
+    sizeBytes: nextSizeBytes,
+    value: nextValue,
+  });
+  cache.totalBytes += nextSizeBytes;
+  pruneCache(cache, now);
+};
+
 const enrichWithPluginIndicators = (
   data: KlineChartData,
   btcData: KlineChartData,
@@ -38,7 +230,7 @@ const enrichWithPluginIndicators = (
     pluginRegistryScope: projectRoot,
   }).result() as Record<string, number[]>;
 
-  const nextData = data.map((candle) => ({ ...candle }));
+  const nextData = cloneKlineData(data);
 
   for (const pluginKey of pluginKeys) {
     const series = history[pluginKey];
@@ -63,6 +255,27 @@ const enrichWithPluginIndicators = (
   return nextData;
 };
 
+const getPluginRegistrySnapshot = async (): Promise<PluginRegistrySnapshot> => {
+  if (!global.__tradejsPluginRegistrySnapshotPromise__) {
+    global.__tradejsPluginRegistrySnapshotPromise__ = (async () => {
+      await ensureIndicatorPluginsLoaded(projectRoot);
+      const pluginKeys = getRegisteredIndicatorEntries(projectRoot)
+        .map((entry) => entry.historyKey || entry.indicator.id)
+        .sort();
+
+      return {
+        pluginKeys,
+        signature: pluginKeys.join(','),
+      };
+    })().catch((error) => {
+      global.__tradejsPluginRegistrySnapshotPromise__ = undefined;
+      throw error;
+    });
+  }
+
+  return global.__tradejsPluginRegistrySnapshotPromise__;
+};
+
 export const POST = async (
   request: NextRequest,
   { params }: { params: Promise<Params> },
@@ -86,42 +299,151 @@ export const POST = async (
       );
     }
 
-    const connectorCreator =
-      (await getConnectorCreatorByProvider(provider, projectRoot)) ||
-      (await getConnectorCreatorByProvider('bybit', projectRoot));
-    if (!connectorCreator) {
-      throw new Error('No connector available for provider');
-    }
-    const connector = await (connectorCreator as ConnectorCreator)({
+    const typedInterval = interval as Interval;
+    const normalizedEnd = normalizeEndToIntervalBoundary(
+      Number(options.end),
+      typedInterval,
+    );
+    const historicalEnd = Math.min(Number(options.end), normalizedEnd);
+    const pluginSnapshot = await getPluginRegistrySnapshot();
+    const requestKey = buildEnrichedCacheKey({
       userName,
-    });
-
-    const baseData = await connector.kline({
+      provider,
       symbol,
-      interval: interval as Interval,
-      ...options,
+      interval: typedInterval,
+      start: Number(options.start ?? 0),
+      end: Number(options.end),
+      historicalEnd,
+      cacheOnly: Boolean(options.cacheOnly),
+      pluginSignature: pluginSnapshot.signature,
     });
+    const now = Date.now();
+    const ttlMs = getCacheTtlMs(typedInterval);
+    const enrichedCache = getEnrichedKlineCache();
+    const cachedEnriched = getCachedKline(enrichedCache, requestKey, now);
+    if (cachedEnriched) {
+      return NextResponse.json({ data: cachedEnriched });
+    }
 
-    await ensureIndicatorPluginsLoaded(projectRoot);
-    const pluginKeys = getRegisteredIndicatorEntries(projectRoot).map(
-      (entry) => entry.historyKey || entry.indicator.id,
-    );
-    if (!pluginKeys.length) {
-      return NextResponse.json({ data: baseData });
+    const inflightRequests = getInflightRequestMap();
+    const inflight = inflightRequests.get(requestKey);
+    if (inflight) {
+      return NextResponse.json({ data: await inflight });
     }
 
-    const btcData =
-      symbol === 'BTCUSDT'
-        ? baseData
-        : await connector.kline({
-            symbol: 'BTCUSDT',
-            interval: interval as Interval,
+    const pending = (async () => {
+      const connectorCreator =
+        (await getConnectorCreatorByProvider(provider, projectRoot)) ||
+        (await getConnectorCreatorByProvider('bybit', projectRoot));
+      if (!connectorCreator) {
+        throw new Error('No connector available for provider');
+      }
+      const connector = await (connectorCreator as ConnectorCreator)({
+        userName,
+      });
+
+      const liveTailRequired = Number(options.end) > historicalEnd;
+      const liveTailStart = Math.max(Number(options.start ?? 0), historicalEnd);
+      const rawCache = getRawKlineCache();
+      const btcCache = getBtcKlineCache();
+
+      const fetchRawSegment = async (segmentParams: {
+        symbol: string;
+        start: number;
+        end: number;
+        useBtcCache?: boolean;
+      }) => {
+        if (segmentParams.end <= segmentParams.start) {
+          return [] as KlineChartData;
+        }
+
+        const cache = segmentParams.useBtcCache ? btcCache : rawCache;
+        const cacheKey = buildRawCacheKey({
+          provider,
+          symbol: segmentParams.symbol,
+          interval: typedInterval,
+          start: segmentParams.start,
+          end: segmentParams.end,
+          cacheOnly: Boolean(options.cacheOnly),
+        });
+        const cached = getCachedKline(cache, cacheKey, now);
+        if (cached) {
+          return cached;
+        }
+
+        const data = await connector.kline({
+          symbol: segmentParams.symbol,
+          interval: typedInterval,
+          ...options,
+          start: segmentParams.start,
+          end: segmentParams.end,
+        });
+
+        setCachedKline(cache, cacheKey, data, ttlMs, now);
+        return data;
+      };
+
+      const baseHistorical =
+        historicalEnd > Number(options.start ?? 0)
+          ? await fetchRawSegment({
+              symbol,
+              start: Number(options.start ?? 0),
+              end: historicalEnd,
+            })
+          : [];
+      const baseLiveTail = liveTailRequired
+        ? await connector.kline({
+            symbol,
+            interval: typedInterval,
             ...options,
-          });
+            start: liveTailStart,
+            end: Number(options.end),
+          })
+        : [];
+      const baseData = mergeData(baseHistorical, baseLiveTail);
+
+      if (!pluginSnapshot.pluginKeys.length) {
+        setCachedKline(enrichedCache, requestKey, baseData, ttlMs, now);
+        return baseData;
+      }
+
+      const btcData =
+        symbol === 'BTCUSDT'
+          ? baseData
+          : mergeData(
+              historicalEnd > Number(options.start ?? 0)
+                ? await fetchRawSegment({
+                    symbol: 'BTCUSDT',
+                    start: Number(options.start ?? 0),
+                    end: historicalEnd,
+                    useBtcCache: true,
+                  })
+                : [],
+              liveTailRequired
+                ? await connector.kline({
+                    symbol: 'BTCUSDT',
+                    interval: typedInterval,
+                    ...options,
+                    start: liveTailStart,
+                    end: Number(options.end),
+                  })
+                : [],
+            );
+
+      const data = enrichWithPluginIndicators(
+        baseData,
+        btcData,
+        pluginSnapshot.pluginKeys,
+      );
+      setCachedKline(enrichedCache, requestKey, data, ttlMs, now);
+      return data;
+    })().finally(() => {
+      inflightRequests.delete(requestKey);
+    });
 
-    const data = enrichWithPluginIndicators(baseData, btcData, pluginKeys);
+    inflightRequests.set(requestKey, pending);
 
-    return NextResponse.json({ data });
+    return NextResponse.json({ data: await pending });
   } catch (error) {
     logger.log('error', `Kline fetch error: %o`, error);
     return NextResponse.json(

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

@@ -1,8 +1,8 @@
-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';
+import { getCurrentUserName } from '@app/lib/currentUser';
 
 export const dynamic = 'force-dynamic';
 
@@ -16,6 +16,11 @@ export const GET = async (
   { params }: { params: Promise<Params> },
 ) => {
   try {
+    const userName = await getCurrentUserName();
+    if (!userName) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
     const { symbol, signalId } = await params;
 
     if (!symbol || !signalId) {
@@ -25,11 +30,9 @@ export const GET = async (
       );
     }
 
-    let signal: Signal = await getData(redisKeys.signal(symbol, signalId));
-
-    if (!signal || _.isEmpty(signal)) {
-      signal = await getData(redisKeys.storeSignal(symbol, signalId));
-    }
+    const signal: Signal = await getData(
+      redisKeys.storeSignal(symbol, signalId),
+    );
 
     return NextResponse.json({ signal });
   } catch (error) {

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

@@ -1,6 +1,10 @@
 import bcrypt from 'bcryptjs';
 import { NextResponse } from 'next/server';
+import { normalizeAiResponseLanguage } from '@tradejs/infra/aiLanguages';
+import { normalizeAiEndpoint } from '@tradejs/infra/aiEndpoints';
+import { normalizeAiModel } from '@tradejs/infra/aiModels';
 import {
+  getUserRecord,
   getUserSettings,
   updateUserRecord,
   type UserRecord,
@@ -18,12 +22,6 @@ type UpdateBody =
         apiSecret?: string;
       };
     }
-  | {
-      section: 'token';
-      data?: {
-        token?: string;
-      };
-    }
   | {
       section: 'coinalyze';
       data?: {
@@ -31,10 +29,12 @@ type UpdateBody =
       };
     }
   | {
-      section: 'openai';
+      section: 'ai';
       data?: {
         apiKey?: string;
         apiEndpoint?: string;
+        model?: string;
+        responseLanguage?: string;
       };
     }
   | {
@@ -80,13 +80,14 @@ const toResponse = (settings: UserSettings) => ({
       apiKey: maskSecret(settings.BYBIT_API_KEY),
       apiSecret: maskSecret(settings.BYBIT_API_SECRET),
     },
-    token: maskSecret(settings.token),
     coinalyze: {
       apiKey: maskSecret(settings.COINALYZE_API_KEY),
     },
-    openai: {
-      apiKey: maskSecret(settings.OPENAI_API_KEY),
-      apiEndpoint: settings.OPENAI_API_ENDPOINT,
+    ai: {
+      apiKey: maskSecret(settings.AI_API_KEY),
+      apiEndpoint: settings.AI_API_ENDPOINT,
+      model: settings.AI_MODEL,
+      responseLanguage: settings.AI_RESPONSE_LANGUAGE,
     },
     telegram: {
       botToken: maskSecret(settings.TG_BOT_TOKEN),
@@ -97,12 +98,22 @@ const toResponse = (settings: UserSettings) => ({
 
 const hasKeys = (patch: Partial<UserRecord>) => Object.keys(patch).length > 0;
 
+const removeLegacyPasswordlessToken = async (userName: string) => {
+  const record = await getUserRecord(userName);
+  if (!record || !Object.hasOwn(record, 'token')) {
+    return;
+  }
+
+  await updateUserRecord(userName, { token: undefined });
+};
+
 export const GET = async () => {
   const userName = await getCurrentUserName();
   if (!userName) {
     return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
   }
 
+  await removeLegacyPasswordlessToken(userName);
   const settings = await getUserSettings(userName);
   return NextResponse.json(toResponse(settings));
 };
@@ -113,6 +124,7 @@ export const PATCH = async (request: Request) => {
     return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
   }
 
+  await removeLegacyPasswordlessToken(userName);
   const body = (await request.json()) as UpdateBody | null;
   if (!body || typeof body !== 'object' || !('section' in body)) {
     return NextResponse.json({ error: 'Invalid payload' }, { status: 400 });
@@ -160,14 +172,6 @@ export const PATCH = async (request: Request) => {
     }
   }
 
-  if (body.section === 'token') {
-    const token = cleanOptionalText(body.data?.token);
-
-    if (token) {
-      await updateUserRecord(userName, { token });
-    }
-  }
-
   if (body.section === 'coinalyze') {
     const apiKey = cleanOptionalText(body.data?.apiKey);
 
@@ -176,17 +180,41 @@ export const PATCH = async (request: Request) => {
     }
   }
 
-  if (body.section === 'openai') {
+  if (body.section === 'ai') {
+    const currentSettings = await getUserSettings(userName);
     const patch: Partial<UserRecord> = {};
     const apiKey = cleanOptionalText(body.data?.apiKey);
-    const apiEndpoint = cleanOptionalText(body.data?.apiEndpoint);
+    const apiEndpoint = normalizeAiEndpoint(body.data?.apiEndpoint);
+    const effectiveEndpoint = apiEndpoint || currentSettings.AI_API_ENDPOINT;
+    const responseLanguage = normalizeAiResponseLanguage(
+      body.data?.responseLanguage,
+    );
 
     if (apiKey) {
-      patch.OPENAI_API_KEY = apiKey;
+      patch.AI_API_KEY = apiKey;
+    }
+
+    if (body.data && 'apiEndpoint' in body.data && !apiEndpoint) {
+      return NextResponse.json(
+        { error: 'Invalid AI API endpoint URL' },
+        { status: 400 },
+      );
     }
 
     if (apiEndpoint) {
-      patch.OPENAI_API_ENDPOINT = apiEndpoint;
+      patch.AI_API_ENDPOINT = apiEndpoint;
+    }
+
+    if (
+      body.data &&
+      ('apiEndpoint' in body.data || 'model' in body.data) &&
+      effectiveEndpoint
+    ) {
+      patch.AI_MODEL = normalizeAiModel(body.data?.model, effectiveEndpoint);
+    }
+
+    if (body.data && 'responseLanguage' in body.data) {
+      patch.AI_RESPONSE_LANGUAGE = responseLanguage;
     }
 
     if (hasKeys(patch)) {