merge(coherence): unify nav, layout settings, mood source, learning gates, coach nav home

# Conflicts:
#	src/lib/personal-records/pr-direction.ts
This commit is contained in:
Marc-André Bombeck committed 2026-06-15 00:23:54 +02:00
commit d1055b4047
29 files changed
+1136 -434

No files matched your search

@@ -0,0 +1,94 @@
/**
* v1.17.1 — the single mood engine `buildMoodDailySeries`.
*
* Pins the one-engine contract: the dashboard snapshot (`buildMoodBlock`)
* and the `/api/mood/analytics` route both read through this function, so
* the same number must read identically on dashboard + insights. Covers
* the rollup fast-path and the legacy live fallback, and asserts the live
* fallback collapses multi-entry days into the daily mean exactly once.
*/
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
vi.mock("@/lib/db", () => ({
prisma: {
moodEntry: { findMany: vi.fn() },
moodEntryRollup: { findMany: vi.fn() },
},
}));
vi.mock("@/lib/rollups/mood-rollups", async () => {
const actual = await vi.importActual<
typeof import("@/lib/rollups/mood-rollups")
>("@/lib/rollups/mood-rollups");
return {
...actual,
ensureUserMoodRollupsFresh: vi
.fn()
.mockResolvedValue({ recomputed: false }),
readMoodDayRollups: vi.fn(),
};
});
import { buildMoodDailySeries } from "../mood-series";
import { prisma } from "@/lib/db";
import { readMoodDayRollups } from "@/lib/rollups/mood-rollups";
beforeEach(() => {
vi.mocked(prisma.moodEntry.findMany).mockResolvedValue([] as never);
vi.mocked(readMoodDayRollups).mockResolvedValue([] as never);
});
afterEach(() => {
vi.restoreAllMocks();
});
describe("buildMoodDailySeries", () => {
it("reads the rollup tier and skips the raw walk when DAY rows exist", async () => {
vi.mocked(readMoodDayRollups).mockResolvedValue([
{ bucketStart: new Date("2026-06-01T00:00:00Z"), mean: 4, count: 2 },
{ bucketStart: new Date("2026-06-02T00:00:00Z"), mean: 3, count: 1 },
] as never);
const series = await buildMoodDailySeries("user-1");
expect(series.source).toBe("rollup");
expect(prisma.moodEntry.findMany).not.toHaveBeenCalled();
expect(series.entries).toEqual([
{ date: "2026-06-01", score: 4, samples: 2 },
{ date: "2026-06-02", score: 3, samples: 1 },
]);
// entryCount sums the per-day samples (2 + 1).
expect(series.entryCount).toBe(3);
expect(series.summary.count).toBe(2);
});
it("falls back to the live walk once and collapses multi-entry days to the daily mean", async () => {
vi.mocked(readMoodDayRollups).mockResolvedValue([] as never);
vi.mocked(prisma.moodEntry.findMany).mockResolvedValue([
{ date: "2026-06-01", score: 5 },
{ date: "2026-06-01", score: 3 },
{ date: "2026-06-02", score: 4 },
] as never);
const series = await buildMoodDailySeries("user-1");
expect(series.source).toBe("live");
// Two distinct calendar days; day one is the mean of its two entries.
expect(series.entries).toEqual([
{ date: "2026-06-01", score: 4, samples: 2 },
{ date: "2026-06-02", score: 4, samples: 1 },
]);
expect(series.entryCount).toBe(3);
// summarize sees one DataPoint per day, not per raw entry.
expect(series.summary.count).toBe(2);
});
it("returns an empty series for a user with no rollups and no raw entries", async () => {
const series = await buildMoodDailySeries("user-1");
expect(series.entries).toEqual([]);
expect(series.entryCount).toBe(0);
// An empty table reads as the rollup tier for annotation parity.
expect(series.source).toBe("rollup");
expect(series.summary.count).toBe(0);
});
});
+149
View File
@@ -0,0 +1,149 @@
/**
* v1.17.1 — single mood daily-series engine.
*
* Before this module the dashboard snapshot (`buildMoodBlock` in
* `src/lib/dashboard/snapshot.ts`) and the `/api/mood/analytics` route
* (`buildMoodAnalyticsResponse`) each carried a hand-copied rollup read +
* coverage fallback + `summarize()` of the same numbers. Two engines for
* one metric is the classic seam where the dashboard and the insights
* surface can read mood differently. This module is the one canonical
* read; both callers delegate to it so the same number reads identically
* on the dashboard, the insights mood sparkline, and the iOS client.
*/
import type { PrismaClient } from "@/generated/prisma/client";
import { prisma } from "@/lib/db";
import { summarize, type DataPoint } from "@/lib/analytics/trends";
import {
ensureUserMoodRollupsFresh,
readMoodDayRollups,
} from "@/lib/rollups/mood-rollups";
/**
* Five-year window for the rollup-tier read. The rollup tier stores one
* row per day, so a five-year cap is cheap (at most ~1 800 rows) and
* still covers every user the product has historic data for. The legacy
* route + snapshot both used this same window.
*/
export const MOOD_SERIES_WINDOW_MS = 5 * 365 * 24 * 60 * 60 * 1000;
/** One daily mood point: the day's average score + how many entries fed it. */
export interface MoodDailyEntry {
date: string;
score: number;
samples: number;
}
export interface MoodDailySeries {
entries: MoodDailyEntry[];
summary: ReturnType<typeof summarize>;
/** Total raw mood entries behind the series (sum of `samples`). */
entryCount: number;
/** Which tier answered — for wide-event annotation by the caller. */
source: "rollup" | "live";
}
/**
* Format a UTC `Date` as a YYYY-MM-DD label. The rollup tier anchors on
* UTC midnight (same convention as the measurement rollup tier). For
* tenants within ±3 h of UTC (Berlin year-round) the label agrees with
* the local wall-clock day on every entry whose timestamp doesn't
* straddle the UTC boundary — i.e. every realistic mood log. v1.5
* per-user-tz bucketing (audit P7) closes the DST fall-back-night gap.
*/
function utcDayLabel(d: Date): string {
const yyyy = d.getUTCFullYear();
const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
const dd = String(d.getUTCDate()).padStart(2, "0");
return `${yyyy}-${mm}-${dd}`;
}
/** Aggregate multiple raw mood entries per day into daily averages. */
function aggregateDailyAverages(
records: Array<{ date: string; score: number }>,
): MoodDailyEntry[] {
const byDay = new Map<string, { sum: number; count: number }>();
for (const record of records) {
const current = byDay.get(record.date) ?? { sum: 0, count: 0 };
current.sum += record.score;
current.count += 1;
byDay.set(record.date, current);
}
return Array.from(byDay.entries())
.sort(([a], [b]) => a.localeCompare(b))
.map(([day, stats]) => ({
date: day,
score: Math.round((stats.sum / stats.count) * 100) / 100,
samples: stats.count,
}));
}
/**
* Canonical mood daily series for a user. Rollup fast-path first; a single
* live walk only on coverage miss (and the warm-up below mints the rollups
* for the next read). Feeds `summarize()` per-day means in both branches so
* the slope/latest/min/max windows are byte-identical on multi-entry days.
*
* `client` lets the snapshot builder pass its own Prisma handle; defaults to
* the shared singleton for the route caller.
*/
export async function buildMoodDailySeries(
userId: string,
client: PrismaClient = prisma,
): Promise<MoodDailySeries> {
// Fire-and-forget warm-up so the next cold mount for this user lands on
// the rollup tier even when the boot-time backfill hasn't reached them.
void ensureUserMoodRollupsFresh(userId);
const since = new Date(Date.now() - MOOD_SERIES_WINDOW_MS);
const rollups = await readMoodDayRollups(userId, since);
if (rollups.length > 0) {
const entries = rollups
.map((r) => ({
date: utcDayLabel(r.bucketStart),
score: Math.round(r.mean * 100) / 100,
samples: r.count,
}))
.sort((a, b) => a.date.localeCompare(b.date));
const dataPoints: DataPoint[] = rollups.map((r) => ({
date: r.bucketStart,
value: r.mean,
}));
const summary = summarize(dataPoints);
const entryCount = rollups.reduce((s, r) => s + r.count, 0);
return { entries, summary, entryCount, source: "rollup" };
}
// Coverage fallback — no rollup rows yet. Run the legacy live walk ONCE;
// the warm-up above mints the rollups for the next request.
const moodEntries = await client.moodEntry.findMany({
// v1.7.0 sync — exclude tombstoned rows from the fallback.
where: { userId, deletedAt: null },
orderBy: { moodLoggedAt: "asc" },
select: { date: true, score: true },
});
const entries = aggregateDailyAverages(
moodEntries.map((e: { date: string; score: number }) => ({
date: e.date,
score: e.score,
})),
);
// Date anchor is local-noon for the day so the slope x-axis spans
// whole-day units — mirrors the dashboard tile's one-number-per-day.
const dataPoints: DataPoint[] = entries.map((e) => ({
date: new Date(`${e.date}T12:00:00.000Z`),
value: e.score,
}));
const summary = summarize(dataPoints);
// An empty table reads as "rollup" (nothing to walk) for annotation
// parity with the historic route; a non-empty live walk reads "live".
return {
entries,
summary,
entryCount: moodEntries.length,
source: moodEntries.length === 0 ? "rollup" : "live",
};
}
+9 -66
View File
@@ -61,10 +61,7 @@ import {
probeRollupCoverage,
type RollupCoverageMap,
} from "@/lib/rollups/measurement-coverage";
import {
ensureUserMoodRollupsFresh,
readMoodDayRollups,
} from "@/lib/rollups/mood-rollups";
import { buildMoodDailySeries } from "@/lib/analytics/mood-series";
import {
resolveDashboardLayout,
DASHBOARD_WIDGET_CATALOGUE_IDS,
@@ -85,9 +82,6 @@ import type { HealthScoreBand } from "@/lib/analytics/health-score";
/** Briefing freshness window — mirrors the 24 h TTL on the advisor cache. */
const BRIEFING_TTL_MS = 24 * 60 * 60 * 1000;
/** Five-year mood window — mirrors `/api/mood/analytics`. */
const MOOD_ROLLUP_WINDOW_MS = 5 * 365 * 24 * 60 * 60 * 1000;
const GLUCOSE_CONTEXTS = [
"FASTING",
"POSTPRANDIAL",
@@ -339,14 +333,6 @@ export interface SnapshotUserInput {
dashboardWidgetsJson: unknown;
}
/** Format a UTC `Date` as a YYYY-MM-DD label (matches mood rollup tier). */
function utcDayLabel(d: Date): string {
const yyyy = d.getUTCFullYear();
const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
const dd = String(d.getUTCDate()).padStart(2, "0");
return `${yyyy}-${mm}-${dd}`;
}
/** Wall-clock hour in `tz`, used for the server-side greeting. */
function hourInTimezone(now: Date, tz: string): number {
try {
@@ -383,63 +369,20 @@ function enrichLastSeen(
return out;
}
/** Read-only mood block, lifting the rollup-tier read from `/api/mood/analytics`. */
/**
* Read-only mood block. v1.17.1 — delegates to the single mood engine
* `buildMoodDailySeries` so the dashboard tile reads the exact numbers
* `/api/mood/analytics` (the insights mood sparkline source) returns.
*/
async function buildMoodBlock(
prisma: PrismaClient,
client: PrismaClient,
userId: string,
): Promise<{
summary: DataSummary | null;
entries: DashboardSnapshotMoodEntry[];
}> {
void ensureUserMoodRollupsFresh(userId);
const since = new Date(Date.now() - MOOD_ROLLUP_WINDOW_MS);
const rollups = await readMoodDayRollups(userId, since);
if (rollups.length > 0) {
const entries = rollups
.map((r) => ({
date: utcDayLabel(r.bucketStart),
score: Math.round(r.mean * 100) / 100,
samples: r.count,
}))
.sort((a, b) => a.date.localeCompare(b.date));
const dataPoints: DataPoint[] = rollups.map((r) => ({
date: r.bucketStart,
value: r.mean,
}));
return { summary: summarize(dataPoints), entries };
}
// Coverage fallback — mirror the live walk in `/api/mood/analytics`.
const moodEntries = await prisma.moodEntry.findMany({
// v1.7.0 sync — exclude tombstoned rows from the dashboard snapshot.
where: { userId, deletedAt: null },
orderBy: { moodLoggedAt: "asc" },
select: { date: true, score: true },
});
if (moodEntries.length === 0) {
return { summary: summarize([]), entries: [] };
}
const byDay = new Map<string, { sum: number; count: number }>();
for (const e of moodEntries) {
const cur = byDay.get(e.date) ?? { sum: 0, count: 0 };
cur.sum += e.score;
cur.count += 1;
byDay.set(e.date, cur);
}
const entries = Array.from(byDay.entries())
.sort(([a], [b]) => a.localeCompare(b))
.map(([day, stats]) => ({
date: day,
score: Math.round((stats.sum / stats.count) * 100) / 100,
samples: stats.count,
}));
const dataPoints: DataPoint[] = entries.map((e) => ({
date: new Date(`${e.date}T12:00:00.000Z`),
value: e.score,
}));
return { summary: summarize(dataPoints), entries };
const series = await buildMoodDailySeries(userId, client);
return { summary: series.summary, entries: series.entries };
}
/**