mirror of
https://github.com/MBombeck/HealthLog.git
synced 2026-11-15 23:12:04 +00:00
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.
78 lines
2.5 KiB
TypeScript
78 lines
2.5 KiB
TypeScript
import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
|
|
|
|
/**
|
|
* v1.4.28 R3a FB-D2 — provider timeout fallback for the pulse-status
|
|
* route. When the upstream `generateCompletion` call does not resolve
|
|
* inside the 20-second budget the route returns a deterministic
|
|
* cached-style envelope so the InsightStatusCard renders the
|
|
* fallback text instead of spinning behind React-Query's default
|
|
* retries.
|
|
*/
|
|
|
|
vi.mock("@/lib/db", () => ({
|
|
prisma: {
|
|
user: { findUnique: vi.fn() },
|
|
auditLog: { findFirst: vi.fn(), create: vi.fn() },
|
|
measurement: { findMany: vi.fn() },
|
|
moodEntry: { findMany: vi.fn() },
|
|
},
|
|
}));
|
|
|
|
vi.mock("@/lib/ai/provider", () => ({
|
|
resolveProvider: vi.fn(),
|
|
}));
|
|
|
|
vi.mock("@/lib/insights/memory", () => ({
|
|
getPreviousInsightContext: vi.fn().mockResolvedValue(null),
|
|
formatPreviousContextForPrompt: vi.fn().mockReturnValue(""),
|
|
}));
|
|
|
|
import { prisma } from "@/lib/db";
|
|
import { resolveProvider } from "@/lib/ai/provider";
|
|
import { generatePulseStatusForUser } from "../pulse-status";
|
|
|
|
beforeEach(() => {
|
|
vi.resetAllMocks();
|
|
vi.useFakeTimers();
|
|
});
|
|
|
|
afterEach(() => {
|
|
vi.useRealTimers();
|
|
});
|
|
|
|
describe("generatePulseStatusForUser — provider timeout fallback", () => {
|
|
it("returns a cached-style envelope when the provider exceeds 20 s", async () => {
|
|
vi.mocked(prisma.user.findUnique).mockResolvedValue({
|
|
dateOfBirth: null,
|
|
gender: null,
|
|
} as never);
|
|
vi.mocked(prisma.auditLog.findFirst).mockResolvedValue(null);
|
|
vi.mocked(prisma.measurement.findMany).mockResolvedValue([
|
|
{ value: 72, measuredAt: new Date() },
|
|
] as never);
|
|
vi.mocked(prisma.moodEntry.findMany).mockResolvedValue([] as never);
|
|
|
|
// Provider stalls indefinitely.
|
|
vi.mocked(resolveProvider).mockResolvedValue({
|
|
type: "anthropic",
|
|
generateCompletion: vi.fn(
|
|
() => new Promise<{ content: string }>(() => {}),
|
|
),
|
|
} as never);
|
|
|
|
const promise = generatePulseStatusForUser("user-1", { locale: "en" });
|
|
// Advance past the 20-second budget so the timeout race wins.
|
|
await vi.advanceTimersByTimeAsync(21_000);
|
|
const result = await promise;
|
|
|
|
expect(result.hasProvider).toBe(true);
|
|
expect(result.cached).toBe(true);
|
|
expect(typeof result.text).toBe("string");
|
|
expect(result.text?.length ?? 0).toBeGreaterThan(0);
|
|
// The route must NOT persist a fallback into the audit cache —
|
|
// a transient provider stall should not poison tomorrow's cache
|
|
// hit.
|
|
expect(prisma.auditLog.create).not.toHaveBeenCalled();
|
|
});
|
|
});
|