@tradejs/app 1.0.5 → 1.0.8

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

@@ -0,0 +1,244 @@
+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,
+  type UserSettings,
+} from '@tradejs/infra/userSettings';
+import { getCurrentUserName } from '@app/lib/currentUser';
+
+export const dynamic = 'force-dynamic';
+
+type UpdateBody =
+  | {
+      section: 'bybit';
+      data?: {
+        apiKey?: string;
+        apiSecret?: string;
+      };
+    }
+  | {
+      section: 'coinalyze';
+      data?: {
+        apiKey?: string;
+      };
+    }
+  | {
+      section: 'ai';
+      data?: {
+        apiKey?: string;
+        apiEndpoint?: string;
+        model?: string;
+        responseLanguage?: string;
+      };
+    }
+  | {
+      section: 'telegram';
+      data?: {
+        botToken?: string;
+        chatId?: string;
+      };
+    }
+  | {
+      section: 'password';
+      data?: {
+        password?: string;
+        confirmPassword?: string;
+      };
+    };
+
+const cleanText = (value: unknown): string =>
+  typeof value === 'string' ? value.trim() : '';
+
+const cleanOptionalText = (value: unknown): string | undefined => {
+  if (typeof value !== 'string') {
+    return undefined;
+  }
+
+  const trimmed = value.trim();
+  return trimmed ? trimmed : undefined;
+};
+
+const maskSecret = (value: string) => {
+  const trimmed = cleanText(value);
+  if (!trimmed) {
+    return '';
+  }
+
+  return `${'*'.repeat(12)}${trimmed.slice(-4) || trimmed}`;
+};
+
+const toResponse = (settings: UserSettings) => ({
+  userName: settings.userName,
+  settings: {
+    bybit: {
+      apiKey: maskSecret(settings.BYBIT_API_KEY),
+      apiSecret: maskSecret(settings.BYBIT_API_SECRET),
+    },
+    coinalyze: {
+      apiKey: maskSecret(settings.COINALYZE_API_KEY),
+    },
+    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),
+      chatId: settings.TG_CHAT_ID,
+    },
+  },
+});
+
+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));
+};
+
+export const PATCH = async (request: Request) => {
+  const userName = await getCurrentUserName();
+  if (!userName) {
+    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 });
+  }
+
+  if (body.section === 'password') {
+    const password = String(body.data?.password || '');
+    const confirmPassword = String(body.data?.confirmPassword || '');
+
+    if (!password) {
+      return NextResponse.json(
+        { error: 'Password is required' },
+        { status: 400 },
+      );
+    }
+
+    if (password !== confirmPassword) {
+      return NextResponse.json(
+        { error: 'Password confirmation does not match' },
+        { status: 400 },
+      );
+    }
+
+    const passwordHash = await bcrypt.hash(password, 10);
+    await updateUserRecord(userName, { passwordHash });
+    const settings = await getUserSettings(userName);
+    return NextResponse.json(toResponse(settings));
+  }
+
+  if (body.section === 'bybit') {
+    const patch: Partial<UserRecord> = {};
+    const apiKey = cleanOptionalText(body.data?.apiKey);
+    const apiSecret = cleanOptionalText(body.data?.apiSecret);
+
+    if (apiKey) {
+      patch.BYBIT_API_KEY = apiKey;
+    }
+
+    if (apiSecret) {
+      patch.BYBIT_API_SECRET = apiSecret;
+    }
+
+    if (hasKeys(patch)) {
+      await updateUserRecord(userName, patch);
+    }
+  }
+
+  if (body.section === 'coinalyze') {
+    const apiKey = cleanOptionalText(body.data?.apiKey);
+
+    if (apiKey) {
+      await updateUserRecord(userName, { COINALYZE_API_KEY: apiKey });
+    }
+  }
+
+  if (body.section === 'ai') {
+    const currentSettings = await getUserSettings(userName);
+    const patch: Partial<UserRecord> = {};
+    const apiKey = cleanOptionalText(body.data?.apiKey);
+    const apiEndpoint = normalizeAiEndpoint(body.data?.apiEndpoint);
+    const effectiveEndpoint = apiEndpoint || currentSettings.AI_API_ENDPOINT;
+    const responseLanguage = normalizeAiResponseLanguage(
+      body.data?.responseLanguage,
+    );
+
+    if (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.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)) {
+      await updateUserRecord(userName, patch);
+    }
+  }
+
+  if (body.section === 'telegram') {
+    const patch: Partial<UserRecord> = {};
+    const botToken = cleanOptionalText(body.data?.botToken);
+
+    if (botToken) {
+      patch.TG_BOT_TOKEN = botToken;
+    }
+
+    if (body.data && 'chatId' in body.data) {
+      patch.TG_CHAT_ID = cleanText(body.data.chatId);
+    }
+
+    if (hasKeys(patch)) {
+      await updateUserRecord(userName, patch);
+    }
+  }
+
+  const settings = await getUserSettings(userName);
+  return NextResponse.json(toResponse(settings));
+};

package/src/app/components/Dashboard/AiDrawer/index.tsx

@@ -1,6 +1,6 @@
 'use client';
 
-import { useCallback, useEffect, useState } from 'react';
+import { useEffect, useMemo, useState } from 'react';
 import {
   Button,
   CloseButton,
@@ -12,74 +12,42 @@ import {
   HStack,
   Stack,
   Text,
+  Alert,
   SkeletonCircle,
   SkeletonText,
 } from '@chakra-ui/react';
-import { AIChatMessage, AIChatHistory } from '@tradejs/types';
 import { GiArtificialHive } from 'react-icons/gi';
-import { useFilters } from '@store';
-import { sendMessage, getHistory } from '@actions/ai';
+import { useAiChatStore, useFilters } from '@store';
 import { Message } from './Message';
 
 export const AiDrawer = () => {
   const [open, setOpen] = useState(false);
-  const [loading, setLoading] = useState(true);
   const [input, setInput] = useState('');
-  const [messages, setMessages] = useState<AIChatHistory>([]);
   const { filters } = useFilters();
-
-  const loadHistory = useCallback(async () => {
-    setLoading(true);
-
-    const history = await getHistory(filters.symbol);
-
-    setMessages(history);
-
-    setLoading(false);
-  }, [filters.symbol]);
+  const getChat = useAiChatStore((s) => s.getChat);
+  const loadHistory = useAiChatStore((s) => s.loadHistory);
+  const sendPrompt = useAiChatStore((s) => s.sendPrompt);
+  const sendQuickCommand = useAiChatStore((s) => s.sendQuickCommand);
+  const chat = getChat(filters.symbol);
+  const { loading, sending, error, messages } = chat;
+  const isBusy = loading || sending;
+  const canSend = useMemo(
+    () => input.trim().length > 0 && !sending,
+    [input, sending],
+  );
 
   useEffect(() => {
-    void loadHistory();
-  }, [loadHistory]);
+    void loadHistory(filters.symbol);
+  }, [filters.symbol, loadHistory]);
 
   const handleSend = async () => {
     if (!input.trim()) return;
-
-    const message = {
-      from: 'user',
-      text: input,
-      command: 'prompt',
-    } as AIChatMessage;
-
-    setMessages((state) => [...state, message]);
-
-    const response = await sendMessage({ message, filters });
-
-    setMessages((state) => [...state, response]);
-
+    await sendPrompt(filters, input);
     setInput('');
   };
 
   const handleQuick = async (command: string) => {
-    let message: AIChatMessage | null = null;
-
-    if (command === '/line') {
-      message = {
-        from: 'user',
-        text: 'Какие наклонные линии можно построить на данном графике',
-        command,
-      };
-    }
-
-    if (!message) {
-      return;
-    }
-
-    setMessages((state) => [...state, message as AIChatMessage]);
-
-    const response = await sendMessage({ message, filters });
-
-    setMessages((state) => [...state, response]);
+    await sendQuickCommand(filters, command);
   };
 
   return (
@@ -106,6 +74,15 @@ export const AiDrawer = () => {
             </Drawer.Header>
 
             <Drawer.Body overflowY="auto" flex="1">
+              {error ? (
+                <Alert.Root status="error" mb={4}>
+                  <Alert.Indicator />
+                  <Alert.Content>
+                    <Alert.Title>AI chat error</Alert.Title>
+                    <Alert.Description>{error}</Alert.Description>
+                  </Alert.Content>
+                </Alert.Root>
+              ) : null}
               {loading ? (
                 <Stack gap="4" maxW="xs">
                   <HStack width="full">
@@ -128,6 +105,7 @@ export const AiDrawer = () => {
                 <Button
                   size="sm"
                   variant="outline"
+                  disabled={isBusy}
                   onClick={() => handleQuick('/line')}
                 >
                   /line
@@ -135,6 +113,7 @@ export const AiDrawer = () => {
                 <Button
                   size="sm"
                   variant="outline"
+                  disabled={isBusy}
                   onClick={() => handleQuick('/analyze')}
                 >
                   /analyze
@@ -148,10 +127,18 @@ export const AiDrawer = () => {
                 rows={3}
                 maxH="15lh"
                 value={input}
+                disabled={sending}
                 onChange={(e) => setInput(e.target.value)}
               />
 
-              <Button mt={2} size={'sm'} variant="subtle" onClick={handleSend}>
+              <Button
+                mt={2}
+                size={'sm'}
+                variant="subtle"
+                disabled={!canSend}
+                loading={sending}
+                onClick={handleSend}
+              >
                 Send
               </Button>
             </Drawer.Footer>

package/src/app/components/Shared/Filters/Backtest/index.tsx

@@ -6,7 +6,8 @@ import { Select } from '@UI';
 import { useFiltersContext } from '../context';
 
 export const SelectBacktest = () => {
-  const { filters, backtestFiles, onChangeFilters } = useFiltersContext();
+  const { filters, backtestFiles, onChangeFilters, ensureBacktestsLoaded } =
+    useFiltersContext();
   const STORAGE_KEY = 'backtest-strategy';
 
   const tests = useMemo(
@@ -127,10 +128,6 @@ export const SelectBacktest = () => {
     }
   };
 
-  if (_.isEmpty(tests) || _.isEmpty(strategyItems) || !selectedStrategy) {
-    return null;
-  }
-
   const strategyTests = tests.filter(
     (test) => test.data?.strategyName === selectedStrategy,
   );
@@ -142,6 +139,11 @@ export const SelectBacktest = () => {
         defaultValue={[selectedStrategy]}
         value={[selectedStrategy]}
         onChange={onChangeStrategy}
+        onOpenChange={(open) => {
+          if (open) {
+            void ensureBacktestsLoaded?.();
+          }
+        }}
         items={strategyItems}
         width="220px"
       />
@@ -150,6 +152,11 @@ export const SelectBacktest = () => {
         defaultValue={[filters.backtestId || '']}
         value={[filters.backtestId || '']}
         onChange={onChange}
+        onOpenChange={(open) => {
+          if (open) {
+            void ensureBacktestsLoaded?.();
+          }
+        }}
         items={[
           {
             label: 'Not selected',

package/src/app/components/Shared/Filters/Root/index.tsx

@@ -9,6 +9,8 @@ interface RootProps {
   backtestFiles: Items;
   filters: UIFilters;
   onChangeFilters?: OnChangeFilters;
+  ensureTickersLoaded?: () => void | Promise<unknown>;
+  ensureBacktestsLoaded?: () => void | Promise<unknown>;
 }
 
 export const Root = ({
@@ -16,11 +18,20 @@ export const Root = ({
   tickers,
   backtestFiles,
   onChangeFilters,
+  ensureTickersLoaded,
+  ensureBacktestsLoaded,
   children,
 }: PropsWithChildren<RootProps>) => {
   return (
     <FiltersContext.Provider
-      value={{ filters, tickers, backtestFiles, onChangeFilters }}
+      value={{
+        filters,
+        tickers,
+        backtestFiles,
+        onChangeFilters,
+        ensureTickersLoaded,
+        ensureBacktestsLoaded,
+      }}
     >
       {children}
     </FiltersContext.Provider>

package/src/app/components/Shared/Filters/Symbol/index.tsx

@@ -2,14 +2,13 @@
 
 import _ from 'lodash';
 import { SelectWithSearch } from '@UI';
-import { SkeletonText, Stack, Show } from '@chakra-ui/react';
 import { useFiltersContext } from '../context';
 
 interface SelectSymbolProps {}
 
 export const SelectSymbol = ({}: SelectSymbolProps) => {
-  const { filters, tickers, onChangeFilters } = useFiltersContext();
-  const loading = _.isEmpty(tickers);
+  const { filters, tickers, onChangeFilters, ensureTickersLoaded } =
+    useFiltersContext();
   const defaultInputValue =
     tickers.find(({ value }) => value === filters.symbol)?.label ||
     filters.symbol;
@@ -29,21 +28,17 @@ export const SelectSymbol = ({}: SelectSymbolProps) => {
   };
 
   return (
-    <Show
-      when={!loading}
-      fallback={
-        <Stack width="240px">
-          <SkeletonText height={8} noOfLines={1} />
-        </Stack>
-      }
-    >
-      <SelectWithSearch
-        defaultValue={[filters.symbol]}
-        defaultInputValue={defaultInputValue}
-        onChange={onChange}
-        items={tickers}
-        width="240px"
-      />
-    </Show>
+    <SelectWithSearch
+      defaultValue={[filters.symbol]}
+      defaultInputValue={defaultInputValue}
+      onChange={onChange}
+      onOpenChange={(open) => {
+        if (open) {
+          void ensureTickersLoaded?.();
+        }
+      }}
+      items={tickers}
+      width="240px"
+    />
   );
 };

package/src/app/components/Shared/Filters/context.ts

@@ -6,6 +6,8 @@ interface FiltersContextProps {
   tickers: Items;
   backtestFiles: Items;
   onChangeFilters?: OnChangeFilters;
+  ensureTickersLoaded?: () => void | Promise<unknown>;
+  ensureBacktestsLoaded?: () => void | Promise<unknown>;
 }
 
 export const FiltersContext = createContext<FiltersContextProps>(