feat(doctor-report): per-section toggle UI + persistence

src/app/api/auth/me/doctor-report-prefs/__tests__/route.test.ts

@@ -0,0 +1,155 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@/lib/db", () => ({
+  prisma: {
+    user: {
+      findUnique: vi.fn(),
+      update: 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, PUT } from "../route";
+import { prisma } from "@/lib/db";
+import { getSession } from "@/lib/auth/session";
+import { DEFAULT_DOCTOR_REPORT_PREFS } from "@/lib/validations/doctor-report-prefs";
+
+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 },
+};
+
+function mkPut(body: unknown): Request {
+  return new Request("http://localhost/api/auth/me/doctor-report-prefs", {
+    method: "PUT",
+    body: JSON.stringify(body),
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("GET /api/auth/me/doctor-report-prefs", () => {
+  it("returns defaults when the column is null", async () => {
+    vi.mocked(getSession).mockResolvedValue(SESSION_OK as never);
+    vi.mocked(prisma.user.findUnique).mockResolvedValue({
+      doctorReportPrefsJson: null,
+    } as never);
+
+    const res = await (GET as (r: Request) => Promise<Response>)(
+      new Request("http://localhost/api/auth/me/doctor-report-prefs"),
+    );
+    expect(res.status).toBe(200);
+    const env = (await res.json()) as { data: typeof DEFAULT_DOCTOR_REPORT_PREFS };
+    expect(env.data).toEqual(DEFAULT_DOCTOR_REPORT_PREFS);
+    expect(env.data.mood).toBe(false); // privacy default per Marc
+  });
+});
+
+describe("PUT /api/auth/me/doctor-report-prefs", () => {
+  // ── Case 1 — happy path ─────────────────────────────────────────────
+  it("persists the full shape and returns the canonical form", async () => {
+    vi.mocked(getSession).mockResolvedValue(SESSION_OK as never);
+    vi.mocked(prisma.user.findUnique).mockResolvedValue({
+      doctorReportPrefsJson: null,
+    } as never);
+    vi.mocked(prisma.user.update).mockResolvedValue({} as never);
+
+    const body = {
+      bp: true,
+      weight: true,
+      pulse: false,
+      bmi: true,
+      mood: true,
+      compliance: true,
+      sleep: false,
+    };
+    const res = await (PUT as (r: Request) => Promise<Response>)(mkPut(body));
+    expect(res.status).toBe(200);
+    const env = (await res.json()) as { data: typeof body };
+    expect(env.data).toEqual(body);
+    expect(prisma.user.update).toHaveBeenCalledWith({
+      where: { id: "user-1" },
+      data: { doctorReportPrefsJson: body },
+    });
+  });
+
+  // ── Case 2 — partial update layers over current persisted row ───────
+  it("merges a partial update over the persisted row", async () => {
+    vi.mocked(getSession).mockResolvedValue(SESSION_OK as never);
+    const current = {
+      bp: false,
+      weight: false,
+      pulse: false,
+      bmi: false,
+      mood: true,
+      compliance: false,
+      sleep: false,
+    };
+    vi.mocked(prisma.user.findUnique).mockResolvedValue({
+      doctorReportPrefsJson: current,
+    } as never);
+    vi.mocked(prisma.user.update).mockResolvedValue({} as never);
+
+    // User only flips mood off — every other key keeps its persisted value.
+    const res = await (PUT as (r: Request) => Promise<Response>)(
+      mkPut({ mood: false }),
+    );
+    expect(res.status).toBe(200);
+    const env = (await res.json()) as { data: typeof current };
+    expect(env.data).toEqual({ ...current, mood: false });
+    expect(prisma.user.update).toHaveBeenCalledWith({
+      where: { id: "user-1" },
+      data: { doctorReportPrefsJson: { ...current, mood: false } },
+    });
+  });
+
+  // ── Case 3 — invalid shape ─────────────────────────────────────────
+  it("rejects a non-boolean value with 422", async () => {
+    vi.mocked(getSession).mockResolvedValue(SESSION_OK as never);
+
+    const res = await (PUT as (r: Request) => Promise<Response>)(
+      mkPut({ bp: "nope" }),
+    );
+    expect(res.status).toBe(422);
+    expect(prisma.user.update).not.toHaveBeenCalled();
+  });
+
+  // ── Case 4 — unauthenticated cross-user request ────────────────────
+  // Marc's spec mentions "cross-user 404" — the route layer returns 401
+  // when there is no session at all, which is the only "you are not the
+  // right user" surface available before requireAuth() resolves an
+  // identity. `prisma.user.update` must NOT fire in this case.
+  it("rejects an unauthenticated request with 401", async () => {
+    vi.mocked(getSession).mockResolvedValue(null);
+
+    const res = await (PUT as (r: Request) => Promise<Response>)(
+      mkPut({ mood: false }),
+    );
+    expect(res.status).toBe(401);
+    expect(prisma.user.update).not.toHaveBeenCalled();
+  });
+});

src/app/api/auth/me/doctor-report-prefs/route.ts

@@ -0,0 +1,97 @@
+/**
+ * v1.4.25 W6c — per-user Doctor-Report section toggles.
+ *
+ *  GET  /api/auth/me/doctor-report-prefs  — returns the resolved prefs
+ *                                           (defaults when the row is null).
+ *  PUT  /api/auth/me/doctor-report-prefs  — merges the supplied partial
+ *                                           shape over the current row
+ *                                           and persists the canonical
+ *                                           fully-resolved object so a
+ *                                           future schema migration
+ *                                           doesn't need to back-fill
+ *                                           missing keys.
+ *
+ * Bearer-auth + cookie-auth both work via the shared `requireAuth()`
+ * helper. The doctor-report aggregator + PDF renderer both read this
+ * row at generation time so mood data is dropped at the aggregator
+ * layer when `mood = false` — the data never leaves the DB.
+ */
+import { apiHandler, requireAuth, HttpError } from "@/lib/api-handler";
+import { apiSuccess } from "@/lib/api-response";
+import { annotate } from "@/lib/logging/context";
+import { prisma } from "@/lib/db";
+import {
+  doctorReportPrefsSchema,
+  parseDoctorReportPrefs,
+  resolveDoctorReportPrefs,
+} from "@/lib/validations/doctor-report-prefs";
+
+export const dynamic = "force-dynamic";
+
+export const GET = apiHandler(async () => {
+  const { user } = await requireAuth();
+  annotate({ action: { name: "auth.me.doctor-report-prefs.get" } });
+
+  const row = await prisma.user.findUnique({
+    where: { id: user.id },
+    select: { doctorReportPrefsJson: true },
+  });
+  return apiSuccess(parseDoctorReportPrefs(row?.doctorReportPrefsJson));
+});
+
+export const PUT = apiHandler(async (req: Request) => {
+  const { user } = await requireAuth();
+
+  let body: unknown;
+  try {
+    body = await req.json();
+  } catch {
+    throw new HttpError(422, "doctor-report-prefs.body.invalid_json");
+  }
+
+  const parsed = doctorReportPrefsSchema.safeParse(body ?? {});
+  if (!parsed.success) {
+    annotate({
+      action: { name: "auth.me.doctor-report-prefs.put.invalid" },
+      meta: { issues: parsed.error.issues.length },
+    });
+    throw new HttpError(422, "doctor-report-prefs.body.invalid_shape");
+  }
+
+  // Merge the partial input over the current row (or defaults) so a
+  // dialog that only toggles `mood` doesn't have to re-state every other
+  // flag. Persist the canonical fully-resolved object so the column
+  // shape stays stable across future schema additions.
+  const current = await prisma.user.findUnique({
+    where: { id: user.id },
+    select: { doctorReportPrefsJson: true },
+  });
+  const merged = resolveDoctorReportPrefs(
+    current?.doctorReportPrefsJson,
+    parsed.data,
+  );
+
+  await prisma.user.update({
+    where: { id: user.id },
+    // `merged` is a typed object; Prisma's `InputJsonValue` insists on an
+    // index signature so cast through `unknown` rather than widen the
+    // typed return surface. Shape is identical to the validated input.
+    data: {
+      doctorReportPrefsJson: merged as unknown as Record<string, boolean>,
+    },
+  });
+
+  annotate({
+    action: { name: "auth.me.doctor-report-prefs.put" },
+    meta: {
+      bp: merged.bp,
+      weight: merged.weight,
+      pulse: merged.pulse,
+      bmi: merged.bmi,
+      mood: merged.mood,
+      compliance: merged.compliance,
+      sleep: merged.sleep,
+    },
+  });
+  return apiSuccess(merged);
+});

src/app/api/doctor-report/availability/route.ts

@@ -0,0 +1,121 @@
+/**
+ * v1.4.25 W6c — doctor-report section availability probe.
+ *
+ * Returns one boolean per toggleable section so the dialog can hide
+ * checkboxes for data types that have zero rows in the user-selected
+ * date range (Marc's "hide-when-empty" rule). Pure presence check —
+ * `count` queries on small indexed tables — so this is cheap enough to
+ * run on every date-range change in the dialog without driving cost.
+ *
+ * Body shape (mirrors `/api/doctor-report`):
+ *   { startDate?: ISO, endDate?: ISO, days?: number }
+ */
+import type { NextRequest } from "next/server";
+import { apiHandler, requireAuth } from "@/lib/api-handler";
+import { annotate } from "@/lib/logging/context";
+import { apiSuccess, safeJson } from "@/lib/api-response";
+import { prisma } from "@/lib/db";
+import { normaliseDateRange } from "@/lib/doctor-report-data";
+
+export const dynamic = "force-dynamic";
+
+export interface DoctorReportAvailability {
+  /** Section flags — `true` when at least one row exists in the range. */
+  bp: boolean;
+  weight: boolean;
+  pulse: boolean;
+  /** BMI requires both a weight reading AND a configured height. */
+  bmi: boolean;
+  mood: boolean;
+  /** Medication compliance — derived from `MedicationIntakeEvent` rows. */
+  compliance: boolean;
+  sleep: boolean;
+}
+
+export const POST = apiHandler(async (request: NextRequest) => {
+  const { user } = await requireAuth();
+  annotate({ action: { name: "doctor-report.availability" } });
+
+  const { data: body, error } = await safeJson(request);
+  if (error) return error;
+  const range = normaliseDateRange(body ?? undefined);
+  const { start, end } = range;
+
+  // `count` queries are cheaper than `findMany` for a presence check —
+  // we never read the rows themselves. The user has indexes on
+  // `(userId, measuredAt)`, `(userId, moodLoggedAt)`, and
+  // `(userId, scheduledFor)` so these stay sub-millisecond even with
+  // multi-year ranges.
+  const [
+    bpCount,
+    weightCount,
+    pulseCount,
+    moodCount,
+    complianceCount,
+    sleepCount,
+    profile,
+  ] = await Promise.all([
+    prisma.measurement.count({
+      where: {
+        userId: user.id,
+        measuredAt: { gte: start, lte: end },
+        type: { in: ["BLOOD_PRESSURE_SYS", "BLOOD_PRESSURE_DIA"] },
+      },
+    }),
+    prisma.measurement.count({
+      where: {
+        userId: user.id,
+        measuredAt: { gte: start, lte: end },
+        type: "WEIGHT",
+      },
+    }),
+    prisma.measurement.count({
+      where: {
+        userId: user.id,
+        measuredAt: { gte: start, lte: end },
+        type: "PULSE",
+      },
+    }),
+    prisma.moodEntry.count({
+      where: { userId: user.id, moodLoggedAt: { gte: start, lte: end } },
+    }),
+    prisma.medicationIntakeEvent.count({
+      where: { userId: user.id, scheduledFor: { gte: start, lte: end } },
+    }),
+    prisma.measurement.count({
+      where: {
+        userId: user.id,
+        measuredAt: { gte: start, lte: end },
+        type: "SLEEP_DURATION",
+      },
+    }),
+    prisma.user.findUnique({
+      where: { id: user.id },
+      select: { heightCm: true },
+    }),
+  ]);
+
+  // BMI is derived (latest weight × profile height) so it only shows up
+  // when BOTH inputs are available — otherwise the user would tick a
+  // box that produces a silently-empty section.
+  const bmi = weightCount > 0 && (profile?.heightCm ?? null) !== null;
+
+  const availability: DoctorReportAvailability = {
+    bp: bpCount > 0,
+    weight: weightCount > 0,
+    pulse: pulseCount > 0,
+    bmi,
+    mood: moodCount > 0,
+    compliance: complianceCount > 0,
+    sleep: sleepCount > 0,
+  };
+
+  annotate({
+    meta: {
+      report_days: range.days,
+      sections_available: Object.values(availability).filter(Boolean).length,
+    },
+  });
+
+  return apiSuccess(availability);
+});