@tradejs/app 1.0.5 → 1.0.8

package/src/app/store/tickers.ts

@@ -1,11 +1,19 @@
 import { useEffect, useMemo, useCallback } from 'react';
 import { create } from 'zustand';
 import { persist } from 'zustand/middleware';
+import { get, set } from 'idb-keyval';
 import _ from 'lodash';
 import { scan } from '@actions/scanner';
 import { Items } from '@tradejs/types';
 
 const LOCAL_STORAGE_KEY = 'tickers';
+const TICKERS_CACHE_TTL_MS = 10 * 60 * 1000;
+const EMPTY_ITEMS: Items = [];
+
+type TickersCacheRecord = {
+  savedAt: number;
+  items: Items;
+};
 
 interface FavoriteTickersState {
   favorites: string[];
@@ -35,38 +43,118 @@ const useFavoriteTickersStore = create<FavoriteTickersState>()(
 );
 
 interface TickersScannerState {
-  provider: string;
-  tickers: Items;
-  setTickers: (provider: string, tickers: Items) => void;
+  tickersByProvider: Record<string, Items>;
+  loadedAtByProvider: Record<string, number>;
+  inFlightByProvider: Record<string, Promise<Items> | undefined>;
+  setTickers: (provider: string, tickers: Items, loadedAt?: number) => void;
+  setInFlight: (provider: string, request?: Promise<Items>) => void;
 }
 
 const useScannerStore = create<TickersScannerState>((set) => ({
-  provider: 'bybit',
-  tickers: [] as Items,
-  setTickers: (provider, coins) =>
-    set(() => ({ provider, tickers: _.sortBy(coins, 'label') })),
+  tickersByProvider: {},
+  loadedAtByProvider: {},
+  inFlightByProvider: {},
+  setTickers: (provider, coins, loadedAt = Date.now()) =>
+    set((state) => ({
+      tickersByProvider: {
+        ...state.tickersByProvider,
+        [provider]: _.sortBy(coins, 'label'),
+      },
+      loadedAtByProvider: {
+        ...state.loadedAtByProvider,
+        [provider]: loadedAt,
+      },
+      inFlightByProvider: {
+        ...state.inFlightByProvider,
+        [provider]: undefined,
+      },
+    })),
+  setInFlight: (provider, request) =>
+    set((state) => ({
+      inFlightByProvider: {
+        ...state.inFlightByProvider,
+        [provider]: request,
+      },
+    })),
 }));
 
-export const useTickers = (provider = 'bybit') => {
+const getTickersCacheKey = (provider: string) => `tickers:${provider}`;
+
+const isFresh = (savedAt: number) =>
+  Date.now() - savedAt < TICKERS_CACHE_TTL_MS;
+
+const loadTickersForProvider = async (provider: string) => {
+  const {
+    tickersByProvider,
+    loadedAtByProvider,
+    inFlightByProvider,
+    setTickers,
+    setInFlight,
+  } = useScannerStore.getState();
+  const memoryTickers = tickersByProvider[provider] ?? [];
+  const loadedAt = loadedAtByProvider[provider] ?? 0;
+
+  if (memoryTickers.length && isFresh(loadedAt)) {
+    return memoryTickers;
+  }
+
+  const inFlight = inFlightByProvider[provider];
+  if (inFlight) {
+    return inFlight;
+  }
+
+  const pending = (async () => {
+    const cached = (await get(
+      getTickersCacheKey(provider),
+    )) as TickersCacheRecord | null;
+
+    if (cached?.items?.length && isFresh(cached.savedAt)) {
+      setTickers(provider, cached.items, cached.savedAt);
+      return cached.items;
+    }
+
+    const coins = await scan(provider);
+    const savedAt = Date.now();
+    setTickers(provider, coins, savedAt);
+    await set(getTickersCacheKey(provider), {
+      savedAt,
+      items: coins,
+    } satisfies TickersCacheRecord);
+    return coins;
+  })().finally(() => {
+    useScannerStore.getState().setInFlight(provider, undefined);
+  });
+
+  setInFlight(provider, pending);
+  return pending;
+};
+
+export const useTickers = (
+  provider = 'bybit',
+  options: { enabled?: boolean } = {},
+) => {
+  const { enabled = true } = options;
   const favorites = useFavoriteTickersStore((s) => s.favorites);
-  const loadedProvider = useScannerStore((s) => s.provider);
-  const tickers = useScannerStore((s) => s.tickers);
+  const tickers = useScannerStore(
+    (s) => s.tickersByProvider[provider] ?? EMPTY_ITEMS,
+  );
   const toggleFavorite = useFavoriteTickersStore((s) => s.toggleFavorite);
-  const setTickers = useScannerStore((s) => s.setTickers);
   const checkIsFavorite = useCallback(
     (ticker: string) => favorites.includes(ticker),
     [favorites],
   );
+  const ensureLoaded = useCallback(
+    () => loadTickersForProvider(provider),
+    [provider],
+  );
 
   useEffect(() => {
-    if (tickers.length && loadedProvider === provider) {
+    if (!enabled) {
       return;
     }
 
-    scan(provider).then((coins) => {
-      setTickers(provider, coins);
-    });
-  }, [loadedProvider, provider, setTickers, tickers.length]);
+    void ensureLoaded();
+  }, [enabled, ensureLoaded]);
 
   const items = useMemo(() => {
     const favoriteItems = tickers
@@ -84,6 +172,14 @@ export const useTickers = (provider = 'bybit') => {
     favorites,
     checkIsFavorite,
     toggleFavorite,
-    setTickers,
+    ensureLoaded,
   };
 };
+
+export const resetTickersStoreForTests = () => {
+  useScannerStore.setState({
+    tickersByProvider: {},
+    loadedAtByProvider: {},
+    inFlightByProvider: {},
+  });
+};

package/src/proxy.ts

@@ -1,38 +1,14 @@
 import { NextResponse, type NextRequest } from 'next/server';
 import { encode, getToken } from 'next-auth/jwt';
-import { getData, getKeys, redisKeys } from '@tradejs/infra/redis';
+import { consumeScreenshotSessionToken } from '@tradejs/infra/redis';
 
 const SIGNIN_PATH = '/routes/signin';
 const SCREENSHOT_API_PREFIX = '/api/files/screenshot';
+const SCREENSHOT_SESSION_QUERY_PARAM = 'screenshotToken';
 const SESSION_COOKIE_NAME = 'authjs.session-token';
 const SECURE_SESSION_COOKIE_NAME = '__Secure-authjs.session-token';
 const SESSION_MAX_AGE = 30 * 24 * 60 * 60;
-const PUBLIC_FILE_RE = /\.(?:png|jpg|jpeg|webp|gif|svg|ico|txt|xml|json|map)$/i;
-
-const getRootToken = async (): Promise<string | null> => {
-  const rootUser = await getData(redisKeys.user('root'), null);
-  if (!rootUser || typeof rootUser !== 'object') return null;
-  const record = rootUser as Record<string, unknown>;
-  const token = record.token;
-  return typeof token === 'string' ? token : null;
-};
-
-const findUserByToken = async (token: string): Promise<string | null> => {
-  const keys = await getKeys(redisKeys.users());
-  for (const key of keys) {
-    const userNameFromKey = key.slice(redisKeys.users().length);
-    if (!userNameFromKey) continue;
-
-    const user = await getData(redisKeys.user(userNameFromKey), null);
-    if (!user || typeof user !== 'object') continue;
-    const record = user as Record<string, unknown>;
-    if (record.token !== token) continue;
-    const userName =
-      typeof record.userName === 'string' ? record.userName : userNameFromKey;
-    if (userName) return userName;
-  }
-  return null;
-};
+const PUBLIC_FILE_RE = /\.(?:png|jpg|jpeg|webp|gif|svg|ico|txt|xml|map)$/i;
 
 const isSecureRequest = (req: NextRequest) => {
   if (req.nextUrl.protocol === 'https:') return true;
@@ -46,6 +22,7 @@ const issueSession = async (
   req: NextRequest,
   userName: string,
   response: NextResponse,
+  maxAge = SESSION_MAX_AGE,
 ) => {
   const secret = process.env.AUTH_SECRET ?? process.env.NEXTAUTH_SECRET;
   if (!secret) return response;
@@ -56,7 +33,7 @@ const issueSession = async (
     token: { id: userName, name: userName },
     secret,
     salt: cookieName,
-    maxAge: SESSION_MAX_AGE,
+    maxAge,
   });
 
   response.cookies.set(cookieName, jwt, {
@@ -64,7 +41,7 @@ const issueSession = async (
     sameSite: 'lax',
     path: '/',
     secure,
-    maxAge: SESSION_MAX_AGE,
+    maxAge,
   });
 
   return response;
@@ -79,33 +56,29 @@ export const proxy = async (req: NextRequest) => {
     pathname.startsWith(SIGNIN_PATH) ||
     pathname.startsWith('/api/auth') ||
     pathname.startsWith(SCREENSHOT_API_PREFIX) ||
-    PUBLIC_FILE_RE.test(pathname)
+    (!pathname.startsWith('/api') && PUBLIC_FILE_RE.test(pathname))
   ) {
     return NextResponse.next();
   }
 
-  const queryToken = req.nextUrl.searchParams.get('token');
-  if (queryToken) {
-    const rootToken = await getRootToken();
-    if (rootToken && queryToken === rootToken) {
-      const cleaned = new URL(req.url);
-      cleaned.searchParams.delete('token');
-      const res =
-        req.method === 'GET' && !pathname.startsWith('/api')
-          ? NextResponse.redirect(cleaned)
-          : NextResponse.next();
-      return issueSession(req, 'root', res);
-    }
-
-    const userName = await findUserByToken(queryToken);
+  const screenshotToken = req.nextUrl.searchParams.get(
+    SCREENSHOT_SESSION_QUERY_PARAM,
+  );
+  if (
+    screenshotToken &&
+    req.method === 'GET' &&
+    pathname.startsWith('/routes/dashboard/')
+  ) {
+    const userName = await consumeScreenshotSessionToken(screenshotToken);
     if (userName) {
       const cleaned = new URL(req.url);
-      cleaned.searchParams.delete('token');
-      const res =
-        req.method === 'GET' && !pathname.startsWith('/api')
-          ? NextResponse.redirect(cleaned)
-          : NextResponse.next();
-      return issueSession(req, userName, res);
+      cleaned.searchParams.delete(SCREENSHOT_SESSION_QUERY_PARAM);
+      return issueSession(
+        req,
+        userName,
+        NextResponse.redirect(cleaned),
+        15 * 60,
+      );
     }
   }