mirror of
https://github.com/MBombeck/HealthLog.git
synced 2026-11-15 06:52:04 +00:00
Marc-André Bombeck
0d591ac928
The seven `*-status.ts` routes awaited `provider.generateCompletion`
with no client timeout. When the upstream stalled, React-Query's
three default retries plus exponential backoff stacked on top of
the upstream latency and the InsightStatusCard spun for up to 90 s
before the user saw the cached fallback or a generic failure. This
is the downstream half of FB-D2 ("pulse insights loads forever").
Add a small `withTimeout` helper that races the provider call
against a 20 s budget and resolves with a typed `{ timedOut, value }`
envelope. Every status route returns the no-key fallback text in a
cached-style response shape on timeout; the audit-log cache is NOT
written so a transient upstream stall cannot poison tomorrow's
hit. `retry: 0` on `useInsightStatus` stops the client from
re-firing the same expensive call after the deterministic fallback
lands.
Cap the per-route Prisma reads at the same time — `take: 365` for
PULSE / WEIGHT, `take: 1095` for the BP three-channel surfaces,
`take: 90` for MoodEntry, `take: 5000` for the general snapshot.
The downstream `applyPayloadBudget` trims further; without the cap
power users pulled tens of thousands of rows on every refresh.
iOS contract — `/api/insights/*-status` routes are web-only (iOS
runs its own on-device summaries against `/api/measurements/series`).
No public-API shape changes; pure server-internal hardening.
88 lines
3.1 KiB
TypeScript
88 lines
3.1 KiB
TypeScript
"use client";
|
|
|
|
import { useQuery } from "@tanstack/react-query";
|
|
|
|
import { useAuth } from "@/hooks/use-auth";
|
|
import { useTranslations } from "@/lib/i18n/context";
|
|
import { queryKeys } from "@/lib/query-keys";
|
|
|
|
/**
|
|
* Shape returned by every `/api/insights/<metric>-status` endpoint.
|
|
*
|
|
* - `hasProvider` — whether the user has configured an AI provider; the
|
|
* sub-page hides the status card entirely when false.
|
|
* - `text` — the rendered status string; null when the provider has
|
|
* not yet produced one.
|
|
* - `cached` — whether the payload came from the per-locale cache or a
|
|
* fresh provider round-trip.
|
|
* - `updatedAt` — ISO timestamp of the cached payload's creation, or
|
|
* null when the route has never produced a value.
|
|
*/
|
|
export interface InsightStatusData {
|
|
hasProvider: boolean;
|
|
text: string | null;
|
|
cached: boolean;
|
|
updatedAt: string | null;
|
|
}
|
|
|
|
/**
|
|
* Metric slugs the sub-pages render. Each slug is paired with the
|
|
* Insights-status endpoint and the matching `queryKeys.*` factory so
|
|
* the cache keys stay aligned across the whole app — a hard-coded
|
|
* `["insights", "weight-status", locale]` array typoed once is exactly
|
|
* the class of bug `queryKeys` was introduced to defend against.
|
|
*/
|
|
type InsightStatusMetric =
|
|
| "blood-pressure"
|
|
| "weight"
|
|
| "pulse"
|
|
| "bmi"
|
|
| "mood"
|
|
| "medication-compliance";
|
|
|
|
const QUERY_KEY_FACTORY: Record<
|
|
InsightStatusMetric,
|
|
(locale: string) => readonly unknown[]
|
|
> = {
|
|
"blood-pressure": queryKeys.insightsBpStatus,
|
|
weight: queryKeys.insightsWeightStatus,
|
|
pulse: queryKeys.insightsPulseStatus,
|
|
bmi: queryKeys.insightsBmiStatus,
|
|
mood: queryKeys.insightsMoodStatus,
|
|
"medication-compliance": queryKeys.insightsMedicationComplianceStatus,
|
|
};
|
|
|
|
/**
|
|
* Shared loader for the insight-status payload backing
|
|
* `/insights/<metric>` sub-pages. Five sub-pages previously copy-pasted
|
|
* the same 13-line useQuery block plus an identical `XxxStatusData`
|
|
* interface; the hook collapses them onto one helper plus the existing
|
|
* `queryKeys` factory so the next "add a metric" PR touches one map
|
|
* entry instead of an entire page module.
|
|
*
|
|
* Returns the `useQuery` result narrowed to the `InsightStatusData`
|
|
* payload — callers stay free to use `data` / `isLoading` / refetch
|
|
* helpers without an extra unwrap.
|
|
*/
|
|
export function useInsightStatus(metric: InsightStatusMetric) {
|
|
const { isAuthenticated } = useAuth();
|
|
const { locale } = useTranslations();
|
|
|
|
return useQuery({
|
|
queryKey: QUERY_KEY_FACTORY[metric](locale),
|
|
queryFn: async (): Promise<InsightStatusData> => {
|
|
const res = await fetch(`/api/insights/${metric}-status?locale=${locale}`);
|
|
if (!res.ok) throw new Error("Failed");
|
|
const json = (await res.json()) as { data: InsightStatusData };
|
|
return json.data;
|
|
},
|
|
enabled: isAuthenticated,
|
|
staleTime: 60 * 1000,
|
|
// v1.4.28 FB-D2 — the status route now returns a deterministic
|
|
// cached-style envelope on provider timeout. Retrying that response
|
|
// re-fires the same expensive upstream call and the user perceives
|
|
// a longer hang. Drop retries to surface the fallback immediately.
|
|
retry: 0,
|
|
});
|
|
}
|