diff --git a/app/api/quotes/route.ts b/app/api/quotes/route.ts new file mode 100644 index 0000000..ffe5fb5 --- /dev/null +++ b/app/api/quotes/route.ts @@ -0,0 +1,23 @@ +import { NextRequest, NextResponse } from "next/server"; +import { getSession } from "@/lib/better-auth/auth"; +import { getLiveQuotes } from "@/lib/actions/finnhub.actions"; + +const MAX_SYMBOLS = 25; +const SYMBOL_PATTERN = /^[A-Z0-9.:\-]{1,20}$/; + +// Polled by on-screen prices. Signed-in only and capped, so nobody can burn the shared Finnhub quota. +export async function GET(req: NextRequest) { + const session = await getSession(); + if (!session?.user) return NextResponse.json({ error: "Unauthorized" }, { status: 401 }); + + const symbols = [...new Set( + (req.nextUrl.searchParams.get("symbols") ?? "") + .split(",") + .map((s) => s.trim().toUpperCase()) + .filter((s) => SYMBOL_PATTERN.test(s)), + )].slice(0, MAX_SYMBOLS); + + return NextResponse.json(await getLiveQuotes(symbols), { + headers: { "Cache-Control": "private, max-age=5" }, + }); +} diff --git a/components/DataFreshness.tsx b/components/DataFreshness.tsx new file mode 100644 index 0000000..d2854c1 --- /dev/null +++ b/components/DataFreshness.tsx @@ -0,0 +1,14 @@ +import { isRealtime } from "@/lib/market-data"; + +// Honest label for how old a number is: "Live" in realtime mode, otherwise the time of the last trade. +const DataFreshness = ({ tradeTime }: { tradeTime?: number }) => { + if (isRealtime) { + return Live · 15s; + } + const asOf = tradeTime + ? new Date(tradeTime * 1000).toLocaleString('en-US', { month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit' }) + : null; + return {asOf ? `As of ${asOf}` : 'Delayed'} · refreshed hourly; +}; + +export default DataFreshness; diff --git a/hooks/useLiveQuotes.ts b/hooks/useLiveQuotes.ts new file mode 100644 index 0000000..69bab96 --- /dev/null +++ b/hooks/useLiveQuotes.ts @@ -0,0 +1,37 @@ +'use client'; + +import { useEffect, useState } from "react"; +import { isRealtime } from "@/lib/market-data"; + +export type LiveQuote = { c?: number; d?: number; dp?: number; h?: number; l?: number; o?: number; pc?: number; t?: number }; + +// Realtime mode only: polls the shared /api/quotes cache while the tab is visible. +// In cached mode prices come from the server render and refresh hourly for everyone. +export function useLiveQuotes(symbols: string[], intervalMs = 15_000) { + const [quotes, setQuotes] = useState>({}); + const key = symbols.join(","); + + useEffect(() => { + if (!key || !isRealtime) return; + let cancelled = false; + + const load = async () => { + if (document.visibilityState !== "visible") return; + try { + const res = await fetch(`/api/quotes?symbols=${encodeURIComponent(key)}`); + if (res.ok && !cancelled) setQuotes(await res.json()); + } catch { /* keep the last good prices */ } + }; + const onVisibility = () => { if (document.visibilityState === "visible") load(); }; + + const interval = setInterval(load, intervalMs); + document.addEventListener("visibilitychange", onVisibility); + return () => { + cancelled = true; + clearInterval(interval); + document.removeEventListener("visibilitychange", onVisibility); + }; + }, [key, intervalMs]); + + return quotes; +} diff --git a/lib/actions/finnhub.actions.ts b/lib/actions/finnhub.actions.ts index 0c9fcb7..cddb445 100644 --- a/lib/actions/finnhub.actions.ts +++ b/lib/actions/finnhub.actions.ts @@ -1,16 +1,38 @@ 'use server'; import { getDateRange, validateArticle, formatArticle } from '@/lib/utils'; -import { POPULAR_STOCK_SYMBOLS } from '@/lib/constants'; +import { POPULAR_STOCKS } from '@/lib/constants'; import { cache } from 'react'; +import { QUOTE_TTL_SECONDS } from '@/lib/market-data'; +import { hasFinnhubQuotes } from '@/lib/markets'; const FINNHUB_BASE_URL = 'https://finnhub.io/api/v1'; -const NEXT_PUBLIC_FINNHUB_API_KEY = process.env.NEXT_PUBLIC_FINNHUB_API_KEY ?? ''; +// Key pool: each free key has its own 60 req/min, so N keys = N x the quota. Rotated per request. +const FINNHUB_KEYS = (process.env.FINNHUB_API_KEYS || process.env.NEXT_PUBLIC_FINNHUB_API_KEY || process.env.FINNHUB_API_KEY || '') + .split(',') + .map((k) => k.trim()) + .filter(Boolean); +let nextKeyIndex = 0; +const FETCH_TIMEOUT_MS = 5000; +// Finnhub stalls bursts of parallel requests from one key (measured: 4 at once -> most hang), +// so calls are queued. ponytail: per-instance limiter; a shared queue (Redis) if instances multiply. +const MAX_IN_FLIGHT_PER_KEY = 2; +const MAX_CACHE_ENTRIES = 1000; +const FAILURE_TTL_MS = 60_000; +// Quotes are shared across everyone looking at a symbol: Finnhub cost scales with symbols, not users +const LIVE_QUOTE_TTL = QUOTE_TTL_SECONDS; +// Long-lived responses also go to the Next data cache, which Vercel shares across all instances +const SHARED_CACHE_MIN_TTL = 60; type FinnhubQuote = { - c?: number; - d?: number; - dp?: number; + c?: number; // current + d?: number; // change + dp?: number; // change % + h?: number; // day high + l?: number; // day low + o?: number; // open + pc?: number; // previous close + t?: number; // unix time of the last trade }; type FinnhubCompanyProfile = { @@ -20,6 +42,8 @@ type FinnhubCompanyProfile = { marketCapitalization?: number; name?: string; ticker?: string; + finnhubIndustry?: string; + weburl?: string; }; type SearchStockCandidate = FinnhubSearchResult & { @@ -33,20 +57,92 @@ const FINNHUB_EXCHANGE_SUFFIXES = new Set([ 'TA', 'TO', 'TW', 'TWO', 'V', 'VI', 'WA', ]); -async function fetchJSON(url: string, revalidateSeconds?: number): Promise { - const options: RequestInit & { next?: { revalidate?: number } } = revalidateSeconds - ? { cache: 'force-cache', next: { revalidate: revalidateSeconds } } - : { cache: 'no-store' }; +// Thrown instead of calling Finnhub while an endpoint is in its failure cool-down; not worth logging again. +class RecentFailure extends Error {} +const logFailure = (what: string, symbol: string, e: unknown) => { + if (!(e instanceof RecentFailure)) console.error(`Error fetching ${what} for`, symbol, e); +}; - const res = await fetch(url, options); - if (!res.ok) { - const text = await res.text().catch(() => ''); - throw new Error(`Fetch failed ${res.status}: ${text}`); +let activeRequests = 0; +const waitingForSlot: (() => void)[] = []; +const inFlight = new Map>(); +const responseCache = new Map(); + +async function withSlot(run: () => Promise): Promise { + if (activeRequests >= MAX_IN_FLIGHT_PER_KEY * Math.max(1, FINNHUB_KEYS.length)) await new Promise((resolve) => waitingForSlot.push(resolve)); + activeRequests++; + try { + return await run(); + } finally { + activeRequests--; + waitingForSlot.shift()?.(); } - return (await res.json()) as T; } -export { fetchJSON }; +// The token travels in a header, so cache keys are the same whichever key served them. +// On 429 the next key in the pool gets a turn. +async function fetchWithKeyPool(url: string, ttl: number) { + if (FINNHUB_KEYS.length === 0) throw new Error('No Finnhub API key configured (FINNHUB_API_KEYS)'); + let res: Response | null = null; + for (let attempt = 0; attempt < FINNHUB_KEYS.length; attempt++) { + const key = FINNHUB_KEYS[nextKeyIndex++ % FINNHUB_KEYS.length]; + res = await fetch(url, { + headers: { 'X-Finnhub-Token': key }, + // Without a timeout a stalled Finnhub socket holds the page for Node's 300s default + signal: AbortSignal.timeout(FETCH_TIMEOUT_MS), + ...(ttl >= SHARED_CACHE_MIN_TTL ? { next: { revalidate: ttl } } : { cache: 'no-store' as const }), + }); + if (res.status !== 429) break; + } + return res!; +} + +// One network call per URL at a time, however many pages ask for it +function request(url: string, ttl = 0): Promise { + let pending = inFlight.get(url) as Promise | undefined; + if (!pending) { + pending = withSlot(async () => { + const res = await fetchWithKeyPool(url, ttl); + if (!res.ok) { + const text = await res.text().catch(() => ''); + throw new Error(`Fetch failed ${res.status}: ${text}`); + } + return (await res.json()) as T; + }).finally(() => inFlight.delete(url)); + inFlight.set(url, pending); + } + return pending; +} + +// Stale-while-revalidate: after the first fetch nobody waits on Finnhub; expired entries +// are served instantly and refreshed in the background. +async function fetchJSON(url: string, revalidateSeconds = 0): Promise { + if (!revalidateSeconds) return request(url); + + const store = (entry: { value: unknown; freshUntil: number; failed?: boolean }) => { + if (responseCache.size >= MAX_CACHE_ENTRIES) responseCache.delete(responseCache.keys().next().value!); + responseCache.set(url, entry); + }; + const refresh = () => request(url, revalidateSeconds).then( + (value) => { + store({ value, freshUntil: Date.now() + revalidateSeconds * 1000 }); + return value; + }, + (error) => { + // A stalling endpoint fails fast for a minute instead of costing every visitor the full timeout + if (!responseCache.get(url) || responseCache.get(url)!.failed) { + store({ value: null, freshUntil: Date.now() + FAILURE_TTL_MS, failed: true }); + } + throw error; + }, + ); + + const hit = responseCache.get(url); + if (!hit || (hit.failed && hit.freshUntil < Date.now())) return refresh(); + if (hit.failed) throw new RecentFailure(`Finnhub request failed recently: ${url.split('?')[0]}`); + if (hit.freshUntil < Date.now()) refresh().catch(() => { /* keep serving the stale value */ }); + return hit.value as T; +} function getExchangeLabel(symbol: string, exchange?: string) { if (exchange?.trim()) { @@ -63,26 +159,33 @@ function getExchangeLabel(symbol: string, exchange?: string) { return FINNHUB_EXCHANGE_SUFFIXES.has(suffix) ? suffix : 'US'; } -export async function getQuote(symbol: string) { +export async function getQuote(symbol: string, revalidateSeconds = 0) { try { - const token = NEXT_PUBLIC_FINNHUB_API_KEY; - const url = `${FINNHUB_BASE_URL}/quote?symbol=${encodeURIComponent(symbol)}&token=${token}`; - // No caching for real-time price - return await fetchJSON(url, 0); + const url = `${FINNHUB_BASE_URL}/quote?symbol=${encodeURIComponent(symbol)}`; + // Real-time by default; shared views pass a short cache to stay inside Finnhub's 60 req/min + return await fetchJSON(url, revalidateSeconds); } catch (e) { - console.error('Error fetching quote for', symbol, e); + logFailure('quote', symbol, e); return null; } } +// Shared, short-lived quotes for anything shown live on screen (pages and /api/quotes) +export async function getLiveQuotes(symbols: string[]) { + // Symbols the free plan can't price are skipped instead of spending a request on a 403 + const quotes = await Promise.all(symbols.map((s) => (hasFinnhubQuotes(s) ? getQuote(s, LIVE_QUOTE_TTL) : null))); + return Object.fromEntries(symbols.map((s, i) => [s, quotes[i]?.c ? quotes[i] : null])); +} + export async function getCompanyProfile(symbol: string) { + // Profiles exist for stocks Finnhub free covers; crypto pairs and non-US listings have none + if (symbol.includes(':') || !hasFinnhubQuotes(symbol)) return null; try { - const token = NEXT_PUBLIC_FINNHUB_API_KEY; - const url = `${FINNHUB_BASE_URL}/stock/profile2?symbol=${encodeURIComponent(symbol)}&token=${token}`; + const url = `${FINNHUB_BASE_URL}/stock/profile2?symbol=${encodeURIComponent(symbol)}`; // Cache profile for 24 hours return await fetchJSON(url, 86400); } catch (e) { - console.error('Error fetching profile for', symbol, e); + logFailure('profile', symbol, e); return null; } } @@ -92,10 +195,10 @@ export async function getWatchlistData(symbols: string[]) { // Fetch quotes and profiles in parallel const promises = symbols.map(async (sym) => { - const [quote, profile] = await Promise.all([ - getQuote(sym), - getCompanyProfile(sym) - ]); + const covered = hasFinnhubQuotes(sym); + const [quote, profile] = covered + ? await Promise.all([getQuote(sym, LIVE_QUOTE_TTL), getCompanyProfile(sym)]) + : [null, null]; return { symbol: sym, @@ -117,8 +220,7 @@ export async function getWatchlistData(symbols: string[]) { export async function getNews(symbols?: string[]): Promise { try { const range = getDateRange(5); - const token = NEXT_PUBLIC_FINNHUB_API_KEY; - if (!token) { + if (FINNHUB_KEYS.length === 0) { throw new Error('FINNHUB API key is not configured'); } const cleanSymbols = (symbols || []) @@ -134,7 +236,7 @@ export async function getNews(symbols?: string[]): Promise await Promise.all( cleanSymbols.map(async (sym) => { try { - const url = `${FINNHUB_BASE_URL}/company-news?symbol=${encodeURIComponent(sym)}&from=${range.from}&to=${range.to}&token=${token}`; + const url = `${FINNHUB_BASE_URL}/company-news?symbol=${encodeURIComponent(sym)}&from=${range.from}&to=${range.to}`; const articles = await fetchJSON(url, 300); perSymbolArticles[sym] = (articles || []).filter(validateArticle); } catch (e) { @@ -168,7 +270,7 @@ export async function getNews(symbols?: string[]): Promise } // General market news fallback or when no symbols provided - const generalUrl = `${FINNHUB_BASE_URL}/news?category=general&token=${token}`; + const generalUrl = `${FINNHUB_BASE_URL}/news?category=general`; const general = await fetchJSON(generalUrl, 300); const seen = new Set(); @@ -192,8 +294,7 @@ export async function getNews(symbols?: string[]): Promise export const searchStocks = cache(async (query?: string): Promise => { try { - const token = NEXT_PUBLIC_FINNHUB_API_KEY; - if (!token) { + if (FINNHUB_KEYS.length === 0) { // If no token, log and return empty to avoid throwing per requirements console.error('Error in stock search:', new Error('FINNHUB API key is not configured')); return []; @@ -204,40 +305,16 @@ export const searchStocks = cache(async (query?: string): Promise { - try { - const url = `${FINNHUB_BASE_URL}/stock/profile2?symbol=${encodeURIComponent(sym)}&token=${token}`; - // Revalidate every hour - const profile = await fetchJSON(url, 3600); - return { sym, profile } as { sym: string; profile: FinnhubCompanyProfile | null }; - } catch (e) { - console.error('Error fetching profile2 for', sym, e); - return { sym, profile: null } as { sym: string; profile: FinnhubCompanyProfile | null }; - } - }) - ); - - results = profiles - .map(({ sym, profile }) => { - const symbol = sym.toUpperCase(); - const name: string | undefined = profile?.name || profile?.ticker || undefined; - const exchange: string | undefined = profile?.exchange || undefined; - if (!name) return undefined; - const r: SearchStockCandidate = { - symbol, - description: name, - displaySymbol: symbol, - type: 'Common Stock', - }; - r.__exchange = exchange; - return r; - }) - .filter((x): x is SearchStockCandidate => Boolean(x)); + // Shown in the palette on every page, so no API calls: Finnhub's free tier is 60 req/min + results = POPULAR_STOCKS.map(({ symbol, name, exchange }) => ({ + symbol, + description: name, + displaySymbol: symbol, + type: 'Common Stock', + __exchange: exchange, + })); } else { - const url = `${FINNHUB_BASE_URL}/search?q=${encodeURIComponent(trimmed)}&token=${token}`; + const url = `${FINNHUB_BASE_URL}/search?q=${encodeURIComponent(trimmed)}`; const data = await fetchJSON(url, 1800); results = Array.isArray(data?.result) ? data.result : []; } diff --git a/lib/market-data.ts b/lib/market-data.ts new file mode 100644 index 0000000..dcbd92a --- /dev/null +++ b/lib/market-data.ts @@ -0,0 +1,11 @@ +// How fresh market numbers are. Safe to import from client components (no keys here). +// +// cached (default) Public instance: quotes refresh hourly, shared by every user via the data cache. +// realtime OpenStock Cloud or self-hosted with your own Finnhub keys: quotes refresh every 15s. +export type DataMode = 'cached' | 'realtime'; + +export const DATA_MODE: DataMode = process.env.NEXT_PUBLIC_OPENSTOCK_DATA_MODE === 'realtime' ? 'realtime' : 'cached'; + +export const QUOTE_TTL_SECONDS = DATA_MODE === 'realtime' ? 15 : 3600; + +export const isRealtime = DATA_MODE === 'realtime';