mirror of
https://github.com/MBombeck/HealthLog.git
synced 2026-11-16 23:33:29 +00:00
v1.4.37 — final web polish before iOS focus
Carries the v1.4.36 perf carry-over for the full /api/analytics route (correlations + healthScore + bp_in_target on the rollup- coverage probe, 111s cold worst-case down to ~1.5-3s on power-user accounts), consolidates Apple Health step samples into a one-row- per-day list view with chevron drill-down and a nightly drain (~50x table compression once it converges), restores IntakeHistoryListV2 to the pre-v1.4.28 contract, converges every Coach affordance behind a single feature gate with an invariant test pin, lifts the medication-detail Mounjaro card to byte- equivalent parity with Ramipril, brings the Insights overview hero row to height parity, hardens getClientIp behind a new TRUST_CF_CONNECTING_IP env flag, ships the Arztbericht hero card on Settings -> Export, adds the Medikamenteneinnahme quick-add overlay to the dashboard, drops the timezone override toggle for a silent browser-zone auto-seed, and fixes the v1.4.36 red CI workflows. Documentation refreshed across all three repos with five new architecture diagrams in the Dracula palette. Unit suite 4354 -> 4486 passing; typecheck + lint clean.
This commit is contained in:
1 parent
0e2a99f8e7
commit
88028fa082
121 files changed
+13912
-1437
No files matched your search
@@ -19,12 +19,22 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
||||
|
||||
vi.mock("@/lib/db", () => ({
|
||||
prisma: {
|
||||
measurement: { findMany: vi.fn() },
|
||||
// v1.4.37 W2 — `ensureUserRollupsFresh` pokes `measurement.findFirst`
|
||||
// for the newest-measurement watermark; mock both shapes.
|
||||
measurement: {
|
||||
findMany: vi.fn(),
|
||||
findFirst: vi.fn().mockResolvedValue(null),
|
||||
},
|
||||
moodEntry: { findMany: vi.fn() },
|
||||
medicationIntakeEvent: { findMany: vi.fn() },
|
||||
medication: { findMany: vi.fn() },
|
||||
// v1.4.33 C1 — slim summaries slice runs through `$queryRaw`.
|
||||
$queryRaw: vi.fn(),
|
||||
// v1.4.33 C1 — slim summaries slice runs through `$queryRaw`. The
|
||||
// v1.4.36 per-type coverage probe and the v1.4.37 default-slice
|
||||
// probe also ride `$queryRaw`. Default to an empty coverage map so
|
||||
// the route falls back to the live aggregator branches and the
|
||||
// assertions stay byte-shape stable.
|
||||
$queryRaw: vi.fn().mockResolvedValue([]),
|
||||
$queryRawUnsafe: vi.fn().mockResolvedValue([]),
|
||||
// v1.4.35 — slim slice also reads DAY buckets; the freshness
|
||||
// watermark inside `ensureUserRollupsFresh` pokes `findFirst`.
|
||||
// Default both to empty so the parity check falls back to live
|
||||
@@ -32,7 +42,13 @@ vi.mock("@/lib/db", () => ({
|
||||
measurementRollup: {
|
||||
findMany: vi.fn().mockResolvedValue([]),
|
||||
findFirst: vi.fn().mockResolvedValue(null),
|
||||
deleteMany: vi.fn().mockResolvedValue({ count: 0 }),
|
||||
upsert: vi.fn().mockResolvedValue({}),
|
||||
},
|
||||
$transaction: vi.fn().mockImplementation(async (queries: unknown[]) => {
|
||||
if (Array.isArray(queries)) return Promise.all(queries);
|
||||
return undefined;
|
||||
}),
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -119,6 +135,29 @@ beforeEach(() => {
|
||||
vi.mocked(prisma.measurementRollup.findFirst).mockResolvedValue(
|
||||
null as never,
|
||||
);
|
||||
vi.mocked(prisma.measurementRollup.deleteMany).mockResolvedValue(
|
||||
{ count: 0 } as never,
|
||||
);
|
||||
vi.mocked(prisma.measurementRollup.upsert).mockResolvedValue(
|
||||
{} as never,
|
||||
);
|
||||
// v1.4.37 W2 — `ensureUserRollupsFresh` reads `measurement.findFirst`;
|
||||
// the per-type coverage probe + the rollup-recompute aggregator ride
|
||||
// `$queryRaw` / `$queryRawUnsafe`. Default to empty so the route
|
||||
// falls back to the live fast-path branches and the assertions stay
|
||||
// byte-shape stable.
|
||||
vi.mocked(prisma.measurement.findFirst).mockResolvedValue(null as never);
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
vi.mocked(prisma.$queryRaw as any).mockResolvedValue([]);
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
vi.mocked(prisma.$queryRawUnsafe as any).mockResolvedValue([]);
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
vi.mocked(prisma.$transaction as any).mockImplementation(
|
||||
async (queries: unknown) => {
|
||||
if (Array.isArray(queries)) return Promise.all(queries);
|
||||
return undefined;
|
||||
},
|
||||
);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
|
||||
+71
-594
@@ -7,60 +7,26 @@ import { cached, caches, type ServerCache } from "@/lib/cache/server-cache";
|
||||
import { summarize, type DataPoint } from "@/lib/analytics/trends";
|
||||
import { computeSummariesSlice } from "@/lib/analytics/summaries-slice";
|
||||
import { getBpTargets } from "@/lib/analytics/bp-targets";
|
||||
import { computeBpInTargetWindows } from "@/lib/analytics/bp-in-target";
|
||||
import { userDayKey, DEFAULT_TIMEZONE } from "@/lib/tz/resolver";
|
||||
import { calculateCompliance } from "@/lib/analytics/compliance";
|
||||
import {
|
||||
computeHealthScore,
|
||||
defaultWeightTargetFromHeight,
|
||||
type ContributingSource,
|
||||
type HealthScoreInput,
|
||||
type HealthScoreResult,
|
||||
} from "@/lib/analytics/health-score";
|
||||
import {
|
||||
correlateBpCompliance,
|
||||
correlateMoodPulse,
|
||||
correlateWeightWeekday,
|
||||
type CorrelationResult,
|
||||
} from "@/lib/insights/correlations";
|
||||
import type {
|
||||
MeasurementSource,
|
||||
MeasurementType,
|
||||
} from "@/generated/prisma/client";
|
||||
import { measurementTypeEnum } from "@/lib/validations/measurement";
|
||||
import { pickCanonicalSourceRows } from "@/lib/analytics/source-priority";
|
||||
import type { SourcePriorityMetricKey } from "@/lib/validations/source-priority";
|
||||
import { ensureUserRollupsFresh } from "@/lib/measurements/rollups";
|
||||
import { probeRollupCoverage } from "@/lib/measurements/rollup-coverage";
|
||||
import { computeBpInTargetFastPath } from "@/lib/analytics/bp-in-target-fast-path";
|
||||
import { computeUserHealthScoreFastPath } from "@/lib/analytics/health-score-fast-path";
|
||||
import { computeCorrelationHypothesesFastPath } from "@/lib/analytics/correlations-fast-path";
|
||||
import {
|
||||
cumulativeMetricKey,
|
||||
isCumulativeDaySumType,
|
||||
pickCumulativeDaySum,
|
||||
} from "@/lib/measurements/cumulative-day-sum";
|
||||
|
||||
export const dynamic = "force-dynamic";
|
||||
|
||||
/**
|
||||
* v1.4.36 W4c — cumulative MeasurementType → SourcePriorityMetricKey
|
||||
* for `pickCanonicalSourceRows`. Returns `null` for types without a
|
||||
* dedicated priority ladder (e.g. TIME_IN_DAYLIGHT), which fall
|
||||
* through the picker's "no ladder" pass-through branch.
|
||||
*/
|
||||
function cumulativeMetricKey(
|
||||
type: MeasurementType,
|
||||
): SourcePriorityMetricKey | null {
|
||||
switch (type) {
|
||||
case "ACTIVITY_STEPS":
|
||||
return "steps";
|
||||
case "ACTIVE_ENERGY_BURNED":
|
||||
return "activeEnergy";
|
||||
case "WALKING_RUNNING_DISTANCE":
|
||||
return "walkingRunningDistance";
|
||||
case "FLIGHTS_CLIMBED":
|
||||
return "flightsClimbed";
|
||||
default:
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* v1.4.33 C1 — pull `?slice=…` from either a NextRequest (the
|
||||
* route's production wrapper) or a plain `Request` (the integration
|
||||
@@ -155,6 +121,15 @@ async function buildAnalyticsResponse(user: AuthedUser) {
|
||||
// shape is untouched.
|
||||
await ensureUserRollupsFresh(user.id);
|
||||
|
||||
// v1.4.37 W2 — single per-type coverage probe shared by the
|
||||
// bp_in_target / healthScore / correlations branches below. The
|
||||
// probe is one indexed query against `measurement_rollups`; the
|
||||
// three downstream branches each reuse the resulting `coverage`
|
||||
// map to decide between the rollup-fast-path and the live
|
||||
// fallback. Probing once instead of per-branch keeps the fan-out
|
||||
// cost flat across the three branches.
|
||||
const coverage = await probeRollupCoverage(user.id);
|
||||
|
||||
// v1.4.25 W7b — every day-bucket call inside this route now honours
|
||||
// the user's display timezone. The legacy `berlinDayKey()` import
|
||||
// remains for sleep-stage and correlation paths that share their
|
||||
@@ -333,57 +308,23 @@ async function buildAnalyticsResponse(user: AuthedUser) {
|
||||
const bpTargets = getBpTargets(user.dateOfBirth);
|
||||
if (bpTargets) {
|
||||
const now = new Date();
|
||||
// v1.4.22 A1 — re-anchor the BD-Zielbereich tile headline to the
|
||||
// last-30-day window. Up to v1.4.19 the headline pinned to the
|
||||
// 30-day average (so 7d / 30d / total all read 50 %). v1.4.19 A1
|
||||
// flipped the headline to all-time, which made the tile correct
|
||||
// but emotionally wrong: the headline was the slowest-moving
|
||||
// aggregate possible, punishing recent improvement. v1.4.22 A1
|
||||
// re-routes the headline to last-30-days and surfaces 7d / 30d /
|
||||
// all-time as a 3-line sub-row so power users still see the
|
||||
// long-arc number without it dominating. The helper still returns
|
||||
// every window — only the headline pick changed.
|
||||
//
|
||||
// v1.4.23 H2 — chunked aggregation replaces an unbounded findMany.
|
||||
// The W2-of-v1.4.20 fix did the right thing semantically (all-time
|
||||
// window for the headline) but read the entire BP table into one
|
||||
// array per type. A 5-year power user holds ~9 000 rows × 2; the
|
||||
// single-shot fetch produced a 50-100 ms Prisma round-trip plus a
|
||||
// ~2 MB allocation per request. Page through in 5 000-row chunks
|
||||
// so the working set stays bounded; accumulate into the same
|
||||
// `BpReading[]` shape the existing helper expects. The
|
||||
// `analytics.bp_in_target.row_count` wide-event meta lets ops
|
||||
// attribute slow requests to specific outlier users.
|
||||
// v1.4.29 M1 — bound the BP-in-target reads to the trailing
|
||||
// 365 days. `computeBpInTargetWindows` only needs the last
|
||||
// year (the longest sub-window it computes is `priorYear`);
|
||||
// pre-bound, each chunked walk pulled the entire BP history
|
||||
// every dashboard mount.
|
||||
const bpInTargetSince = new Date(
|
||||
now.getTime() - 365 * 24 * 60 * 60 * 1000,
|
||||
);
|
||||
const [sysData, diaData] = await Promise.all([
|
||||
fetchMeasurementSeriesChunked(user.id, "BLOOD_PRESSURE_SYS", {
|
||||
since: bpInTargetSince,
|
||||
}),
|
||||
fetchMeasurementSeriesChunked(user.id, "BLOOD_PRESSURE_DIA", {
|
||||
since: bpInTargetSince,
|
||||
}),
|
||||
]);
|
||||
|
||||
annotate({
|
||||
meta: {
|
||||
analytics: {
|
||||
bp_in_target: {
|
||||
row_count: sysData.length + diaData.length,
|
||||
sys_rows: sysData.length,
|
||||
dia_rows: diaData.length,
|
||||
},
|
||||
},
|
||||
},
|
||||
// v1.4.37 W2 — probe-gated dispatcher replaces the inline chunked
|
||||
// read. When BOTH BP types have DAY-bucket coverage the helper
|
||||
// pairs the per-day MEAN SYS + MEAN DIA from `measurement_rollups`
|
||||
// and counts in-target days against the five reporting windows,
|
||||
// skipping the heavy 365-day chunked walk against `measurements`.
|
||||
// Falls back to the legacy `computeBpInTargetWindows` over a
|
||||
// chunked read when coverage is partial so a brand-new account
|
||||
// (no buckets yet) still sees per-event numbers. The helper emits
|
||||
// a `path: "rollup" | "live"` annotate so prod logs prove which
|
||||
// branch fired. See `bp-in-target-fast-path.ts` for the
|
||||
// documented per-day-mean approximation.
|
||||
const windows = await computeBpInTargetFastPath({
|
||||
userId: user.id,
|
||||
targets: bpTargets,
|
||||
now,
|
||||
coverage,
|
||||
});
|
||||
|
||||
const windows = computeBpInTargetWindows(sysData, diaData, bpTargets, now);
|
||||
bpInTargetPct = windows.last30Days?.pct ?? null;
|
||||
bpInTargetPct7d = windows.last7Days?.pct ?? null;
|
||||
bpInTargetPct30d = windows.last30Days?.pct ?? null;
|
||||
@@ -420,32 +361,39 @@ async function buildAnalyticsResponse(user: AuthedUser) {
|
||||
}
|
||||
|
||||
// v1.4.20 phase B3 — three pre-defined correlation hypotheses.
|
||||
// All three run on the trailing 30 days so a sparse account doesn't
|
||||
// burn the n >= 20 gate on a stale window (v1.4.23 H6 raised the
|
||||
// floor from 14 → 20). Each runner gates on n >= 20 + p < 0.05;
|
||||
// below the bar the result.status === "insufficient" and the UI
|
||||
// paints an EmptyState.
|
||||
const correlations = await computeCorrelationHypotheses(user.id, userTz);
|
||||
// v1.4.37 W2 — probe-gated helper. The 28-day scan window (down
|
||||
// from 30 to keep the cold critical path tight while still
|
||||
// satisfying the n >= 20 surface gate) reads SYS / PULSE / WEIGHT
|
||||
// per-day means from `measurement_rollups` when the user has full
|
||||
// coverage; mood and medication-intake reads always stay live (no
|
||||
// rollup equivalent). The helper emits `meta.correlations.path` +
|
||||
// `meta.correlations.window_days` so prod logs prove the branch
|
||||
// selection and the truthful window.
|
||||
const correlations = await computeCorrelationHypothesesFastPath({
|
||||
userId: user.id,
|
||||
userTz,
|
||||
now: new Date(),
|
||||
coverage,
|
||||
});
|
||||
|
||||
// v1.4.20 phase B5 — Personal Health Score. Server-deterministic
|
||||
// composite of BP-in-target % + weight-trend alignment + mood
|
||||
// stability + medication compliance. The "vs last week" delta
|
||||
// re-runs the same compute against a 7-day-shifted snapshot.
|
||||
const healthScore = await computeUserHealthScore(user.id, {
|
||||
//
|
||||
// v1.4.37 W2 — probe-gated helper. The weight pillar derives from
|
||||
// DAY-bucket means on `measurement_rollups` when the user has full
|
||||
// coverage; the source-attribution accordion still pulls a narrow
|
||||
// 2-column projection from `measurements` for the ingest-path
|
||||
// pills. Falls back to the legacy 37-day raw read on partial /
|
||||
// missing coverage. Path annotate sits on `meta.healthScore.path`.
|
||||
const healthScore = await computeUserHealthScoreFastPath({
|
||||
userId: user.id,
|
||||
bpInTargetPct,
|
||||
heightCm: user.heightCm ?? null,
|
||||
now: new Date(),
|
||||
coverage,
|
||||
});
|
||||
if (healthScore) {
|
||||
annotate({
|
||||
meta: {
|
||||
healthScore: {
|
||||
score: healthScore.score,
|
||||
band: healthScore.band,
|
||||
delta: healthScore.delta,
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
return {
|
||||
summaries: results,
|
||||
@@ -538,160 +486,11 @@ async function computeSleepStageBreakdown(
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Build inputs for the three pre-defined hypotheses + run them.
|
||||
* Pure-ish — only Prisma reads, no external calls.
|
||||
*
|
||||
* Window: trailing 30 days. Anything older falls outside the surface
|
||||
* because the user-facing "based on N paired readings · last 30 days"
|
||||
* source-chip has to remain truthful.
|
||||
*/
|
||||
async function computeCorrelationHypotheses(
|
||||
userId: string,
|
||||
userTz: string,
|
||||
): Promise<{
|
||||
bpCompliance: CorrelationResult;
|
||||
moodPulse: CorrelationResult;
|
||||
weightWeekday: CorrelationResult;
|
||||
}> {
|
||||
const DAY_MS = 24 * 60 * 60 * 1000;
|
||||
const since = new Date(Date.now() - 30 * DAY_MS);
|
||||
|
||||
// v1.4.23 Sr-H1 — the four measurement reads route through the
|
||||
// chunked helper so even a noisy 30-day window (e.g. minute-level
|
||||
// HealthKit pulse samples) cannot allocate an unbounded buffer. The
|
||||
// helper still returns the full filtered series the Pearson runners
|
||||
// need; we just bound the per-page Prisma round-trip.
|
||||
const [sysRows, pulseRows, weightRows, moodRows, intakeRows] =
|
||||
await Promise.all([
|
||||
fetchMeasurementSeriesChunked(userId, "BLOOD_PRESSURE_SYS", { since }),
|
||||
fetchMeasurementSeriesChunked(userId, "PULSE", { since }),
|
||||
fetchMeasurementSeriesChunked(userId, "WEIGHT", { since }),
|
||||
prisma.moodEntry.findMany({
|
||||
where: { userId, moodLoggedAt: { gte: since } },
|
||||
select: { score: true, moodLoggedAt: true, date: true },
|
||||
}),
|
||||
prisma.medicationIntakeEvent.findMany({
|
||||
where: { userId, scheduledFor: { gte: since } },
|
||||
select: { scheduledFor: true, takenAt: true, skipped: true },
|
||||
}),
|
||||
]);
|
||||
|
||||
// ── Hypothesis 1: BP × medication compliance ────────────────
|
||||
// Aggregate by the user's display-tz day key so DST + UTC boundary
|
||||
// issues don't split a day's readings. The day's "compliance %" is
|
||||
// taken / expected for that calendar day across all medications.
|
||||
const dayKey = (d: Date): string => userDayKey(d, userTz);
|
||||
|
||||
const dailySys = new Map<string, number[]>();
|
||||
for (const row of sysRows) {
|
||||
const key = dayKey(row.measuredAt);
|
||||
const list = dailySys.get(key) ?? [];
|
||||
list.push(row.value);
|
||||
dailySys.set(key, list);
|
||||
}
|
||||
|
||||
const dailyCompliance = new Map<
|
||||
string,
|
||||
{ expected: number; taken: number }
|
||||
>();
|
||||
for (const event of intakeRows) {
|
||||
const key = dayKey(event.scheduledFor);
|
||||
const slot = dailyCompliance.get(key) ?? { expected: 0, taken: 0 };
|
||||
slot.expected += 1;
|
||||
if (event.takenAt && !event.skipped) slot.taken += 1;
|
||||
dailyCompliance.set(key, slot);
|
||||
}
|
||||
|
||||
const bpCompliancePairs: Array<{
|
||||
date: Date;
|
||||
systolic: number;
|
||||
compliancePct: number;
|
||||
}> = [];
|
||||
for (const [key, sysValues] of dailySys.entries()) {
|
||||
const slot = dailyCompliance.get(key);
|
||||
if (!slot || slot.expected === 0) continue;
|
||||
const compliancePct = (slot.taken / slot.expected) * 100;
|
||||
const meanSys = sysValues.reduce((s, v) => s + v, 0) / sysValues.length;
|
||||
bpCompliancePairs.push({
|
||||
date: dateFromDayKey(key),
|
||||
systolic: meanSys,
|
||||
compliancePct,
|
||||
});
|
||||
}
|
||||
const bpCompliance = correlateBpCompliance({ daily: bpCompliancePairs });
|
||||
|
||||
// ── Hypothesis 2: Mood × resting pulse ──────────────────────
|
||||
// Same-day pairing: take the day's mean mood vs the day's mean pulse.
|
||||
// "Resting" is approximated by mean — HealthLog has no separate
|
||||
// resting-pulse field, so we accept the noise rather than skip.
|
||||
const dailyMood = new Map<string, number[]>();
|
||||
for (const row of moodRows) {
|
||||
const key = userDayKey(row.moodLoggedAt, userTz);
|
||||
const list = dailyMood.get(key) ?? [];
|
||||
list.push(row.score);
|
||||
dailyMood.set(key, list);
|
||||
}
|
||||
const dailyPulse = new Map<string, number[]>();
|
||||
for (const row of pulseRows) {
|
||||
const key = userDayKey(row.measuredAt, userTz);
|
||||
const list = dailyPulse.get(key) ?? [];
|
||||
list.push(row.value);
|
||||
dailyPulse.set(key, list);
|
||||
}
|
||||
const moodPulsePairs: Array<{
|
||||
date: Date;
|
||||
mood: number;
|
||||
restingPulse: number;
|
||||
}> = [];
|
||||
for (const [key, moodScores] of dailyMood.entries()) {
|
||||
const pulseValues = dailyPulse.get(key);
|
||||
if (!pulseValues || pulseValues.length === 0) continue;
|
||||
const meanMood = moodScores.reduce((s, v) => s + v, 0) / moodScores.length;
|
||||
const meanPulse =
|
||||
pulseValues.reduce((s, v) => s + v, 0) / pulseValues.length;
|
||||
moodPulsePairs.push({
|
||||
date: dateFromDayKey(key),
|
||||
mood: meanMood,
|
||||
restingPulse: meanPulse,
|
||||
});
|
||||
}
|
||||
const moodPulse = correlateMoodPulse({ daily: moodPulsePairs });
|
||||
|
||||
// ── Hypothesis 3: Weight × weekday ──────────────────────────
|
||||
// 0 = Monday … 6 = Sunday. ISO weekday minus 1.
|
||||
//
|
||||
// v1.4.25 W10 reconcile (Code-H1) — buckets the weekday by the
|
||||
// user's display tz, matching W7's per-user-tz threading that the
|
||||
// BP, mood, sleep, and pulse aggregators above already honour. The
|
||||
// pre-W10 helper was pinned to `Europe/Berlin` and would land a
|
||||
// user-local 23:30 weight reading from `Pacific/Auckland` under
|
||||
// Sunday's bucket instead of Monday's — Pearson on the wrong
|
||||
// weekday column.
|
||||
const weightWeekdayPairs: Array<{ weekday: number; weight: number }> = [];
|
||||
for (const row of weightRows) {
|
||||
const isoWeekday = isoWeekdayInTz(row.measuredAt, userTz); // 1..7, 1=Mon
|
||||
weightWeekdayPairs.push({
|
||||
weekday: isoWeekday - 1,
|
||||
weight: row.value,
|
||||
});
|
||||
}
|
||||
const weightWeekday = correlateWeightWeekday({ daily: weightWeekdayPairs });
|
||||
|
||||
// Annotate so admin observability can attribute coverage to the
|
||||
// corresponding wide-event rather than chasing it via DB queries.
|
||||
annotate({
|
||||
meta: {
|
||||
correlations: {
|
||||
bpCompliance: bpCompliance.status,
|
||||
moodPulse: moodPulse.status,
|
||||
weightWeekday: weightWeekday.status,
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
return { bpCompliance, moodPulse, weightWeekday };
|
||||
}
|
||||
// v1.4.37 W2 — `computeCorrelationHypotheses` body relocated to
|
||||
// `src/lib/analytics/correlations-fast-path.ts` so the probe-gated
|
||||
// rollup / live dispatcher can be unit-tested independently of the
|
||||
// route. The new helper also tightens the scan window to 28 days and
|
||||
// emits a sentinel on `meta.correlations.window_days` / `degraded`.
|
||||
|
||||
/**
|
||||
* v1.4.23 Sr-H1 — paged read of every Measurement of a given type for
|
||||
@@ -793,338 +592,16 @@ async function fetchMeasurementSeriesChunked(
|
||||
return out;
|
||||
}
|
||||
|
||||
// v1.4.22 W5 reconcile (Code-MED-3) — `berlinDayKey()` lifted to
|
||||
// `src/lib/analytics/berlin-day.ts` so the targets route's sparkline
|
||||
// bucketing shares the same Europe/Berlin contract. The
|
||||
// `weekday: "short"` formatter still lives here because it's only
|
||||
// used by `isoWeekdayInTz()` below.
|
||||
//
|
||||
// v1.4.25 W10 reconcile (Code-H1) — formatter is now per-tz so the
|
||||
// weight-weekday correlator honours the same per-user-tz contract the
|
||||
// BP/mood/pulse aggregators above already use. Memoised by tz so the
|
||||
// formatter is built once per unique timezone per process (tz strings
|
||||
// rarely change at runtime; the cache is bounded by the IANA database
|
||||
// to a few hundred entries even in the worst case).
|
||||
const WEEKDAY_FORMATTER_CACHE = new Map<string, Intl.DateTimeFormat>();
|
||||
function getWeekdayFormatter(timeZone: string): Intl.DateTimeFormat {
|
||||
let formatter = WEEKDAY_FORMATTER_CACHE.get(timeZone);
|
||||
if (!formatter) {
|
||||
formatter = new Intl.DateTimeFormat("en-CA", {
|
||||
timeZone,
|
||||
year: "numeric",
|
||||
month: "2-digit",
|
||||
day: "2-digit",
|
||||
weekday: "short",
|
||||
});
|
||||
WEEKDAY_FORMATTER_CACHE.set(timeZone, formatter);
|
||||
}
|
||||
return formatter;
|
||||
}
|
||||
|
||||
function dateFromDayKey(key: string): Date {
|
||||
// Anchor to UTC midnight — the date is a sortable bucket label rather
|
||||
// than a wall-clock timestamp, so DST drift is irrelevant. The tz
|
||||
// info is already baked into the key (built via `userDayKey` upstream).
|
||||
return new Date(`${key}T00:00:00.000Z`);
|
||||
}
|
||||
|
||||
const ISO_WEEKDAY: Record<string, number> = {
|
||||
Mon: 1,
|
||||
Tue: 2,
|
||||
Wed: 3,
|
||||
Thu: 4,
|
||||
Fri: 5,
|
||||
Sat: 6,
|
||||
Sun: 7,
|
||||
};
|
||||
|
||||
function isoWeekdayInTz(d: Date, timeZone: string): number {
|
||||
const parts = getWeekdayFormatter(timeZone).formatToParts(d);
|
||||
const weekday = parts.find((p) => p.type === "weekday")?.value ?? "Mon";
|
||||
return ISO_WEEKDAY[weekday] ?? 1;
|
||||
}
|
||||
// v1.4.37 W2 — `WEEKDAY_FORMATTER_CACHE`, `getWeekdayFormatter`,
|
||||
// `dateFromDayKey`, `ISO_WEEKDAY`, and `isoWeekdayInTz` relocated
|
||||
// alongside the correlation runner in
|
||||
// `src/lib/analytics/correlations-fast-path.ts`. They were only ever
|
||||
// used by the weight-weekday + day-key helpers inside the old inline
|
||||
// correlation builder.
|
||||
|
||||
|
||||
/**
|
||||
* v1.4.25 W8e — collapse the persisted `MeasurementSource` enum onto
|
||||
* the camelCase token set the health-score analytics layer consumes.
|
||||
*
|
||||
* - `MANUAL` and `IMPORT` (CSV import — still user-supplied data) both
|
||||
* surface as `"manual"`.
|
||||
* - `WITHINGS` and `APPLE_HEALTH` ride one-to-one.
|
||||
*
|
||||
* Returns `null` for source values that don't fall into the three
|
||||
* exposed buckets — defence-in-depth in case the enum grows before the
|
||||
* client is taught about it.
|
||||
*/
|
||||
function mapMeasurementSourceToLabel(
|
||||
source: MeasurementSource,
|
||||
): ContributingSource | null {
|
||||
switch (source) {
|
||||
case "MANUAL":
|
||||
case "IMPORT":
|
||||
return "manual";
|
||||
case "WITHINGS":
|
||||
return "withings";
|
||||
case "APPLE_HEALTH":
|
||||
return "appleHealth";
|
||||
default:
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* v1.4.25 W8e — deduplicate the contributing-source list for a single
|
||||
* component. Returns the empty array when nothing in the input maps
|
||||
* onto a known label so downstream `resolveSourceLabel` falls through
|
||||
* to `none` (matches the empty-state branch).
|
||||
*/
|
||||
function uniqueComponentSources(
|
||||
rows: ReadonlyArray<MeasurementSource>,
|
||||
): ReadonlyArray<ContributingSource> {
|
||||
const seen = new Set<ContributingSource>();
|
||||
for (const src of rows) {
|
||||
const label = mapMeasurementSourceToLabel(src);
|
||||
if (label) seen.add(label);
|
||||
}
|
||||
return Array.from(seen);
|
||||
}
|
||||
|
||||
/**
|
||||
* Build the Health Score input from the user's last-30-day weight,
|
||||
* mood, and medication-compliance data, plus the already-computed
|
||||
* `bpInTargetPct` headline. Re-runs the same compute against a
|
||||
* 7-day-shifted window to populate the "vs last week" delta.
|
||||
*
|
||||
* Returns null when the score wouldn't carry any signal (every
|
||||
* component nullable + no medications). The route surfaces the
|
||||
* `null` to the UI so the hero panel hides cleanly.
|
||||
*/
|
||||
async function computeUserHealthScore(
|
||||
userId: string,
|
||||
input: { bpInTargetPct: number | null; heightCm: number | null },
|
||||
): Promise<HealthScoreResult | null> {
|
||||
const DAY_MS = 24 * 60 * 60 * 1000;
|
||||
const now = new Date();
|
||||
const since30d = new Date(now.getTime() - 30 * DAY_MS);
|
||||
// Prior week's snapshot — shift everything 7 days into the past so
|
||||
// both windows close at the same wall-clock-of-day boundary.
|
||||
const prevSince30d = new Date(now.getTime() - 37 * DAY_MS);
|
||||
const prevUntil = new Date(now.getTime() - 7 * DAY_MS);
|
||||
|
||||
// v1.4.25 W8e — read the `source` column alongside the value so the
|
||||
// health-score provenance accordion knows which ingest path drove
|
||||
// each component. The weight + BP reads already paid the row cost;
|
||||
// adding the column to the SELECT is free in Postgres terms (no extra
|
||||
// round-trip, no extra plan node) and the alternative — a second
|
||||
// aggregate just for the source pill — would burn another findMany.
|
||||
const [weightRows, bpSysRowsForSource, moodRows, medications] =
|
||||
await Promise.all([
|
||||
prisma.measurement.findMany({
|
||||
where: {
|
||||
userId,
|
||||
type: "WEIGHT",
|
||||
measuredAt: { gte: prevSince30d, lte: now },
|
||||
},
|
||||
select: { value: true, measuredAt: true, source: true },
|
||||
orderBy: { measuredAt: "asc" },
|
||||
}),
|
||||
// BP source attribution rides on the systolic-readings row set —
|
||||
// diastolic rows always carry the same `source` because both
|
||||
// halves of a pair are persisted in the same write. Pull only the
|
||||
// trailing 30 days to keep the call bounded for power users.
|
||||
prisma.measurement.findMany({
|
||||
where: {
|
||||
userId,
|
||||
type: "BLOOD_PRESSURE_SYS",
|
||||
measuredAt: { gte: since30d, lte: now },
|
||||
},
|
||||
select: { measuredAt: true, source: true },
|
||||
orderBy: { measuredAt: "asc" },
|
||||
}),
|
||||
prisma.moodEntry.findMany({
|
||||
where: {
|
||||
userId,
|
||||
moodLoggedAt: { gte: prevSince30d, lte: now },
|
||||
},
|
||||
select: { score: true, moodLoggedAt: true },
|
||||
orderBy: { moodLoggedAt: "asc" },
|
||||
}),
|
||||
prisma.medication.findMany({
|
||||
where: { userId, active: true },
|
||||
select: {
|
||||
id: true,
|
||||
createdAt: true,
|
||||
schedules: {
|
||||
select: {
|
||||
windowStart: true,
|
||||
windowEnd: true,
|
||||
},
|
||||
},
|
||||
},
|
||||
}),
|
||||
]);
|
||||
|
||||
// Compliance30 per active medication, then again for the prior-week
|
||||
// snapshot. The compliance helper anchors on `Date.now()` internally;
|
||||
// for the previous-week snapshot we reuse the same helper but pass a
|
||||
// shifted "createdAt" floor so the window mathematically reflects the
|
||||
// [-37d, -7d] period — equivalent to running the helper a week ago.
|
||||
let medicationCompliance30: number[] = [];
|
||||
let medicationCompliance30Previous: number[] = [];
|
||||
if (medications.length > 0) {
|
||||
const medIds = medications.map((m) => m.id);
|
||||
const intakeEvents = await prisma.medicationIntakeEvent.findMany({
|
||||
where: {
|
||||
userId,
|
||||
medicationId: { in: medIds },
|
||||
scheduledFor: { gte: prevSince30d, lte: now },
|
||||
},
|
||||
select: {
|
||||
medicationId: true,
|
||||
scheduledFor: true,
|
||||
takenAt: true,
|
||||
skipped: true,
|
||||
},
|
||||
});
|
||||
const eventsByMed = new Map<string, typeof intakeEvents>();
|
||||
for (const ev of intakeEvents) {
|
||||
const list = eventsByMed.get(ev.medicationId);
|
||||
if (list) list.push(ev);
|
||||
else eventsByMed.set(ev.medicationId, [ev]);
|
||||
}
|
||||
medicationCompliance30 = medications.map((med) => {
|
||||
const events = eventsByMed.get(med.id) ?? [];
|
||||
return calculateCompliance(events, med.schedules, 30, med.createdAt).rate;
|
||||
});
|
||||
medicationCompliance30Previous = medications.map((med) => {
|
||||
const events = (eventsByMed.get(med.id) ?? []).filter(
|
||||
(e) => e.scheduledFor <= prevUntil,
|
||||
);
|
||||
// Compute compliance against the prior-week-aligned window by
|
||||
// remapping the helper's "now": shift each event's scheduledFor
|
||||
// and takenAt forward by 7 days so the helper's internal `now`
|
||||
// anchor still captures the same logical 30 days.
|
||||
const shifted = events.map((e) => ({
|
||||
scheduledFor: new Date(e.scheduledFor.getTime() + 7 * DAY_MS),
|
||||
takenAt: e.takenAt ? new Date(e.takenAt.getTime() + 7 * DAY_MS) : null,
|
||||
skipped: e.skipped,
|
||||
}));
|
||||
return calculateCompliance(shifted, med.schedules, 30, med.createdAt)
|
||||
.rate;
|
||||
});
|
||||
}
|
||||
|
||||
const fallbackTarget = defaultWeightTargetFromHeight(input.heightCm);
|
||||
|
||||
const weightSeriesLast30d = weightRows
|
||||
.filter((r) => r.measuredAt >= since30d)
|
||||
.map((r) => ({ date: r.measuredAt.toISOString(), kg: r.value }));
|
||||
const weightSeriesPrev30d = weightRows
|
||||
.filter((r) => r.measuredAt >= prevSince30d && r.measuredAt <= prevUntil)
|
||||
.map((r) => ({ date: r.measuredAt.toISOString(), kg: r.value }));
|
||||
|
||||
const moodSeriesLast30d = moodRows
|
||||
.filter((r) => r.moodLoggedAt >= since30d)
|
||||
.map((r) => ({
|
||||
date: r.moodLoggedAt.toISOString(),
|
||||
score: r.score,
|
||||
}));
|
||||
const moodSeriesPrev30d = moodRows
|
||||
.filter(
|
||||
(r) => r.moodLoggedAt >= prevSince30d && r.moodLoggedAt <= prevUntil,
|
||||
)
|
||||
.map((r) => ({
|
||||
date: r.moodLoggedAt.toISOString(),
|
||||
score: r.score,
|
||||
}));
|
||||
|
||||
// Skip any input shape where literally nothing is computable — the
|
||||
// hero panel hides instead of painting a misleading "0".
|
||||
if (
|
||||
input.bpInTargetPct === null &&
|
||||
weightSeriesLast30d.length === 0 &&
|
||||
moodSeriesLast30d.length === 0 &&
|
||||
medicationCompliance30.length === 0
|
||||
) {
|
||||
// Tag-only annotation so admin observability can see the empty path.
|
||||
annotate({
|
||||
meta: {
|
||||
healthScore: { score: null, reason: "no_components_available" },
|
||||
},
|
||||
});
|
||||
return null;
|
||||
}
|
||||
|
||||
// v1.4.25 W8e — build per-component source attribution from the rows
|
||||
// we already hold in memory. `mapMeasurementSourceToLabel` collapses
|
||||
// the persisted `MeasurementSource` enum onto the camelCase token list
|
||||
// the analytics helper consumes; `IMPORT` rides under `manual`
|
||||
// because the v1.4.20 CSV importer ingests user-supplied data — it's
|
||||
// not a wearable stream.
|
||||
const windowEndAt = now.toISOString();
|
||||
|
||||
const weightSourcesIn30d = uniqueComponentSources(
|
||||
weightRows
|
||||
.filter((r) => r.measuredAt >= since30d)
|
||||
.map((r) => r.source),
|
||||
);
|
||||
const latestWeightInWindow = weightRows
|
||||
.filter((r) => r.measuredAt >= since30d)
|
||||
.at(-1);
|
||||
|
||||
const bpSourceTokens = uniqueComponentSources(
|
||||
bpSysRowsForSource.map((r) => r.source),
|
||||
);
|
||||
const latestBpInWindow = bpSysRowsForSource.at(-1);
|
||||
|
||||
// Mood doesn't yet have a non-manual ingest (v1.5 will introduce
|
||||
// Apple Health mood) so the source list is always `["manual"]` when
|
||||
// there are entries in window. Keep the lookup explicit so the
|
||||
// v1.5 ingest path slot just drops in.
|
||||
const moodSourceTokens = moodSeriesLast30d.length > 0
|
||||
? (["manual"] as const)
|
||||
: [];
|
||||
const latestMoodInWindow = moodRows
|
||||
.filter((r) => r.moodLoggedAt >= since30d)
|
||||
.at(-1);
|
||||
|
||||
// Medication compliance always derives from logged intake events —
|
||||
// user-driven manual logging today.
|
||||
const complianceSourceTokens = medicationCompliance30.length > 0
|
||||
? (["manual"] as const)
|
||||
: [];
|
||||
|
||||
const current: HealthScoreInput = {
|
||||
bpInTargetRate: input.bpInTargetPct,
|
||||
weightSeriesLast30d,
|
||||
weightTargetKg: fallbackTarget,
|
||||
moodEntriesLast30d: moodSeriesLast30d,
|
||||
medicationCompliance30,
|
||||
attribution: {
|
||||
bpSources: bpSourceTokens,
|
||||
asOfBp: latestBpInWindow?.measuredAt.toISOString() ?? null,
|
||||
weightSources: weightSourcesIn30d,
|
||||
asOfWeight: latestWeightInWindow?.measuredAt.toISOString() ?? null,
|
||||
moodSources: moodSourceTokens,
|
||||
asOfMood: latestMoodInWindow?.moodLoggedAt.toISOString() ?? null,
|
||||
complianceSources: complianceSourceTokens,
|
||||
asOfCompliance: complianceSourceTokens.length > 0 ? windowEndAt : null,
|
||||
windowEndAt,
|
||||
},
|
||||
};
|
||||
// The all-time `bpInTargetPct` is a slow-moving aggregate and would
|
||||
// need a full historical re-pair to "rewind" by a week. We pass the
|
||||
// same value to the previous snapshot so the delta primarily
|
||||
// reflects week-over-week changes in the weight / mood / compliance
|
||||
// pillars — the components that actually move on a weekly cadence.
|
||||
const previous: HealthScoreInput = {
|
||||
bpInTargetRate: input.bpInTargetPct,
|
||||
weightSeriesLast30d: weightSeriesPrev30d,
|
||||
weightTargetKg: fallbackTarget,
|
||||
moodEntriesLast30d: moodSeriesPrev30d,
|
||||
medicationCompliance30: medicationCompliance30Previous,
|
||||
};
|
||||
|
||||
return computeHealthScore(current, previous);
|
||||
}
|
||||
// v1.4.37 W2 — `mapMeasurementSourceToLabel`, `uniqueComponentSources`,
|
||||
// and the inline `computeUserHealthScore` body relocated to
|
||||
// `src/lib/analytics/health-score-fast-path.ts` so the probe-gated
|
||||
// rollup / live dispatcher can be unit-tested independently of the
|
||||
// route. The route now delegates through `computeUserHealthScoreFastPath`.
|
||||
@@ -0,0 +1,346 @@
|
||||
import { describe, it, expect, vi, beforeEach } from "vitest";
|
||||
import { NextRequest } from "next/server";
|
||||
|
||||
/**
|
||||
* v1.4.37 W7c — GET /api/measurements gains two new branches for
|
||||
* cumulative HK types (steps, active energy, distance, flights,
|
||||
* daylight):
|
||||
*
|
||||
* 1. `?type=ACTIVITY_STEPS&groupBy=day` → one synthesised row per
|
||||
* user-TZ day with `value` = SUM and `sampleCount` = number of
|
||||
* per-sample rows behind the bucket.
|
||||
* 2. `?type=ACTIVITY_STEPS&dayKey=YYYY-MM-DD` → raw per-sample rows
|
||||
* for that single calendar day in the user's IANA timezone.
|
||||
*
|
||||
* Spot metrics (BP, weight, pulse, etc.) keep the legacy
|
||||
* `findMany`-only behaviour even when these params are present —
|
||||
* the schema accepts the params but the route gates each branch on
|
||||
* `CUMULATIVE_HK_TYPES`.
|
||||
*/
|
||||
|
||||
vi.mock("@/lib/db", () => ({
|
||||
prisma: {
|
||||
measurement: {
|
||||
findMany: vi.fn(),
|
||||
count: vi.fn(),
|
||||
},
|
||||
measurementRollup: {
|
||||
findMany: vi.fn(),
|
||||
},
|
||||
$queryRaw: vi.fn(),
|
||||
},
|
||||
}));
|
||||
|
||||
vi.mock("@/lib/auth/session", () => ({ getSession: vi.fn() }));
|
||||
vi.mock("@/lib/auth/audit", () => ({ auditLog: vi.fn() }));
|
||||
vi.mock("@/lib/logging/transports", () => ({ emitIfSampled: vi.fn() }));
|
||||
vi.mock("@/lib/db-compat", () => ({
|
||||
ensureDbCompatibility: vi.fn().mockResolvedValue(undefined),
|
||||
}));
|
||||
vi.mock("next/headers", () => ({
|
||||
headers: vi.fn(async () => ({ get: () => null })),
|
||||
cookies: vi.fn(async () => ({
|
||||
get: () => undefined,
|
||||
set: () => {},
|
||||
delete: () => {},
|
||||
})),
|
||||
}));
|
||||
|
||||
import { GET } from "../route";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { getSession } from "@/lib/auth/session";
|
||||
|
||||
const SESSION_OK = {
|
||||
session: { id: "sess-1", expiresAt: new Date(Date.now() + 3_600_000) },
|
||||
user: {
|
||||
id: "user-1",
|
||||
username: "test-user",
|
||||
role: "USER" as const,
|
||||
timezone: "Europe/Berlin",
|
||||
},
|
||||
};
|
||||
|
||||
function getRequest(query: string): NextRequest {
|
||||
return new NextRequest(`http://localhost/api/measurements?${query}`, {
|
||||
method: "GET",
|
||||
});
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
vi.resetAllMocks();
|
||||
vi.mocked(getSession).mockResolvedValue(SESSION_OK as never);
|
||||
});
|
||||
|
||||
describe("GET /api/measurements — groupBy=day (W7c collapsed list)", () => {
|
||||
it("collapses per-sample step rows into one row per user-TZ day with sampleCount", async () => {
|
||||
// Three Apple-Watch chunks on 2026-05-15 (Europe/Berlin) +
|
||||
// two on 2026-05-16 — the route should sum each day's bucket.
|
||||
vi.mocked(prisma.measurement.findMany).mockResolvedValue([
|
||||
{
|
||||
id: "m-1",
|
||||
type: "ACTIVITY_STEPS",
|
||||
value: 1200,
|
||||
unit: "steps",
|
||||
source: "APPLE_HEALTH",
|
||||
measuredAt: new Date("2026-05-15T08:00:00.000Z"),
|
||||
notes: null,
|
||||
},
|
||||
{
|
||||
id: "m-2",
|
||||
type: "ACTIVITY_STEPS",
|
||||
value: 3400,
|
||||
unit: "steps",
|
||||
source: "APPLE_HEALTH",
|
||||
measuredAt: new Date("2026-05-15T11:00:00.000Z"),
|
||||
notes: null,
|
||||
},
|
||||
{
|
||||
id: "m-3",
|
||||
type: "ACTIVITY_STEPS",
|
||||
value: 800,
|
||||
unit: "steps",
|
||||
source: "APPLE_HEALTH",
|
||||
measuredAt: new Date("2026-05-15T16:00:00.000Z"),
|
||||
notes: null,
|
||||
},
|
||||
{
|
||||
id: "m-4",
|
||||
type: "ACTIVITY_STEPS",
|
||||
value: 2500,
|
||||
unit: "steps",
|
||||
source: "APPLE_HEALTH",
|
||||
measuredAt: new Date("2026-05-16T07:00:00.000Z"),
|
||||
notes: null,
|
||||
},
|
||||
{
|
||||
id: "m-5",
|
||||
type: "ACTIVITY_STEPS",
|
||||
value: 4500,
|
||||
unit: "steps",
|
||||
source: "APPLE_HEALTH",
|
||||
measuredAt: new Date("2026-05-16T14:00:00.000Z"),
|
||||
notes: null,
|
||||
},
|
||||
] as never);
|
||||
|
||||
const res = await GET(
|
||||
getRequest(
|
||||
"type=ACTIVITY_STEPS&groupBy=day&from=2026-05-15T00:00:00Z&to=2026-05-17T00:00:00Z",
|
||||
),
|
||||
);
|
||||
expect(res.status).toBe(200);
|
||||
const json = (await res.json()) as {
|
||||
data: {
|
||||
measurements: Array<{
|
||||
type: string;
|
||||
value: number;
|
||||
unit: string;
|
||||
dayKey: string;
|
||||
sampleCount: number;
|
||||
measuredAt: string;
|
||||
}>;
|
||||
meta: { groupBy?: string; total: number };
|
||||
};
|
||||
};
|
||||
expect(json.data.meta.groupBy).toBe("day");
|
||||
expect(json.data.measurements.length).toBe(2);
|
||||
// Sort is desc by default — newer day first.
|
||||
const [day16, day15] = json.data.measurements;
|
||||
expect(day16.dayKey).toBe("2026-05-16");
|
||||
expect(day16.value).toBe(7000);
|
||||
expect(day16.sampleCount).toBe(2);
|
||||
expect(day16.unit).toBe("steps");
|
||||
expect(day15.dayKey).toBe("2026-05-15");
|
||||
expect(day15.value).toBe(5400);
|
||||
expect(day15.sampleCount).toBe(3);
|
||||
// The collapsed row's measuredAt anchors to local noon so the
|
||||
// row sorts cleanly between same-day spot samples (canonical
|
||||
// daily-timestamp contract shared with the drain helper).
|
||||
expect(day15.measuredAt).toContain("2026-05-15T10:00:00");
|
||||
});
|
||||
|
||||
it("falls back to the legacy findMany path when groupBy=day is set on a non-cumulative type", async () => {
|
||||
vi.mocked(prisma.measurement.findMany).mockResolvedValue([
|
||||
{
|
||||
id: "m-1",
|
||||
type: "PULSE",
|
||||
value: 60,
|
||||
unit: "bpm",
|
||||
source: "MANUAL",
|
||||
measuredAt: new Date("2026-05-15T09:00:00.000Z"),
|
||||
notes: null,
|
||||
},
|
||||
] as never);
|
||||
vi.mocked(prisma.measurement.count).mockResolvedValue(1 as never);
|
||||
|
||||
const res = await GET(getRequest("type=PULSE&groupBy=day"));
|
||||
expect(res.status).toBe(200);
|
||||
const json = (await res.json()) as {
|
||||
data: {
|
||||
measurements: Array<{ type: string }>;
|
||||
meta: { groupBy?: string };
|
||||
};
|
||||
};
|
||||
// Spot metrics keep the per-sample shape; the collapse branch
|
||||
// never fires.
|
||||
expect(json.data.meta.groupBy).toBeUndefined();
|
||||
expect(json.data.measurements.length).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe("GET /api/measurements — dayKey drill-down (W7c)", () => {
|
||||
it("returns per-sample rows for the requested calendar day in the user's TZ", async () => {
|
||||
vi.mocked(prisma.measurement.findMany).mockResolvedValue([
|
||||
{
|
||||
id: "m-1",
|
||||
type: "ACTIVITY_STEPS",
|
||||
value: 1200,
|
||||
unit: "steps",
|
||||
source: "APPLE_HEALTH",
|
||||
measuredAt: new Date("2026-05-15T08:00:00.000Z"),
|
||||
notes: null,
|
||||
},
|
||||
{
|
||||
id: "m-2",
|
||||
type: "ACTIVITY_STEPS",
|
||||
value: 3400,
|
||||
unit: "steps",
|
||||
source: "APPLE_HEALTH",
|
||||
measuredAt: new Date("2026-05-15T15:00:00.000Z"),
|
||||
notes: null,
|
||||
},
|
||||
] as never);
|
||||
|
||||
const res = await GET(
|
||||
getRequest("type=ACTIVITY_STEPS&dayKey=2026-05-15"),
|
||||
);
|
||||
expect(res.status).toBe(200);
|
||||
const json = (await res.json()) as {
|
||||
data: {
|
||||
measurements: Array<{ id: string; value: number }>;
|
||||
meta: { dayKey?: string };
|
||||
};
|
||||
};
|
||||
expect(json.data.meta.dayKey).toBe("2026-05-15");
|
||||
expect(json.data.measurements.length).toBe(2);
|
||||
expect(json.data.measurements[0].value).toBe(1200);
|
||||
|
||||
// The route resolves the user-TZ day boundary, so the underlying
|
||||
// findMany must be called with measuredAt: { gte, lt } shape.
|
||||
const call = vi.mocked(prisma.measurement.findMany).mock.calls[0]?.[0];
|
||||
expect(call).toBeDefined();
|
||||
const measuredAt = (call as { where: { measuredAt?: unknown } }).where
|
||||
.measuredAt as { gte?: Date; lt?: Date };
|
||||
expect(measuredAt.gte).toBeInstanceOf(Date);
|
||||
expect(measuredAt.lt).toBeInstanceOf(Date);
|
||||
// Window is exactly 24 hours wide on a non-DST-transition day for
|
||||
// a whole-hour-offset zone. The DST-aware drill-down test below
|
||||
// pins the 23-/25-hour shape on the two transition days per year.
|
||||
expect(measuredAt.lt!.getTime() - measuredAt.gte!.getTime()).toBe(
|
||||
24 * 60 * 60 * 1000,
|
||||
);
|
||||
});
|
||||
|
||||
// v1.4.37 W10 H-1 — DST awareness. The drill-down window must honour
|
||||
// the day's true local span (23 h on spring-forward, 25 h on
|
||||
// fall-back) so the row count matches what the collapsed daily row
|
||||
// displays. Previous shape (`canonicalDailyTimestamp ± 12h`) leaked
|
||||
// an hour from the previous day on spring-forward and hid the first
|
||||
// hour of `today` on fall-back.
|
||||
it("returns a 23-hour window on the Berlin spring-forward day (2025-03-30)", async () => {
|
||||
vi.mocked(prisma.measurement.findMany).mockResolvedValue([] as never);
|
||||
const res = await GET(
|
||||
getRequest("type=ACTIVITY_STEPS&dayKey=2025-03-30"),
|
||||
);
|
||||
expect(res.status).toBe(200);
|
||||
const call = vi.mocked(prisma.measurement.findMany).mock.calls[0]?.[0];
|
||||
const measuredAt = (call as { where: { measuredAt?: unknown } }).where
|
||||
.measuredAt as { gte?: Date; lt?: Date };
|
||||
expect(measuredAt.gte!.toISOString()).toBe("2025-03-29T23:00:00.000Z");
|
||||
expect(measuredAt.lt!.toISOString()).toBe("2025-03-30T22:00:00.000Z");
|
||||
expect(measuredAt.lt!.getTime() - measuredAt.gte!.getTime()).toBe(
|
||||
23 * 60 * 60 * 1000,
|
||||
);
|
||||
});
|
||||
|
||||
it("returns a 25-hour window on the Berlin fall-back day (2025-10-26)", async () => {
|
||||
vi.mocked(prisma.measurement.findMany).mockResolvedValue([] as never);
|
||||
const res = await GET(
|
||||
getRequest("type=ACTIVITY_STEPS&dayKey=2025-10-26"),
|
||||
);
|
||||
expect(res.status).toBe(200);
|
||||
const call = vi.mocked(prisma.measurement.findMany).mock.calls[0]?.[0];
|
||||
const measuredAt = (call as { where: { measuredAt?: unknown } }).where
|
||||
.measuredAt as { gte?: Date; lt?: Date };
|
||||
expect(measuredAt.gte!.toISOString()).toBe("2025-10-25T22:00:00.000Z");
|
||||
expect(measuredAt.lt!.toISOString()).toBe("2025-10-26T23:00:00.000Z");
|
||||
expect(measuredAt.lt!.getTime() - measuredAt.gte!.getTime()).toBe(
|
||||
25 * 60 * 60 * 1000,
|
||||
);
|
||||
});
|
||||
|
||||
it("rejects a malformed dayKey at the validation gate (no DB call)", async () => {
|
||||
const res = await GET(getRequest("type=ACTIVITY_STEPS&dayKey=15.05.2026"));
|
||||
expect(res.status).toBe(422);
|
||||
expect(prisma.measurement.findMany).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("ignores dayKey on non-cumulative types and falls back to the legacy path", async () => {
|
||||
vi.mocked(prisma.measurement.findMany).mockResolvedValue([] as never);
|
||||
vi.mocked(prisma.measurement.count).mockResolvedValue(0 as never);
|
||||
|
||||
const res = await GET(getRequest("type=PULSE&dayKey=2026-05-15"));
|
||||
expect(res.status).toBe(200);
|
||||
const json = (await res.json()) as {
|
||||
data: { meta: { dayKey?: string } };
|
||||
};
|
||||
// No dayKey echo on the legacy path — proves the W7c branch
|
||||
// didn't fire for the spot metric.
|
||||
expect(json.data.meta.dayKey).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe("GET /api/measurements — schema rejections (W10 reconcile)", () => {
|
||||
// v1.4.37 W10 H1 — the groupBy=day collapsed path runs the collapse
|
||||
// AFTER the per-sample scan, so it can't honour a non-zero offset
|
||||
// without a Postgres-side date_trunc grouping that's a v1.4.38
|
||||
// backlog item. The validator must reject the combination instead
|
||||
// of silently rendering "showing 1-25 of N" with the wrong N.
|
||||
it("rejects offset>0 when groupBy=day is set", async () => {
|
||||
const res = await GET(
|
||||
getRequest("type=ACTIVITY_STEPS&groupBy=day&offset=25"),
|
||||
);
|
||||
expect(res.status).toBe(422);
|
||||
expect(prisma.measurement.findMany).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
// v1.4.37 W10 H1 — same restriction for the drill-down branch; it
|
||||
// returns a single bounded page per dayKey, not a cursor.
|
||||
it("rejects offset>0 when dayKey is set", async () => {
|
||||
const res = await GET(
|
||||
getRequest("type=ACTIVITY_STEPS&dayKey=2026-05-15&offset=25"),
|
||||
);
|
||||
expect(res.status).toBe(422);
|
||||
expect(prisma.measurement.findMany).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
// v1.4.37 W10 H2 — `2026-02-30` is a YYYY-MM-DD string but not a
|
||||
// real calendar date. `new Date()` silently overflows it to March
|
||||
// 2, so the drill-down would point at the wrong day. The validator
|
||||
// refine must reject it at parse time.
|
||||
it("rejects impossible calendar dates on dayKey (2026-02-30)", async () => {
|
||||
const res = await GET(
|
||||
getRequest("type=ACTIVITY_STEPS&dayKey=2026-02-30"),
|
||||
);
|
||||
expect(res.status).toBe(422);
|
||||
expect(prisma.measurement.findMany).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("rejects impossible month on dayKey (2026-13-01)", async () => {
|
||||
const res = await GET(
|
||||
getRequest("type=ACTIVITY_STEPS&dayKey=2026-13-01"),
|
||||
);
|
||||
expect(res.status).toBe(422);
|
||||
expect(prisma.measurement.findMany).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
@@ -19,6 +19,11 @@ import {
|
||||
type AggregateGrain,
|
||||
} from "@/lib/measurements/range-aggregation";
|
||||
import { CUMULATIVE_HK_TYPES } from "@/lib/measurements/apple-health-mapping";
|
||||
import {
|
||||
canonicalDailyTimestamp,
|
||||
dayKeyForUserTz,
|
||||
localDayWindow,
|
||||
} from "@/lib/measurements/drain-per-sample-cumulative";
|
||||
import { withIdempotency } from "@/lib/idempotency";
|
||||
import { invalidateUserMeasurements } from "@/lib/cache/invalidate";
|
||||
import {
|
||||
@@ -42,8 +47,19 @@ export const GET = apiHandler(async (request: NextRequest) => {
|
||||
return apiError(parsed.error.issues[0].message, 422);
|
||||
}
|
||||
|
||||
const { type, from, to, limit, offset, sortBy, sortDir, aggregate, source } =
|
||||
parsed.data;
|
||||
const {
|
||||
type,
|
||||
from,
|
||||
to,
|
||||
limit,
|
||||
offset,
|
||||
sortBy,
|
||||
sortDir,
|
||||
aggregate,
|
||||
source,
|
||||
groupBy,
|
||||
dayKey,
|
||||
} = parsed.data;
|
||||
|
||||
const where = {
|
||||
userId: user.id,
|
||||
@@ -58,6 +74,151 @@ export const GET = apiHandler(async (request: NextRequest) => {
|
||||
: {}),
|
||||
};
|
||||
|
||||
// v1.4.37 W7c — list-view drill-down to per-sample rows for a single
|
||||
// calendar day in the user's IANA timezone. Resolves the day's UTC
|
||||
// bounds against `User.timezone`, then runs a plain `findMany` so the
|
||||
// expandable list row shows every per-sample chunk the daily collapse
|
||||
// hid. Gated to cumulative HK types — the spot-sample types render
|
||||
// one-row-per-event already and have nothing to drill into.
|
||||
if (dayKey && type && CUMULATIVE_HK_TYPES.has(type as MeasurementType)) {
|
||||
const tz =
|
||||
user.timezone && user.timezone.length > 0
|
||||
? user.timezone
|
||||
: "Europe/Berlin";
|
||||
// Resolve `[dayStart, dayEnd)` for the requested calendar day in
|
||||
// the user's local zone. v1.4.37 W10 — `localDayWindow` honours
|
||||
// DST: the previous shape (`canonicalDailyTimestamp ± 12 h`)
|
||||
// silently leaked or hid one hour of samples on spring-forward
|
||||
// (23-h day) and fall-back (25-h day) by always spanning exactly
|
||||
// 24 h. Works for every IANA offset including sub-half-hour
|
||||
// zones (Asia/Kathmandu UTC+5:45, Pacific/Chatham UTC+12:45).
|
||||
const { dayStart, dayEnd } = localDayWindow(dayKey, tz);
|
||||
const samples = await prisma.measurement.findMany({
|
||||
where: {
|
||||
userId: user.id,
|
||||
type: type as MeasurementType,
|
||||
measuredAt: { gte: dayStart, lt: dayEnd },
|
||||
},
|
||||
orderBy: { measuredAt: sortDir },
|
||||
// Cap the drill-down — a phone-only stepCount day can hit a few
|
||||
// hundred rows; the route ceiling keeps a pathological day bounded.
|
||||
take: Math.min(limit, 1000),
|
||||
});
|
||||
annotate({
|
||||
action: { name: "measurement.list" },
|
||||
meta: { total: samples.length, type, dayKey, mode: "drill-down" },
|
||||
});
|
||||
return apiSuccess({
|
||||
measurements: samples,
|
||||
meta: { total: samples.length, limit, offset: 0, dayKey },
|
||||
});
|
||||
}
|
||||
|
||||
// v1.4.37 W7c — collapsed "one row per day" mode for cumulative
|
||||
// types. The list page renders the day's SUM as a single synthesised
|
||||
// row with a `sampleCount` chevron that drills back into the
|
||||
// per-sample rows via the `dayKey=…` branch above.
|
||||
if (
|
||||
groupBy === "day" &&
|
||||
type &&
|
||||
CUMULATIVE_HK_TYPES.has(type as MeasurementType)
|
||||
) {
|
||||
const tz =
|
||||
user.timezone && user.timezone.length > 0
|
||||
? user.timezone
|
||||
: "Europe/Berlin";
|
||||
const rows = await prisma.measurement.findMany({
|
||||
where,
|
||||
orderBy: { measuredAt: "asc" },
|
||||
// Per-sample row scan within the requested window — bounded by
|
||||
// the existing `limit` cap (default 100, max 5000) so a wide
|
||||
// multi-year window can still walk the whole range when the
|
||||
// chart explicitly asks for it.
|
||||
take: limit,
|
||||
select: {
|
||||
id: true,
|
||||
type: true,
|
||||
value: true,
|
||||
unit: true,
|
||||
source: true,
|
||||
measuredAt: true,
|
||||
notes: true,
|
||||
},
|
||||
});
|
||||
|
||||
// Group by the user's calendar day, sum values, keep a representative
|
||||
// unit/source from the bucket's first row so the rendered row carries
|
||||
// a sensible label even when the bucket mixes sources.
|
||||
type Bucket = {
|
||||
dayKey: string;
|
||||
total: number;
|
||||
sampleCount: number;
|
||||
latest: Date;
|
||||
unit: string;
|
||||
source: string;
|
||||
};
|
||||
const buckets = new Map<string, Bucket>();
|
||||
for (const row of rows) {
|
||||
const key = dayKeyForUserTz(row.measuredAt, tz);
|
||||
const slot = buckets.get(key);
|
||||
if (!slot) {
|
||||
buckets.set(key, {
|
||||
dayKey: key,
|
||||
total: row.value,
|
||||
sampleCount: 1,
|
||||
latest: row.measuredAt,
|
||||
unit: row.unit,
|
||||
source: row.source,
|
||||
});
|
||||
} else {
|
||||
slot.total += row.value;
|
||||
slot.sampleCount += 1;
|
||||
if (row.measuredAt > slot.latest) slot.latest = row.measuredAt;
|
||||
}
|
||||
}
|
||||
|
||||
const measurements = Array.from(buckets.values())
|
||||
.map((b) => ({
|
||||
// Synthetic id so the list-row key stays stable across pages
|
||||
// and the row never collides with a real `Measurement.id`.
|
||||
id: `day:${type}:${b.dayKey}`,
|
||||
type,
|
||||
value: b.total,
|
||||
unit: b.unit,
|
||||
source: b.source,
|
||||
// Anchor the row's timestamp to local noon so the row sorts
|
||||
// cleanly between same-day spot samples — matches the
|
||||
// `canonicalDailyTimestamp` convention used by the drain.
|
||||
measuredAt: canonicalDailyTimestamp(b.dayKey, tz).toISOString(),
|
||||
notes: null,
|
||||
dayKey: b.dayKey,
|
||||
sampleCount: b.sampleCount,
|
||||
}))
|
||||
.sort((a, b) => {
|
||||
const cmp = a.dayKey < b.dayKey ? -1 : a.dayKey > b.dayKey ? 1 : 0;
|
||||
return sortDir === "asc" ? cmp : -cmp;
|
||||
});
|
||||
|
||||
annotate({
|
||||
action: { name: "measurement.list" },
|
||||
meta: {
|
||||
total: measurements.length,
|
||||
type,
|
||||
groupBy: "day",
|
||||
rowsScanned: rows.length,
|
||||
},
|
||||
});
|
||||
return apiSuccess({
|
||||
measurements,
|
||||
meta: {
|
||||
total: measurements.length,
|
||||
limit,
|
||||
offset: 0,
|
||||
groupBy: "day",
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
// v1.4.28 FB-D2 — server-side aggregation. Gated on an explicit
|
||||
// `aggregate` param so the iOS contract (raw `MeasurementWireDTO`
|
||||
// shape on `GET /api/measurements`) is byte-stable for any caller
|
||||
|
||||
@@ -0,0 +1,157 @@
|
||||
/**
|
||||
* v1.4.37 W3 — GET /api/medications/[id]/intake `status` filter tests.
|
||||
*
|
||||
* Pins the contract added to fix the v1.4.36 regression where
|
||||
* `IntakeHistoryListV2` rendered rows with `takenAt:null AND
|
||||
* skipped:false` as "Eingenommen". The route now accepts an optional
|
||||
* `status` query param:
|
||||
*
|
||||
* - default (`status:"all"`) keeps the byte-stable contract for the
|
||||
* iOS Swift client and the dashboard tiles already on the wire.
|
||||
* - `status:"completed"` — taken OR skipped — is what the
|
||||
* detail-page list passes so ambiguous "missed / unconfirmed"
|
||||
* rows stay out of the user-facing table.
|
||||
* - `status:"taken"` / `status:"skipped"` cover the two single-arm
|
||||
* branches future surfaces may need.
|
||||
*
|
||||
* The route-level guard (404 on cross-user reads) is exercised by
|
||||
* the shared `assertMedicationOwnership` test suite — this file only
|
||||
* cares about the Prisma `where` fragment derived from the new knob.
|
||||
*/
|
||||
|
||||
import { describe, it, expect, vi, beforeEach } from "vitest";
|
||||
import { NextRequest } from "next/server";
|
||||
|
||||
vi.mock("@/lib/db", () => ({
|
||||
prisma: {
|
||||
medication: { findUnique: vi.fn() },
|
||||
medicationIntakeEvent: {
|
||||
findMany: vi.fn(),
|
||||
count: vi.fn(),
|
||||
},
|
||||
},
|
||||
}));
|
||||
|
||||
vi.mock("@/lib/auth/session", () => ({ getSession: vi.fn() }));
|
||||
|
||||
vi.mock("@/lib/auth/audit", () => ({
|
||||
auditLog: vi.fn().mockResolvedValue(undefined),
|
||||
}));
|
||||
|
||||
vi.mock("@/lib/logging/transports", () => ({ emitIfSampled: vi.fn() }));
|
||||
|
||||
vi.mock("@/lib/db-compat", () => ({
|
||||
ensureDbCompatibility: vi.fn().mockResolvedValue(undefined),
|
||||
}));
|
||||
|
||||
vi.mock("next/headers", () => ({
|
||||
headers: vi.fn(async () => ({ get: () => null })),
|
||||
cookies: vi.fn(async () => ({
|
||||
get: () => undefined,
|
||||
set: () => {},
|
||||
delete: () => {},
|
||||
})),
|
||||
}));
|
||||
|
||||
import { GET } from "../route";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { getSession } from "@/lib/auth/session";
|
||||
|
||||
const SESSION_OK = {
|
||||
session: { id: "sess-1", expiresAt: new Date(Date.now() + 3_600_000) },
|
||||
user: { id: "user-1", username: "marc", role: "USER" as const },
|
||||
};
|
||||
|
||||
const MED_OK = { id: "med-1", userId: "user-1" };
|
||||
|
||||
function makeRequest(query: string): NextRequest {
|
||||
return new NextRequest(
|
||||
`http://localhost/api/medications/med-1/intake?${query}`,
|
||||
);
|
||||
}
|
||||
|
||||
const ROUTE_PARAMS = { params: Promise.resolve({ id: "med-1" }) };
|
||||
|
||||
beforeEach(() => {
|
||||
vi.resetAllMocks();
|
||||
vi.mocked(getSession).mockResolvedValue(SESSION_OK as never);
|
||||
vi.mocked(prisma.medication.findUnique).mockResolvedValue(MED_OK as never);
|
||||
vi.mocked(prisma.medicationIntakeEvent.findMany).mockResolvedValue(
|
||||
[] as never,
|
||||
);
|
||||
vi.mocked(prisma.medicationIntakeEvent.count).mockResolvedValue(0);
|
||||
});
|
||||
|
||||
describe("GET /api/medications/[id]/intake — status filter", () => {
|
||||
it("applies no status filter when `status` is omitted (back-compat)", async () => {
|
||||
const res = await GET(makeRequest("limit=25&offset=0"), ROUTE_PARAMS);
|
||||
expect(res.status).toBe(200);
|
||||
|
||||
const where = vi.mocked(prisma.medicationIntakeEvent.findMany).mock
|
||||
.calls[0][0]?.where;
|
||||
expect(where).toEqual({ medicationId: "med-1", userId: "user-1" });
|
||||
});
|
||||
|
||||
it("applies no status filter when explicitly passed `status=all`", async () => {
|
||||
const res = await GET(
|
||||
makeRequest("limit=25&offset=0&status=all"),
|
||||
ROUTE_PARAMS,
|
||||
);
|
||||
expect(res.status).toBe(200);
|
||||
|
||||
const where = vi.mocked(prisma.medicationIntakeEvent.findMany).mock
|
||||
.calls[0][0]?.where;
|
||||
expect(where).toEqual({ medicationId: "med-1", userId: "user-1" });
|
||||
});
|
||||
|
||||
it("filters to confirmed-taken rows for `status=taken`", async () => {
|
||||
await GET(makeRequest("status=taken"), ROUTE_PARAMS);
|
||||
const where = vi.mocked(prisma.medicationIntakeEvent.findMany).mock
|
||||
.calls[0][0]?.where;
|
||||
expect(where).toEqual({
|
||||
medicationId: "med-1",
|
||||
userId: "user-1",
|
||||
takenAt: { not: null },
|
||||
skipped: false,
|
||||
});
|
||||
});
|
||||
|
||||
it("filters to skipped rows for `status=skipped`", async () => {
|
||||
await GET(makeRequest("status=skipped"), ROUTE_PARAMS);
|
||||
const where = vi.mocked(prisma.medicationIntakeEvent.findMany).mock
|
||||
.calls[0][0]?.where;
|
||||
expect(where).toEqual({
|
||||
medicationId: "med-1",
|
||||
userId: "user-1",
|
||||
skipped: true,
|
||||
});
|
||||
});
|
||||
|
||||
it("filters to taken-or-skipped rows for `status=completed` (the detail-page contract)", async () => {
|
||||
await GET(makeRequest("status=completed"), ROUTE_PARAMS);
|
||||
const where = vi.mocked(prisma.medicationIntakeEvent.findMany).mock
|
||||
.calls[0][0]?.where;
|
||||
expect(where).toEqual({
|
||||
medicationId: "med-1",
|
||||
userId: "user-1",
|
||||
OR: [{ takenAt: { not: null }, skipped: false }, { skipped: true }],
|
||||
});
|
||||
});
|
||||
|
||||
it("rejects unknown status values with a 422", async () => {
|
||||
const res = await GET(makeRequest("status=junk"), ROUTE_PARAMS);
|
||||
expect(res.status).toBe(422);
|
||||
expect(prisma.medicationIntakeEvent.findMany).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("propagates the `status` value to the count call so totals match the visible page", async () => {
|
||||
await GET(makeRequest("status=completed"), ROUTE_PARAMS);
|
||||
const countArgs = vi.mocked(prisma.medicationIntakeEvent.count).mock
|
||||
.calls[0][0];
|
||||
expect(countArgs?.where).toEqual({
|
||||
medicationId: "med-1",
|
||||
userId: "user-1",
|
||||
OR: [{ takenAt: { not: null }, skipped: false }, { skipped: true }],
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -177,8 +177,31 @@ export const GET = apiHandler(
|
||||
return apiError(parsed.error.issues[0].message, 422);
|
||||
}
|
||||
|
||||
const { limit, offset, sortBy, sortDir } = parsed.data;
|
||||
const where = { medicationId: id, userId: user.id };
|
||||
const { limit, offset, sortBy, sortDir, status } = parsed.data;
|
||||
|
||||
// v1.4.37 W3 — translate the optional `status` filter into a Prisma
|
||||
// `where` fragment. Default `status:"all"` keeps the contract
|
||||
// byte-stable for the iOS Swift client and the dashboard tiles that
|
||||
// were on the wire before this knob existed. The detail-page
|
||||
// IntakeHistoryListV2 component opts into `status:"completed"` so
|
||||
// ambiguous "missed / never confirmed" rows
|
||||
// (`takenAt IS NULL AND skipped = false`) stay out of the user-facing
|
||||
// table — they were the source of the v1.4.36 regression where rows
|
||||
// with no takenAt rendered an "Eingenommen" chip.
|
||||
const statusFilter =
|
||||
status === "taken"
|
||||
? { takenAt: { not: null }, skipped: false }
|
||||
: status === "skipped"
|
||||
? { skipped: true }
|
||||
: status === "completed"
|
||||
? {
|
||||
OR: [
|
||||
{ takenAt: { not: null }, skipped: false },
|
||||
{ skipped: true },
|
||||
],
|
||||
}
|
||||
: {};
|
||||
const where = { medicationId: id, userId: user.id, ...statusFilter };
|
||||
|
||||
const [events, total] = await Promise.all([
|
||||
prisma.medicationIntakeEvent.findMany({
|
||||
@@ -192,7 +215,7 @@ export const GET = apiHandler(
|
||||
|
||||
annotate({
|
||||
action: { name: "medication.intake.list" },
|
||||
meta: { medication_id: id, total },
|
||||
meta: { medication_id: id, total, status },
|
||||
});
|
||||
|
||||
return apiSuccess({ events, meta: { total, limit, offset } });
|
||||
|
||||
Reference in new issue
Block a user