Merge iOS server asks and client work into release/v1.42.0

# Conflicts:
#	docs/api/openapi.yaml
#	src/lib/openapi/routes/auth.ts
This commit is contained in:
Marc-André Bombeck committed 2026-10-08 11:27:42 +02:00
commit 7eb5659ab9
87 files changed
+4294 -548

No files matched your search

@@ -153,6 +153,12 @@ const ACTIVE_RECORD_ONLY_FIELDS = [
* only when the claim is true and checkable.
*/
const NO_CLIENT_CONSUMER: Record<string, string> = {
features:
"A capability probe for clients released apart from the server: the native app asks " +
"whether this server takes the record-only medication switch before the account has a " +
"medication to learn it from (iOS #116, item 18). The web client is built into the same " +
"image as the server, so everything it renders is by construction supported; a web read " +
"of the flag would be a read written to satisfy this guard.",
insurerIkNumber:
"No web surface reads or writes it — the account form offers the insurer name and the " +
"insurance number, not the institution number. The native client does consume it: it " +
@@ -190,6 +190,17 @@ const ALLOWED: Readonly<Record<string, { count: number; reason: string }>> = {
count: 1,
reason: "See readActiveJobsStartedBefore: null means no queue schema.",
},
"lib/jobs/measurement-maintenance-status.ts::readMeasurementMaintenanceStatus":
{
count: 1,
reason:
"No pgboss schema on a web-only deployment; the admin card reads `available: false` and says so.",
},
"lib/jobs/measurement-maintenance-status.ts::readSizes": {
count: 1,
reason:
"A size probe for an admin card: null shows no figure, and the status read must not fail over it.",
},
"lib/jobs/job-observer.ts::emitJobLine": {
count: 1,
reason:
@@ -97,6 +97,11 @@ const PINNED_AFFORDANCES: Record<
"toast.success": 1,
},
"src/components/admin/glitchtip-section.tsx": { "toast.success": 1 },
// Fires only when the route answered `enqueued: true`; a run already queued
// reads as an info toast instead, and the outcome itself is the status line.
"src/components/admin/measurement-maintenance-card.tsx": {
"toast.success": 1,
},
"src/components/admin/invite-tokens-section.tsx": {
"text-success": 2,
"toast.success": 3,
+4 -1
View File
@@ -5,7 +5,7 @@
* a given slug. Lives next to the route page so the shell can stay a
* server component while the auth-gated body remains a client component.
*
* This is the equivalent of `SECTION_COMPONENTS` in
* This is the equivalent of `SettingsSectionLoader` for
* `src/app/settings/[section]/page.tsx`, lifted to a separate file so
* the route page can be a server component (Settings can keep
* `"use client"`-leaning components in its page because none of them
@@ -36,6 +36,7 @@ import { ModuleAvailabilitySection } from "@/components/admin/module-availabilit
import { RemindersSection } from "@/components/admin/reminders-section";
import { ServicesSection } from "@/components/admin/services-section";
import { SystemStatusSection } from "@/components/admin/system-status-section";
import { MeasurementMaintenanceCard } from "@/components/admin/measurement-maintenance-card";
import { InviteTokensSection } from "@/components/admin/invite-tokens-section";
import { UserManagementSection } from "@/components/admin/user-management-section";
import type { AdminSectionSlug } from "@/components/admin/section-slugs";
@@ -60,6 +61,8 @@ export function AdminSectionRenderer({
return (
<SectionFrame>
<SystemStatusSection />
{/* v1.42 — the table maintenance after the tombstone purge. */}
<MeasurementMaintenanceCard />
</SectionFrame>
);
case "general":
@@ -119,6 +119,14 @@ const DELIBERATELY_OPEN: Record<string, { count: number; reason: string }> = {
count: 1,
reason: "read filter over whole searchParams",
},
"medications/compliance/route.ts": {
count: 1,
reason: "read filter over whole searchParams",
},
"mood/insights/route.ts": {
count: 1,
reason: "read filter over whole searchParams",
},
// ---------------------------------------------------------------
// 3. Native-client ingest and device registration. This is where the
@@ -0,0 +1,143 @@
/**
* `GET /api/admin/maintenance/measurements` — the status the admin card
* starts and follows the run with. Admin-only, and a web-only deployment
* (no pg-boss schema) answers `available: false` instead of failing.
*/
import { beforeEach, describe, expect, it, vi } from "vitest";
import { NextRequest } from "next/server";
vi.mock("@/lib/db", () => ({ prisma: { $queryRaw: 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";
import { runStateOf } from "@/lib/jobs/measurement-maintenance-status";
const ADMIN = {
session: { id: "s-1", expiresAt: new Date(Date.now() + 3_600_000) },
user: { id: "admin-1", username: "admin", role: "ADMIN" as const },
};
const USER = {
session: { id: "s-2", expiresAt: new Date(Date.now() + 3_600_000) },
user: { id: "user-1", username: "bob", role: "USER" as const },
};
const get = () =>
(GET as unknown as (r: NextRequest) => Promise<Response>)(
new NextRequest("http://localhost/api/admin/maintenance/measurements"),
);
beforeEach(() => {
vi.resetAllMocks();
});
describe("GET /api/admin/maintenance/measurements", () => {
it("is refused to anyone but an admin", async () => {
vi.mocked(getSession).mockResolvedValue(USER as never);
expect((await get()).status).toBe(403);
expect(prisma.$queryRaw).not.toHaveBeenCalled();
});
it("reports a running pass, the purge and the table size", async () => {
vi.mocked(getSession).mockResolvedValue(ADMIN as never);
vi.mocked(prisma.$queryRaw)
// sizes
.mockResolvedValueOnce([
{ table_bytes: BigInt(5_000_000_000), index_bytes: BigInt(2e9) },
] as never)
// newest run
.mockResolvedValueOnce([
{
state: "active",
created_on: new Date("2026-10-08T08:00:00Z"),
started_on: new Date("2026-10-08T08:00:05Z"),
completed_on: null,
outcome: null,
},
] as never)
// purge queue
.mockResolvedValueOnce([{ n: 0 }] as never);
const body = await (await get()).json();
expect(body.data).toEqual({
available: true,
purgePending: false,
run: {
state: "running",
requestedAt: "2026-10-08T08:00:00.000Z",
startedAt: "2026-10-08T08:00:05.000Z",
finishedAt: null,
outcome: null,
},
sizes: { tableBytes: 5_000_000_000, indexBytes: 2_000_000_000 },
});
});
it("says when a finished run refused because the purge was still working", async () => {
vi.mocked(getSession).mockResolvedValue(ADMIN as never);
vi.mocked(prisma.$queryRaw)
.mockResolvedValueOnce([
{ table_bytes: BigInt(1), index_bytes: BigInt(1) },
] as never)
.mockResolvedValueOnce([
{
state: "completed",
created_on: new Date("2026-10-08T08:00:00Z"),
started_on: new Date("2026-10-08T08:00:01Z"),
completed_on: new Date("2026-10-08T08:00:02Z"),
outcome: "refused_purge_running",
},
] as never)
.mockResolvedValueOnce([{ n: 1 }] as never);
const body = await (await get()).json();
expect(body.data.purgePending).toBe(true);
expect(body.data.run.outcome).toBe("refused_purge_running");
});
it("answers available: false where there is no queue to ask", async () => {
vi.mocked(getSession).mockResolvedValue(ADMIN as never);
vi.mocked(prisma.$queryRaw)
.mockResolvedValueOnce([
{ table_bytes: BigInt(10), index_bytes: BigInt(4) },
] as never)
.mockRejectedValue(new Error('relation "pgboss.job" does not exist'));
const res = await get();
expect(res.status).toBe(200);
const body = await res.json();
expect(body.data).toEqual({
available: false,
purgePending: false,
run: null,
sizes: { tableBytes: 10, indexBytes: 4 },
});
});
});
describe("runStateOf", () => {
it("maps every pg-boss state onto the card's four", () => {
expect(runStateOf("created")).toBe("queued");
expect(runStateOf("retry")).toBe("queued");
expect(runStateOf("active")).toBe("running");
expect(runStateOf("completed")).toBe("completed");
expect(runStateOf("failed")).toBe("failed");
expect(runStateOf("cancelled")).toBe("failed");
});
});
@@ -8,6 +8,9 @@
* start while the compaction-tombstone purge is still working. At most one
* run is queued or running; a second press answers `enqueued: false`.
* Runbook: `docs/ops/measurement-maintenance.md`.
*
* `GET` reads where the newest run stands, for the admin card that starts it
* and follows it.
*/
import { NextRequest } from "next/server";
import { z } from "zod/v4";
@@ -26,6 +29,7 @@ import {
MEASUREMENT_MAINTENANCE_SEND_OPTIONS,
type MeasurementMaintenancePayload,
} from "@/lib/jobs/measurement-maintenance";
import { readMeasurementMaintenanceStatus } from "@/lib/jobs/measurement-maintenance-status";
import { annotate } from "@/lib/logging/context";
/** Two booleans; anything longer is not a request for this route. */
@@ -90,3 +94,17 @@ export const POST = apiHandler(async (request: NextRequest) => {
return apiSuccess({ enqueued }, 202);
});
export const GET = apiHandler(async () => {
await requireAdmin();
const status = await readMeasurementMaintenanceStatus();
annotate({
action: { name: "admin.maintenance.measurements.status" },
meta: {
available: status.available,
run_state: status.run?.state ?? null,
purge_pending: status.purgePending,
},
});
return apiSuccess(status);
});
+16 -1
View File
@@ -74,9 +74,17 @@ import { recordSessionForPayload } from "@/lib/sharing/record-session-fence";
import { loadAiCapabilities } from "@/lib/ai/capabilities/load";
import { loadCoachReasoningState } from "@/lib/ai/reasoning/controls";
import { parseCoachPrefs } from "@/lib/validations/coach-prefs";
import { storedGlucoseUnit } from "@/lib/glucose";
export const dynamic = "force-dynamic";
/**
* Capability flags for clients that are not shipped with the server. Constant
* by design: a feature the server supports is supported for every account,
* and a per-account answer belongs in `modules` or `ai`, not here.
*/
const SERVER_FEATURES = { trackIntake: true } as const;
export const GET = apiHandler(async () => {
const auth = await requireActorAuth();
const { user } = auth;
@@ -331,7 +339,8 @@ export const GET = apiHandler(async () => {
avatarUrl: user.avatarUpdatedAt
? buildAvatarUrl(user.id, user.avatarUpdatedAt)
: null,
glucoseUnit: user.glucoseUnit ?? null,
// The stored choice, published as the closed pair the contract names.
glucoseUnit: storedGlucoseUnit(user.glucoseUnit),
// v1.7.0 — global metric/imperial display preference. Canonical
// storage stays SI; this only drives the display-time transform
// branch. Null defaults to "metric" on the client.
@@ -442,5 +451,11 @@ export const GET = apiHandler(async () => {
// behind it have one reader by design, and a route that projected them
// itself would be a second statement of what a record context is.
recordSession: recordSessionForPayload(auth),
// v1.42 — what this server understands, for a client released on its own
// schedule (iOS #116, item 18). `trackIntake: true` says medications take
// the record-only switch, so an add form can offer it before the account
// has a medication to learn it from. A flag only ever appears here once
// the server supports it, and stays `true`; absence means an older server.
features: SERVER_FEATURES,
});
});
@@ -0,0 +1,164 @@
/**
* A passkey sign-in that cannot be checked answers with its own status and
* `meta.errorCode`, never a 500. The real `verifyAuthentication` runs here
* against a mocked database, so the test pins the whole path from the
* library's refusal to the wire: an expired or already-used challenge, a
* credential this server does not know, a body that is not an assertion, and
* an assertion the WebAuthn library refuses.
*/
import { describe, it, expect, vi, beforeEach } from "vitest";
import { NextRequest } from "next/server";
vi.mock("@/lib/db", () => ({
prisma: {
$queryRaw: vi.fn(),
passkey: { findUnique: vi.fn(), update: vi.fn() },
user: { findUnique: vi.fn() },
},
}));
vi.mock("@simplewebauthn/server", async (importOriginal) => ({
...(await importOriginal<typeof import("@simplewebauthn/server")>()),
verifyAuthenticationResponse: vi.fn(),
}));
vi.mock("@/lib/auth/audit", () => ({
auditLog: vi.fn().mockResolvedValue(undefined),
}));
vi.mock("@/lib/rate-limit", () => ({
checkRateLimit: vi.fn(),
checkAuthSurfaceRateLimit: vi.fn(),
}));
vi.mock("@/lib/db-compat", () => ({
ensureDbCompatibility: vi.fn().mockResolvedValue(undefined),
}));
vi.mock("@/lib/logging/transports", () => ({ emitIfSampled: vi.fn() }));
vi.mock("next/headers", () => ({
headers: vi.fn(async () => ({ get: () => null })),
cookies: vi.fn(async () => ({
get: () => undefined,
set: () => {},
delete: () => {},
})),
}));
import { POST } from "../route";
import { prisma } from "@/lib/db";
import { auditLog } from "@/lib/auth/audit";
import { checkAuthSurfaceRateLimit } from "@/lib/rate-limit";
import { verifyAuthenticationResponse } from "@simplewebauthn/server";
const ASSERTION = {
id: "cred-1",
rawId: "cred-1",
type: "public-key",
response: {
clientDataJSON: "e30",
authenticatorData: "AA",
signature: "AA",
},
};
function request(credential: unknown = ASSERTION): NextRequest {
return new NextRequest("http://localhost/api/auth/passkey/login-verify", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ challengeId: "ch-1", credential }),
});
}
async function refusal(res: Response) {
const body = (await res.json()) as {
data: null;
meta?: { errorCode?: string };
};
return { status: res.status, code: body.meta?.errorCode, data: body.data };
}
beforeEach(() => {
vi.resetAllMocks();
vi.mocked(checkAuthSurfaceRateLimit).mockResolvedValue({
allowed: true,
remaining: 9,
resetAt: 0,
ip: "203.0.113.1",
} as never);
vi.mocked(prisma.$queryRaw).mockResolvedValue([
{ challenge: "c-1", user_id: null },
] as never);
vi.mocked(prisma.passkey.findUnique).mockResolvedValue({
id: "pk-1",
userId: "user-1",
credentialId: "cred-1",
credentialPublicKey: new Uint8Array([1]),
counter: BigInt(0),
transports: [],
} as never);
});
describe("POST /api/auth/passkey/login-verify — named refusals", () => {
it("answers an expired or already-used challenge with 401 passkey.challenge.expired", async () => {
vi.mocked(prisma.$queryRaw).mockResolvedValue([] as never);
expect(await refusal(await POST(request()))).toEqual({
status: 401,
code: "passkey.challenge.expired",
data: null,
});
expect(auditLog).toHaveBeenCalledWith(
"auth.login.failed",
expect.objectContaining({
details: { reason: "passkey_challenge_expired" },
}),
);
});
it("answers a challenge begun for another account the same way", async () => {
vi.mocked(prisma.$queryRaw).mockResolvedValue([
{ challenge: "c-1", user_id: "someone-else" },
] as never);
const out = await refusal(await POST(request()));
expect(out.status).toBe(401);
expect(out.code).toBe("passkey.challenge.expired");
});
it("answers a passkey that is not registered here with 404 passkey.unknown", async () => {
vi.mocked(prisma.passkey.findUnique).mockResolvedValue(null as never);
expect(await refusal(await POST(request()))).toEqual({
status: 404,
code: "passkey.unknown",
data: null,
});
expect(auditLog).toHaveBeenCalledWith(
"auth.login.failed",
expect.objectContaining({ details: { reason: "passkey_unknown" } }),
);
});
it("answers a body that is not an assertion with 422 passkey.response.invalid", async () => {
const out = await refusal(await POST(request({ id: "cred-1" })));
expect(out.status).toBe(422);
expect(out.code).toBe("passkey.response.invalid");
});
it("answers an assertion the library refuses with 401 passkey.verification.failed", async () => {
vi.mocked(verifyAuthenticationResponse).mockRejectedValue(
new Error("Unexpected authentication response origin"),
);
const out = await refusal(await POST(request()));
expect(out.status).toBe(401);
expect(out.code).toBe("passkey.verification.failed");
expect(prisma.user.findUnique).not.toHaveBeenCalled();
});
it("still lets a real fault surface as one", async () => {
vi.mocked(prisma.passkey.findUnique).mockRejectedValue(
new Error("connection reset"),
);
const res = await POST(request());
expect(res.status).toBe(500);
});
});
+69 -6
View File
@@ -1,4 +1,8 @@
import { verifyAuthentication } from "@/lib/auth/passkey";
import {
PasskeyAuthError,
verifyAuthentication,
type PasskeyAuthErrorKind,
} from "@/lib/auth/passkey";
import { createSession } from "@/lib/auth/session";
import { syncMfaEnrollCookie } from "@/lib/auth/mfa-enrollment";
import { recordSignInDevice } from "@/lib/auth/login-alert";
@@ -20,6 +24,43 @@ import { issueAccessAndRefresh } from "@/lib/auth/refresh-token";
import { isOidcOnly } from "@/lib/auth/oidc";
import { completePendingOidcLink } from "@/lib/auth/oidc-pending-link";
const PASSKEY_VERIFICATION_FAILED_CODE = "passkey.verification.failed";
/**
* How each passkey refusal answers. The challenge and verification cases are
* 401 (the sign-in did not prove anything), the unknown credential is 404 (the
* passkey is not registered on this server), and a malformed body is 422.
*/
const PASSKEY_REFUSALS: Record<
PasskeyAuthErrorKind,
{ status: number; errorCode: string; message: string; auditReason: string }
> = {
challenge_expired: {
status: 401,
errorCode: "passkey.challenge.expired",
message: "The sign-in took too long or was already used. Try again.",
auditReason: "passkey_challenge_expired",
},
unknown_passkey: {
status: 404,
errorCode: "passkey.unknown",
message: "This passkey is not registered here.",
auditReason: "passkey_unknown",
},
malformed: {
status: 422,
errorCode: "passkey.response.invalid",
message: "The passkey response could not be read.",
auditReason: "passkey_response_invalid",
},
verification_failed: {
status: 401,
errorCode: PASSKEY_VERIFICATION_FAILED_CODE,
message: "Passkey verification failed",
auditReason: "passkey_verification_failed",
},
};
export const POST = apiHandler(async (request: NextRequest) => {
// OIDC_ONLY must block passkey login too, not just password login — a
// credential minted before SSO was mandated must not stay a live bypass.
@@ -55,17 +96,39 @@ export const POST = apiHandler(async (request: NextRequest) => {
return apiError("challengeId and credential required", 422);
}
const { verification, passkey } = await verifyAuthentication(
challengeId,
credential,
);
let outcome: Awaited<ReturnType<typeof verifyAuthentication>>;
try {
outcome = await verifyAuthentication(challengeId, credential);
} catch (err) {
// A known client-side case — an expired challenge, a passkey that is no
// longer registered here, a malformed or refused assertion — answers
// with its own status and code (iOS #116, item 20) so the app can tell
// the person what to do instead of reporting a server error. Anything
// else is a real fault and keeps propagating.
if (!(err instanceof PasskeyAuthError)) throw err;
const refusal = PASSKEY_REFUSALS[err.kind];
await auditLog("auth.login.failed", {
ipAddress: ip,
details: { reason: refusal.auditReason },
});
annotate({
action: { name: "auth.login.passkey.refused" },
meta: { reason: err.kind },
});
return apiError(refusal.message, refusal.status, {
errorCode: refusal.errorCode,
});
}
const { verification, passkey } = outcome;
if (!verification.verified) {
await auditLog("auth.login.failed", {
ipAddress: ip,
details: { reason: "passkey_verification_failed" },
});
return apiError("Passkey verification failed", 401);
return apiError("Passkey verification failed", 401, {
errorCode: PASSKEY_VERIFICATION_FAILED_CODE,
});
}
const user = await prisma.user.findUnique({
@@ -577,4 +577,22 @@ describe("POST /api/ingest/medication — the rate-limit bucket", () => {
);
expect(res.status).toBe(429);
});
it("refuses a dose for a record-only medication with medication.intake.notTracked", async () => {
vi.mocked(prisma.medicationIntakeEvent.findFirst).mockResolvedValue(
null as never,
);
vi.mocked(prisma.medication.findFirst).mockResolvedValue({
id: "med-1",
userId: "user-1",
name: "Metformin",
trackIntake: false,
} as never);
const res = await POST(
postReq({ medicationName: "Metformin", idempotencyKey: "k-record-001" }),
);
expect(res.status).toBe(422);
const body = await res.json();
expect(body.meta?.errorCode).toBe("medication.intake.notTracked");
});
});
+7
View File
@@ -31,6 +31,8 @@ import {
import { consumeForIntake } from "@/lib/medications/inventory/consumption";
import { invalidateUserMedications } from "@/lib/cache/invalidate";
import { DEFAULT_TIMEZONE } from "@/lib/tz/format";
import { isRecordOnly } from "@/lib/medications/intake-tracking";
import { refuseUntrackedIntake } from "@/lib/medications/route-guards";
import { NextRequest } from "next/server";
const RATE_LIMIT = 60;
@@ -224,6 +226,11 @@ export const POST = apiHandler(async (request: NextRequest) => {
return apiError("API endpoint for this medication is disabled", 403);
}
// A record-only medication takes no new dose — the same refusal every
// dose-writing route gives (iOS #116, item 15). Checked after the scope
// gate so a token without this medication's scope learns nothing about it.
if (isRecordOnly(medication)) return refuseUntrackedIntake();
// The external ingest path runs without a User record in scope;
// resolve the timezone once — band attribution and the compliance
// recompute below both anchor on the user's local day.
@@ -0,0 +1,183 @@
/**
* `POST /api/measurements/batch` — which issue belongs to which entry.
*
* A whole-batch 422 (`measurement.batch.invalid`) lists every problem in
* `details.issues`. The native client splits such a batch: it drops the
* entries the issues name and resends the rest, so one bad reading does not
* cost the valid ones. That only works if every problem caused by one entry
* carries a path that starts `entries.<n>`, and if the problems that are not
* about an entry (the wrapper itself) never do. Both halves are pinned here,
* and the first case proves the split by resending what is left.
*/
import { describe, expect, it, vi, beforeEach } from "vitest";
import { NextRequest } from "next/server";
vi.mock("@/lib/db", () => ({
prisma: {
user: { update: vi.fn() },
measurement: { findMany: vi.fn() },
$transaction: vi.fn(async (fn: unknown) => {
if (typeof fn === "function") {
return (fn as (tx: unknown) => unknown)(prisma);
}
}),
},
}));
vi.mock("@/lib/measurements/reconcile-external-measurement", () => ({
reconcileExternalMeasurement: vi.fn(
async (_tx: unknown, input: Record<string, unknown>) => ({
status: "inserted",
row: { id: "row-1", ...input },
}),
),
}));
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("@/lib/rate-limit", () => ({ checkRateLimit: vi.fn() }));
vi.mock("@/lib/jobs/pr-detection", () => ({
enqueuePrDetection: vi.fn().mockResolvedValue(undefined),
}));
vi.mock("@/lib/jobs/reminder-satisfy", () => ({
enqueueReminderSatisfy: vi.fn().mockResolvedValue(undefined),
}));
vi.mock("@/lib/cache/invalidate", () => ({
invalidateUserMeasurements: vi.fn(),
}));
vi.mock("@/lib/rollups/after-measurement-mutation", () => ({
afterMeasurementMutation: vi.fn().mockResolvedValue(undefined),
}));
vi.mock("@/lib/daily/morning-refresh-trigger", () => ({
maybeEnqueueMorningRefresh: vi.fn().mockResolvedValue(undefined),
}));
vi.mock("@/lib/arrivals/emit-shared", () => ({
emitDataArrival: vi.fn().mockResolvedValue(undefined),
}));
vi.mock("next/headers", () => ({
headers: vi.fn(async () => ({ get: () => null })),
cookies: vi.fn(async () => ({
get: () => undefined,
set: () => {},
delete: () => {},
})),
}));
import { POST } from "../route";
import { prisma } from "@/lib/db";
import { getSession } from "@/lib/auth/session";
import { checkRateLimit } from "@/lib/rate-limit";
const SESSION_OK = {
session: { id: "sess-1", expiresAt: new Date(Date.now() + 3_600_000) },
user: { id: "user-1", username: "testuser", role: "USER" as const },
};
function post(body: unknown) {
return POST(
new NextRequest("http://localhost/api/measurements/batch", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify(body),
}),
);
}
const AT = new Date(Date.now() - 3_600_000).toISOString();
function entry(i: number, overrides: Record<string, unknown> = {}) {
return {
hkIdentifier: "HKQuantityTypeIdentifierHeartRate",
value: 64,
unit: "count/min",
startDate: AT,
endDate: AT,
externalId: `uuid-${i}`,
...overrides,
};
}
type Issue = { path: string; code: string };
async function issuesFor(body: unknown): Promise<Issue[]> {
const res = await post(body);
expect(res.status).toBe(422);
const json = (await res.json()) as {
details: { issues: Issue[] };
meta?: { errorCode?: string };
};
expect(json.meta?.errorCode).toBe("measurement.batch.invalid");
return json.details.issues;
}
/** The entry index an issue names, or null when it names the batch itself. */
function entryIndex(path: string): number | null {
const m = /^entries\.(\d+)(?:\.|$)/.exec(path);
return m ? Number(m[1]) : null;
}
/** The paths that are about the batch wrapper and no single entry. */
const BATCH_LEVEL_PATHS = new Set(["", "entries", "syncTrigger"]);
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(getSession).mockResolvedValue(SESSION_OK as never);
vi.mocked(checkRateLimit).mockResolvedValue({
allowed: true,
limit: 60,
remaining: 60,
resetAt: Date.now() + 60_000,
});
vi.mocked(prisma.measurement.findMany).mockResolvedValue([]);
});
describe("POST /api/measurements/batch — every entry problem names its entry", () => {
it("names each bad entry as entries.<n>, so the rest of the batch can be resent", async () => {
const entries = [
entry(0),
entry(1, { startDate: "yesterday" }),
entry(2),
entry(3, { value: "64" }),
"not an entry",
entry(5, { hkIdentifier: "", unit: "" }),
entry(6),
];
const issues = await issuesFor({ entries });
expect(issues.length).toBeGreaterThan(0);
for (const issue of issues) {
expect(entryIndex(issue.path), issue.path).not.toBeNull();
}
const bad = new Set(issues.map((i) => entryIndex(i.path)));
expect([...bad].sort()).toEqual([1, 3, 4, 5]);
// The split the client performs: drop the named entries, resend the rest.
const kept = entries.filter((_, i) => !bad.has(i));
const res = await post({ entries: kept });
expect(res.status).toBe(200);
});
it("names the batch itself, never an entry, when the wrapper is wrong", async () => {
const cases: unknown[] = [
[],
{ entries: [] },
{ entries: "x" },
{ entries: [entry(0)], syncTrigger: "sometimes" },
];
let seen = 0;
for (const body of cases) {
for (const issue of await issuesFor(body)) {
expect(BATCH_LEVEL_PATHS.has(issue.path), issue.path).toBe(true);
expect(entryIndex(issue.path)).toBeNull();
seen += 1;
}
}
expect(seen).toBeGreaterThanOrEqual(cases.length);
});
});
@@ -7,6 +7,7 @@ import {
buildCompliancePayload,
complianceCacheKey,
type CompliancePayload,
type CompliancePayloadWire,
} from "@/lib/medications/compliance-payload";
import { cachedSwr, caches, type ServerCache } from "@/lib/cache/server-cache";
import { checkRateLimit } from "@/lib/rate-limit";
@@ -113,6 +114,16 @@ export const GET = apiHandler(
},
});
return apiSuccess(payload);
// The report windows ride the cached cell for the batched read only; this
// route's published shape does not carry them.
const wire: CompliancePayloadWire = {
applicable: payload.applicable,
notApplicableReason: payload.notApplicableReason,
compliance7: payload.compliance7,
compliance30: payload.compliance30,
dailyCompliance: payload.dailyCompliance,
complianceDisplay: payload.complianceDisplay,
};
return apiSuccess(wire);
},
);
@@ -71,6 +71,7 @@ vi.mock("@/lib/medications/inventory/consumption", () => ({
vi.mock("@/lib/medications/route-guards", () => ({
assertMedicationOwnership: vi.fn().mockResolvedValue(null),
assertMedicationTakesIntake: vi.fn().mockResolvedValue(null),
}));
vi.mock("@/lib/cache/invalidate", () => ({
@@ -79,6 +79,7 @@ vi.mock("@/lib/medications/lifecycle", () => ({
vi.mock("@/lib/medications/route-guards", () => ({
assertMedicationOwnership: vi.fn().mockResolvedValue(null),
assertMedicationTakesIntake: vi.fn().mockResolvedValue(null),
}));
vi.mock("@/lib/cache/invalidate", () => ({
+9 -3
View File
@@ -27,7 +27,10 @@ import {
restoreForIntake,
} from "@/lib/medications/inventory/consumption";
import { reconcileOneShotState } from "@/lib/medications/lifecycle";
import { assertMedicationOwnership } from "@/lib/medications/route-guards";
import {
assertMedicationOwnership,
assertMedicationTakesIntake,
} from "@/lib/medications/route-guards";
import { invalidateUserMedications } from "@/lib/cache/invalidate";
import { queueMedicationIntakeSync } from "@/lib/notifications/medication-intake-sync";
import { dispatchMedicationIntakeWebClear } from "@/lib/notifications/web-push-clear";
@@ -111,8 +114,11 @@ async function postIntake(request: NextRequest, { params }: RouteParams) {
const intakeSource = authMethod === "bearer" ? "API" : "WEB";
const { id } = await params;
// v1.4.25 W21 Fix-N — privacy gate hoisted to the shared helper.
const guard = await assertMedicationOwnership(id, user.id);
// v1.4.25 W21 Fix-N — privacy gate hoisted to the shared helper. This is a
// dose write, so the guard also refuses a record-only medication with
// `medication.intake.notTracked` (iOS #116, item 15): its history stays,
// but a new dose would be stored and then counted nowhere.
const guard = await assertMedicationTakesIntake(id, user.id);
if (guard) return guard;
const { data: body, error: jsonError } = await safeJson(request, {
@@ -274,4 +274,70 @@ describe("GET /api/medications/compliance", () => {
);
expect(prisma.medication.findMany).not.toHaveBeenCalled();
});
it("carries one account-wide figure in meta.aggregate, from applicable medications only", async () => {
vi.mocked(prisma.medication.findMany).mockResolvedValue([
medication("med-1"),
medication("med-2"),
{
...medication("mirror-1"),
externalSource: "APPLE_HEALTH",
externalId: "hk-concept-1",
schedules: [],
},
] as never);
const res = await (GET as (req: Request) => Promise<Response>)(
new Request("http://localhost"),
);
const body = await res.json();
const items = body.data as Array<{
compliance7: { totalExpected: number; missed: number };
compliance30: { totalExpected: number };
}>;
expect(body.meta.aggregate.medicationCount).toBe(2);
// Summed over the two scheduled medications; the mirror adds nothing.
expect(body.meta.aggregate.compliance7.totalExpected).toBe(
items[0].compliance7.totalExpected + items[1].compliance7.totalExpected,
);
expect(body.meta.aggregate.compliance30.totalExpected).toBe(
items[0].compliance30.totalExpected + items[1].compliance30.totalExpected,
);
expect(body.meta.aggregate.compliance7.totalExpected).toBeGreaterThan(0);
expect(body.meta).not.toHaveProperty("days");
});
it("answers meta.aggregate null when no medication's adherence applies", async () => {
vi.mocked(prisma.medication.findMany).mockResolvedValue([] as never);
const res = await (GET as (req: Request) => Promise<Response>)(
new Request("http://localhost"),
);
const body = await res.json();
expect(body.meta).toEqual({ aggregate: null });
});
it("adds a complianceN block per medication and to the aggregate on ?days=N", async () => {
vi.mocked(prisma.medication.findMany).mockResolvedValue([
medication("med-1"),
] as never);
const res = await (GET as (req: Request) => Promise<Response>)(
new Request("http://localhost/api/medications/compliance?days=90"),
);
expect(res.status).toBe(200);
const body = await res.json();
const item = body.data[0] as Record<string, { totalExpected: number }>;
expect(item.compliance90.totalExpected).toBeGreaterThan(
item.compliance30.totalExpected,
);
expect(body.meta.days).toBe(90);
expect(body.meta.aggregate.compliance90).toEqual(item.compliance90);
});
it("refuses a window the ledger does not serve", async () => {
const res = await (GET as (req: Request) => Promise<Response>)(
new Request("http://localhost/api/medications/compliance?days=45"),
);
expect(res.status).toBe(422);
expect(prisma.medication.findMany).not.toHaveBeenCalled();
});
});
+87 -13
View File
@@ -1,15 +1,22 @@
import pLimit from "p-limit";
import { z } from "zod/v4";
import { COURSES_COMPLIANCE_SELECT } from "@/lib/analytics/compliance";
import { prisma } from "@/lib/db";
import { apiHandler, requireRecordAuth } from "@/lib/api-handler";
import { annotate } from "@/lib/logging/context";
import { apiSuccess, apiError } from "@/lib/api-response";
import {
apiError,
apiSuccessWithMeta,
returnAllZodIssues,
} from "@/lib/api-response";
import {
aggregateCompliance,
buildCompliancePayload,
complianceCacheKey,
type CompliancePayload,
} from "@/lib/medications/compliance-payload";
import { COMPLIANCE_REPORT_DAYS } from "@/lib/analytics/compliance";
import { cachedSwr, caches, type ServerCache } from "@/lib/cache/server-cache";
import { checkRateLimit } from "@/lib/rate-limit";
import { TRACKED_INTAKE_WHERE } from "@/lib/medications/intake-tracking";
@@ -28,9 +35,29 @@ import { DEFAULT_TIMEZONE } from "@/lib/tz/format";
* wire shape — the cards render rates / streak / display block only; the
* detail page keeps the per-id route for the grid.
*/
export const GET = apiHandler(async () => {
/**
* `?days=N` adds a `complianceN` block per medication and to the account
* aggregate, for a report that covers its own window rather than the fixed 7
* and 30 days. Only the windows the ledger serves are accepted; anything else
* is a 422, never a silently rounded window.
*/
const querySchema = z.object({
days: z
.enum(COMPLIANCE_REPORT_DAYS.map(String) as [string, ...string[]])
.transform(Number)
.optional(),
});
export const GET = apiHandler(async (request: Request) => {
const { user, actor } = await requireRecordAuth("read", "medications");
const query = querySchema.safeParse(
Object.fromEntries(new URL(request.url).searchParams),
);
if (!query.success) return returnAllZodIssues(query.error, 422);
const days = query.data.days as
(typeof COMPLIANCE_REPORT_DAYS)[number] | undefined;
// v1.36.0 — the bucket keys on the ACTOR while everything below it scopes to
// the record. Two reasons, and both are the same reason from opposite ends:
// a delegate hammering this route must burn their own allowance rather than
@@ -74,7 +101,7 @@ export const GET = apiHandler(async () => {
// on a cold cache. Warm / stale cells return without touching the
// database at all; `Promise.all` keeps the response in list order.
const limit = pLimit(3);
const items = await Promise.all(
const results = await Promise.all(
medications.map((medication) =>
limit(async () => {
const payload = await cachedSwr(
@@ -83,22 +110,69 @@ export const GET = apiHandler(async () => {
() => buildCompliancePayload(medication, user.id, userTz),
annotate,
);
return {
medicationId: medication.id,
applicable: payload.applicable,
notApplicableReason: payload.notApplicableReason,
compliance7: payload.compliance7,
compliance30: payload.compliance30,
complianceDisplay: payload.complianceDisplay,
};
return { payload, medicationId: medication.id };
}),
),
);
// A cell cached before the report windows existed carries none; it reads
// as the not-applicable placeholder until its next rebuild rather than
// failing the whole read.
const windowFor = (payload: CompliancePayload, n: number) =>
payload.reportWindows?.[n as keyof CompliancePayload["reportWindows"]];
const items = results.map(({ payload, medicationId }) => ({
medicationId,
applicable: payload.applicable,
notApplicableReason: payload.notApplicableReason,
compliance7: payload.compliance7,
compliance30: payload.compliance30,
...(days !== undefined && days !== 30
? { [`compliance${days}`]: windowFor(payload, days) ?? null }
: {}),
complianceDisplay: payload.complianceDisplay,
}));
// The account-wide figure the widget ring and the report show, built only
// from medications whose adherence means something (`applicable`).
const applicable = results
.map((r) => r.payload)
.filter((payload) => payload.applicable);
const reportWindow =
days !== undefined && days !== 30
? applicable.map((payload) => windowFor(payload, days))
: [];
const aggregate =
applicable.length === 0
? null
: {
compliance7: aggregateCompliance(
applicable.map((p) => p.compliance7),
),
compliance30: aggregateCompliance(
applicable.map((p) => p.compliance30),
),
...(days !== undefined && days !== 30
? {
[`compliance${days}`]: reportWindow.every(Boolean)
? aggregateCompliance(
reportWindow as NonNullable<
(typeof reportWindow)[number]
>[],
)
: null,
}
: {}),
medicationCount: applicable.length,
};
annotate({
action: { name: "medication.compliance_summary.read" },
meta: { count: items.length },
meta: { count: items.length, days: days ?? null },
});
return apiSuccess(items);
return apiSuccessWithMeta(items, {
aggregate,
...(days !== undefined ? { days } : {}),
});
});
@@ -381,6 +381,45 @@ describe("POST /api/medications/intake", () => {
expect(res.status).toBe(422);
});
it("refuses to resolve an open dose of a record-only medication with medication.intake.notTracked", async () => {
vi.mocked(getSession).mockResolvedValue(SESSION_OK as never);
vi.mocked(prisma.medicationIntakeEvent.findFirst).mockResolvedValue({
id: "e1",
userId: "user-1",
medicationId: "m1",
takenAt: null,
skipped: false,
scheduledFor: new Date("2026-05-18T10:00:00.000Z"),
medication: { trackIntake: false },
} as never);
const res = await POST(req({ intakeId: "e1", status: "taken" }));
expect(res.status).toBe(422);
const body = await res.json();
expect(body.meta?.errorCode).toBe("medication.intake.notTracked");
expect(prisma.medicationIntakeEvent.update).not.toHaveBeenCalled();
expect(consumeForIntake).not.toHaveBeenCalled();
});
it("still lets the owner correct a dose a record-only medication already has", async () => {
vi.mocked(getSession).mockResolvedValue(SESSION_OK as never);
vi.mocked(prisma.medicationIntakeEvent.findFirst).mockResolvedValue({
id: "e1",
userId: "user-1",
medicationId: "m1",
takenAt: new Date("2026-05-18T10:05:00.000Z"),
skipped: false,
scheduledFor: new Date("2026-05-18T10:00:00.000Z"),
medication: { trackIntake: false },
} as never);
vi.mocked(prisma.medicationIntakeEvent.update).mockResolvedValue({
id: "e1",
skipped: true,
takenAt: null,
} as never);
const res = await POST(req({ intakeId: "e1", status: "skipped" }));
expect(res.status).toBe(200);
});
it("marks event as skipped", async () => {
vi.mocked(getSession).mockResolvedValue(SESSION_OK as never);
vi.mocked(prisma.medicationIntakeEvent.findFirst).mockResolvedValue({
@@ -244,6 +244,29 @@ describe("POST /api/medications/intake/bulk — v1.8.2 reconcile", () => {
vi.useRealTimers();
});
it("skips an entry for a record-only medication as intake_not_tracked and keeps the rest", async () => {
vi.mocked(prisma.medication.findMany).mockResolvedValue([
{ id: "med-1", trackIntake: false },
] as never);
const res = await POST(
postReq({
entries: [
{
medicationId: "med-1",
scheduledFor: "2026-06-15T05:00:00.000Z",
takenAt: "2026-06-15T05:01:00.000Z",
},
],
}),
);
expect(res.status).toBe(200);
const body = await res.json();
expect(body.data.entries).toEqual([
{ index: 0, status: "skipped", reason: "intake_not_tracked" },
]);
expect(prisma.medicationIntakeEvent.create).not.toHaveBeenCalled();
});
it("C2 — a pending echo onto an already-TAKEN slot is reported duplicate, NOT a downgrade", async () => {
// Existing TAKEN row at the 07:00 slot. The bulk entry is a pending
// echo (no takenAt, skipped false) — must NOT clear takenAt.
@@ -86,6 +86,10 @@ import type { InjectionSiteKey } from "@/lib/medications/injection-sites";
import { queueMedicationIntakeSync } from "@/lib/notifications/medication-intake-sync";
import { dispatchMedicationIntakeWebClearBulk } from "@/lib/notifications/web-push-clear";
import { countOutstandingDosesToday } from "@/lib/medications/outstanding-doses";
import {
INTAKE_NOT_TRACKED_REASON,
isRecordOnly,
} from "@/lib/medications/intake-tracking";
const MAX_ENTRIES_PER_BATCH = 500;
const BATCH_RATE_LIMIT_MAX = 60;
@@ -256,6 +260,7 @@ async function postBulk(request: NextRequest): Promise<Response> {
trackInjectionSites: true,
allowedInjectionSites: true,
externalSource: true,
trackIntake: true,
},
});
const ownedSet = new Set(ownedMedications.map((m) => m.id));
@@ -366,6 +371,16 @@ async function postBulk(request: NextRequest): Promise<Response> {
continue;
}
// A record-only medication takes no new dose (iOS #116, item 15). The
// single-dose routes answer 422 `medication.intake.notTracked`; here the
// same decision is one entry's outcome, so the rest of the batch lands.
if (isRecordOnly(medById.get(entry.medicationId) ?? {})) {
const reason = INTAKE_NOT_TRACKED_REASON;
skipped.push({ index: i, reason });
results.push({ index: i, status: "skipped", reason });
continue;
}
// Both dedup keys on this route are only idempotent while the value
// is STABLE across client launches: `(userId, externalId)` for the
// Apple dose event, and the `@unique` `idempotency_key` column for
+16 -1
View File
@@ -54,7 +54,11 @@ import { queueMedicationIntakeSync } from "@/lib/notifications/medication-intake
import { dispatchMedicationIntakeWebClear } from "@/lib/notifications/web-push-clear";
import { notifyDelegatedIntake } from "@/lib/notifications/delegated-intake";
import { countOutstandingDosesToday } from "@/lib/medications/outstanding-doses";
import { TRACKED_INTAKE_EVENT_WHERE } from "@/lib/medications/intake-tracking";
import {
TRACKED_INTAKE_EVENT_WHERE,
isRecordOnly,
} from "@/lib/medications/intake-tracking";
import { refuseUntrackedIntake } from "@/lib/medications/route-guards";
// The query + body schemas moved to `@/lib/validations/medication` when this
// endpoint joined the published contract: the OpenAPI registry generates from
@@ -265,6 +269,7 @@ export const POST = apiHandler(async (request: NextRequest) => {
deliveryForm: true,
trackInjectionSites: true,
allowedInjectionSites: true,
trackIntake: true,
},
},
},
@@ -273,6 +278,16 @@ export const POST = apiHandler(async (request: NextRequest) => {
return apiError("Intake event not found", 404);
}
// A record-only medication keeps the doses it already has, and an owner may
// still correct one of those (that is an edit of history). What it no longer
// takes is a NEW dose: resolving or snoozing an event that is still open
// would record one, and it would then be counted nowhere (iOS #116, item
// 15). Refused by name, the same code the per-medication route answers with.
const stillOpen = existing.takenAt === null && !existing.skipped;
if (stillOpen && isRecordOnly(existing.medication)) {
return refuseUntrackedIntake();
}
// v1.36.1 — this route is admitted for delegates because marking a dose is
// the thing a person standing next to the patient needs to do. It is an
// UPDATE, though, and two of the transitions it can express are not that.
@@ -0,0 +1,86 @@
/**
* `GET /api/mood/insights?days=N` serves the stability score for the period
* a client shows. The aggregate is cached once per user with every window in
* it; the route picks one, names it, and keeps the per-window map off the
* wire.
*/
import { beforeEach, describe, expect, it, vi } from "vitest";
vi.mock("@/lib/auth/session", () => ({ getSession: vi.fn() }));
vi.mock("@/lib/modules/gate", () => ({
requireModuleEnabled: vi.fn(async () => ({ enabled: true })),
}));
vi.mock("@/lib/cache/server-cache", () => ({
cachedSwr: vi.fn(),
caches: { moodInsights: {} },
}));
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 { getSession } from "@/lib/auth/session";
import { cachedSwr } from "@/lib/cache/server-cache";
import { requireModuleEnabled } from "@/lib/modules/gate";
const year = { score: 40, stdDev: 0.9, band: "variable", days: 300 };
const month = { score: 90, stdDev: 0.2, band: "verySteady", days: 28 };
const AGGREGATE = {
summary: { totalEntries: 300 },
heatmap: { windowDays: 365, cells: [] },
tags: [],
stability: year,
stabilityByWindow: { 30: month, 90: null, 180: year, 365: year },
};
const call = (query = "") =>
(GET as (req: Request) => Promise<Response>)(
new Request(`http://localhost/api/mood/insights${query}`),
);
beforeEach(() => {
vi.resetAllMocks();
vi.mocked(getSession).mockResolvedValue({
session: { id: "s", expiresAt: new Date(Date.now() + 3_600_000) },
user: { id: "user-1", username: "u", role: "USER", timezone: "UTC" },
} as never);
vi.mocked(requireModuleEnabled).mockResolvedValue({ enabled: true } as never);
vi.mocked(cachedSwr).mockResolvedValue(AGGREGATE as never);
});
describe("GET /api/mood/insights — stability per period", () => {
it("serves the whole year by default and names the window", async () => {
const body = await (await call()).json();
expect(body.data.stability).toEqual(year);
expect(body.data.stabilityWindowDays).toBe(365);
expect(body.data).not.toHaveProperty("stabilityByWindow");
});
it("serves the chosen window as stability on ?days=30", async () => {
const body = await (await call("?days=30")).json();
expect(body.data.stability).toEqual(month);
expect(body.data.stabilityWindowDays).toBe(30);
});
it("answers null, not the year's score, when the window has too few days", async () => {
const body = await (await call("?days=90")).json();
expect(body.data.stability).toBeNull();
expect(body.data.stabilityWindowDays).toBe(90);
});
it("refuses a window it does not offer", async () => {
const res = await call("?days=45");
expect(res.status).toBe(422);
expect(cachedSwr).not.toHaveBeenCalled();
});
});
+38 -3
View File
@@ -1,10 +1,14 @@
import { apiSuccess } from "@/lib/api-response";
import { z } from "zod/v4";
import { apiSuccess, returnAllZodIssues } from "@/lib/api-response";
import { apiHandler, requireAuth } from "@/lib/api-handler";
import { annotate } from "@/lib/logging/context";
import { cachedSwr, caches, type ServerCache } from "@/lib/cache/server-cache";
import {
fetchMoodAggregates,
MOOD_STABILITY_WINDOWS,
type MoodAggregates,
type MoodStabilityWindow,
} from "@/lib/insights/mood-aggregates";
import { requireModuleEnabled } from "@/lib/modules/gate";
@@ -26,9 +30,28 @@ export const dynamic = "force-dynamic";
* aggregate is served immediately and a single background recompute
* warms a fresh one, so an active logger never re-pays the cold compute.
*/
export const GET = apiHandler(async () => {
/**
* `?days=N` cuts `stability` to the trailing N days, so a period picker shows
* the steadiness of the period it shows. Without it the score covers the
* whole year, as it always has; `stabilityWindowDays` names the window the
* served score covers either way.
*/
const querySchema = z.object({
days: z
.enum(MOOD_STABILITY_WINDOWS.map(String) as [string, ...string[]])
.transform((v) => Number(v) as MoodStabilityWindow)
.optional(),
});
export const GET = apiHandler(async (request: Request) => {
const { user } = await requireAuth();
const query = querySchema.safeParse(
Object.fromEntries(new URL(request.url).searchParams),
);
if (!query.success) return returnAllZodIssues(query.error, 422);
const stabilityWindowDays: MoodStabilityWindow = query.data.days ?? 365;
// Per-domain gate: the mood-insights aggregate surface only serves the
// mood module's analysis page, so it must be gated on the mood module
// (mirrors `/api/insights/mood-status`). Disabled ⇒ 403 module.disabled.
@@ -51,5 +74,17 @@ export const GET = apiHandler(async () => {
},
});
return apiSuccess(result);
// The per-window map is the cache's, not the wire's: the chosen window is
// served as `stability`. An aggregate cached before the map existed has
// only the year, so a shorter window reads as not yet computed (`null`)
// until the next rebuild rather than as the year's score under a new name.
const { stabilityByWindow, ...wire } = result;
return apiSuccess({
...wire,
stability:
stabilityWindowDays === 365
? result.stability
: (stabilityByWindow?.[stabilityWindowDays] ?? null),
stabilityWindowDays,
});
});
+20 -66
View File
@@ -1,33 +1,14 @@
import { notFound } from "next/navigation";
import type { JSX } from "react";
import { AccessSection } from "@/components/settings/access-section";
import { AccountSection } from "@/components/settings/account-section";
import { AnamnesisSection } from "@/components/settings/anamnesis-section";
import { SecuritySection } from "@/components/settings/security-section";
import { AboutSection } from "@/components/settings/about-section";
import { AdvancedSection } from "@/components/settings/advanced-section";
import { AiSection } from "@/components/settings/ai-section";
import { ApiSection } from "@/components/settings/api-section";
import { CoachSection } from "@/components/settings/coach-section";
import { EnvironmentSection } from "@/components/settings/environment-section";
import { ExportSection } from "@/components/settings/export-section";
import { GesundheitsakteSection } from "@/components/settings/gesundheitsakte-section";
import { IntegrationsSection } from "@/components/settings/integrations-section";
import { LayoutSection } from "@/components/settings/layout-section";
import { McpSection } from "@/components/settings/mcp-section";
import { ModulesSection } from "@/components/settings/modules-section";
import { NotificationsSection } from "@/components/settings/notifications-section";
import { PrivacySection } from "@/components/settings/privacy-section";
import { ScoreSection } from "@/components/settings/score-section";
import { SourcesSection } from "@/components/settings/sources-section";
import { ThresholdsSection } from "@/components/settings/thresholds-section";
import {
SETTINGS_SECTION_SLUGS,
isSettingsSectionSlug,
type SettingsSectionSlug,
} from "@/components/settings/section-slugs";
import { SettingsShell } from "@/components/settings/settings-shell";
import {
SettingsSectionLoader,
SettingsSectionPreload,
} from "@/components/settings/settings-section-loader";
import { RecordSettingsSectionGate } from "@/components/settings/record-settings-section-gate";
import { getIntegrationCallbackUrls } from "@/lib/integrations/callback-urls";
@@ -47,44 +28,6 @@ export function generateStaticParams() {
return SETTINGS_SECTION_SLUGS.map((section) => ({ section }));
}
/**
* Integrations is the one section that needs a server-resolved value: the
* OAuth callback URL each provider registers. It is read from the runtime env
* here, per request, and handed to the client section as a prop, because a
* `NEXT_PUBLIC_*` read inside a client module is inlined at build time and the
* published image is built without it.
*/
function IntegrationsSectionWithCallbackUrls() {
return <IntegrationsSection callbackUrls={getIntegrationCallbackUrls()} />;
}
const SECTION_COMPONENTS: Record<
SettingsSectionSlug,
() => JSX.Element | null
> = {
account: AccountSection,
access: AccessSection,
security: SecuritySection,
modules: ModulesSection,
about: AboutSection,
ai: AiSection,
coach: CoachSection,
integrations: IntegrationsSectionWithCallbackUrls,
sources: SourcesSection,
notifications: NotificationsSection,
layout: LayoutSection,
environment: EnvironmentSection,
anamnesis: AnamnesisSection,
score: ScoreSection,
thresholds: ThresholdsSection,
api: ApiSection,
mcp: McpSection,
gesundheitsakte: GesundheitsakteSection,
export: ExportSection,
advanced: AdvancedSection,
privacy: PrivacySection,
};
interface PageProps {
// Next.js 16 made route `params` an async Promise. We `await` it before use.
params: Promise<{ section: string }>;
@@ -100,10 +43,13 @@ export default async function SettingsSectionPage({ params }: PageProps) {
notFound();
}
// `SECTION_COMPONENTS` is an exhaustive Record over the slug union, so a
// slug without a wired component is a compile error — the old runtime
// `<SectionPlaceholder>` fallback could never render and was removed.
const SectionComponent = SECTION_COMPONENTS[section];
// Each section is its own chunk (see `SettingsSectionLoader`), so the route
// ships the one it shows rather than all twenty-one. Integrations is the
// one section that needs a server-resolved value: the OAuth callback URL
// each provider registers, read from the runtime env here, per request,
// because a `NEXT_PUBLIC_*` read inside a client module is inlined at build
// time and the published image is built without it.
//
// v1.18.6.1 — the heading + subtitle (and the Layout-hub "← back" link)
// live in `<SettingsShell>`, which places them in their own grid row
// spanning only the content column so the left nav's first item lines up
@@ -112,12 +58,20 @@ export default async function SettingsSectionPage({ params }: PageProps) {
// `settings-section-<slug>-title` `aria-labelledby` linkage still resolves.
return (
<SettingsShell active={section}>
<SettingsSectionPreload section={section} />
<RecordSettingsSectionGate section={section}>
<section
aria-labelledby={`settings-section-${section}-title`}
className="space-y-6"
>
<SectionComponent />
<SettingsSectionLoader
section={section}
callbackUrls={
section === "integrations"
? getIntegrationCallbackUrls()
: undefined
}
/>
</section>
</RecordSettingsSectionGate>
</SettingsShell>
@@ -0,0 +1,247 @@
"use client";
/**
* `<MeasurementMaintenanceCard>` — start the measurement table maintenance
* and follow it, from the admin console instead of a `curl` against the
* route (runbook: `docs/ops/measurement-maintenance.md`).
*
* Calm on purpose. The button asks once, says what the run does and that it
* can take a while, and then the card shows where the run stands: waiting,
* running since when, finished, or stopped. It polls only while a run is
* queued or running. It stays disabled while the compaction-tombstone purge
* is still at work, because a run started then would refuse at once.
*/
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { Database, Loader2, Wrench } from "lucide-react";
import { toast } from "sonner";
import { StatTile } from "@/components/admin/_stat-tile";
import { SettingsCardActions } from "@/components/settings/_card-actions";
import { SettingsCardHeader } from "@/components/settings/_card-header";
import { SettingsCard } from "@/components/settings/settings-card";
import {
AlertDialog,
AlertDialogAction,
AlertDialogCancel,
AlertDialogContent,
AlertDialogDescription,
AlertDialogFooter,
AlertDialogHeader,
AlertDialogTitle,
AlertDialogTrigger,
} from "@/components/ui/alert-dialog";
import { Button } from "@/components/ui/button";
import { QueryErrorCard } from "@/components/ui/query-error-card";
import { apiFetchRaw, apiGet } from "@/lib/api/api-fetch";
import { formatBytes } from "@/lib/format/bytes";
import { useFormatters, useTranslations } from "@/lib/i18n/context";
import type { MeasurementMaintenanceStatus } from "@/lib/jobs/measurement-maintenance-status";
import { queryKeys } from "@/lib/query-keys";
import { getApiErrorMessage } from "./_shared";
const ENDPOINT = "/api/admin/maintenance/measurements";
/** How often the card asks while a run is waiting or working. */
const POLL_MS = 10_000;
const GIB = 1024 * 1024 * 1024;
function sizeLabel(
bytes: number,
fmt: ReturnType<typeof useFormatters>,
): string {
// The shared formatter stops at MB; this table is routinely gigabytes.
return bytes >= GIB
? `${fmt.number(bytes / GIB, 2)} GB`
: formatBytes(bytes, fmt);
}
export function MeasurementMaintenanceCard() {
const { t } = useTranslations();
const fmt = useFormatters();
const queryClient = useQueryClient();
const status = useQuery({
queryKey: queryKeys.adminMeasurementMaintenance(),
queryFn: () =>
apiGet<MeasurementMaintenanceStatus>(ENDPOINT, {
credentials: "include",
}),
refetchInterval: (query) => {
const state = query.state.data?.run?.state;
return state === "queued" || state === "running" ? POLL_MS : false;
},
});
const start = useMutation({
mutationFn: async (): Promise<{ enqueued: boolean }> => {
const res = await apiFetchRaw(ENDPOINT, {
method: "POST",
credentials: "include",
headers: { "content-type": "application/json" },
body: JSON.stringify({ vacuum: true, reindex: true }),
});
if (!res.ok) throw new Error(await getApiErrorMessage(res));
return ((await res.json()) as { data: { enqueued: boolean } }).data;
},
onSuccess: ({ enqueued }) => {
if (enqueued) toast.success(t("admin.section.maintenance.started"));
else toast.info(t("admin.section.maintenance.alreadyQueued"));
void queryClient.invalidateQueries({
queryKey: queryKeys.adminMeasurementMaintenance(),
});
},
onError: (err: Error) => {
toast.error(err.message || t("admin.section.maintenance.startFailed"));
},
});
const header = (
<SettingsCardHeader
icon={Database}
title={t("admin.section.maintenance.title")}
description={t("admin.section.maintenance.description")}
/>
);
if (status.isError) {
return (
<QueryErrorCard
title={t("admin.section.maintenance.loadError")}
onRetry={() => void status.refetch()}
/>
);
}
const s = status.data;
const run = s?.run ?? null;
const active = run?.state === "queued" || run?.state === "running";
const blocked = !s || !s.available || s.purgePending || active;
return (
<SettingsCard data-testid="admin-measurement-maintenance">
{header}
<p className="text-sm">{t("admin.section.maintenance.body")}</p>
{s?.sizes ? (
<div className="grid gap-3 sm:grid-cols-2">
<StatTile
label={t("admin.section.maintenance.tableSize")}
value={sizeLabel(s.sizes.tableBytes, fmt)}
/>
<StatTile
label={t("admin.section.maintenance.indexSize")}
value={sizeLabel(s.sizes.indexBytes, fmt)}
/>
</div>
) : null}
<div
className="text-sm"
role="status"
aria-live="polite"
data-slot="maintenance-state"
data-state={status.isLoading ? "loading" : (run?.state ?? "idle")}
>
{status.isLoading ? (
<span className="text-muted-foreground flex items-center gap-2">
<Loader2
className="size-4 animate-spin motion-reduce:animate-none"
aria-hidden
/>
{t("admin.section.maintenance.loading")}
</span>
) : !s?.available ? (
<span className="text-muted-foreground">
{t("admin.section.maintenance.unavailable")}
</span>
) : run?.state === "queued" ? (
<span className="flex items-center gap-2">
<Loader2
className="text-muted-foreground size-4 animate-spin motion-reduce:animate-none"
aria-hidden
/>
{t("admin.section.maintenance.state.queued")}
</span>
) : run?.state === "running" ? (
<span className="flex items-center gap-2">
<Loader2
className="text-muted-foreground size-4 animate-spin motion-reduce:animate-none"
aria-hidden
/>
{t("admin.section.maintenance.state.running", {
since: fmt.time(run.startedAt ?? run.requestedAt),
})}
</span>
) : run?.state === "completed" ? (
<span>
{run.outcome === "refused_purge_running"
? t("admin.section.maintenance.state.refusedPurge")
: run.outcome === "already_running"
? t("admin.section.maintenance.state.alreadyRunning")
: t("admin.section.maintenance.state.completed", {
at: fmt.dateTime(run.finishedAt ?? run.requestedAt),
})}
</span>
) : run?.state === "failed" ? (
<span className="text-destructive">
{t("admin.section.maintenance.state.failed", {
at: fmt.dateTime(run.finishedAt ?? run.requestedAt),
})}
</span>
) : (
<span className="text-muted-foreground">
{t("admin.section.maintenance.state.idle")}
</span>
)}
</div>
{s?.available && s.purgePending ? (
<p className="text-muted-foreground text-xs">
{t("admin.section.maintenance.purgePending")}
</p>
) : null}
<SettingsCardActions>
<AlertDialog>
<AlertDialogTrigger asChild>
<Button
size="sm"
className="min-h-11 sm:min-h-9"
disabled={blocked || start.isPending}
data-testid="admin-maintenance-start"
>
{start.isPending ? (
<Loader2
className="size-3.5 animate-spin motion-reduce:animate-none"
aria-hidden
/>
) : (
<Wrench className="size-3.5" aria-hidden />
)}
{t("admin.section.maintenance.start")}
</Button>
</AlertDialogTrigger>
<AlertDialogContent>
<AlertDialogHeader>
<AlertDialogTitle>
{t("admin.section.maintenance.confirmTitle")}
</AlertDialogTitle>
<AlertDialogDescription>
{t("admin.section.maintenance.confirmBody")}
</AlertDialogDescription>
</AlertDialogHeader>
<AlertDialogFooter>
<AlertDialogCancel>
{t("admin.section.maintenance.cancel")}
</AlertDialogCancel>
<AlertDialogAction onClick={() => start.mutate()}>
{t("admin.section.maintenance.confirm")}
</AlertDialogAction>
</AlertDialogFooter>
</AlertDialogContent>
</AlertDialog>
</SettingsCardActions>
</SettingsCard>
);
}
@@ -336,3 +336,40 @@ describe("<UploadStateCard>", () => {
expect(html).toContain("1 GB");
});
});
describe('<DocumentCard variant="tile"> (the archive grid)', () => {
it("puts a 4:3 preview above the title, falling back to the kind icon", () => {
const html = render(
<DocumentCard
variant="tile"
document={doc()}
selected={false}
onToggleSelected={noop}
onOpen={noop}
highlighted={false}
/>,
);
expect(html).toContain('data-variant="tile"');
const preview = html.indexOf('data-slot="document-preview"');
expect(preview).toBeGreaterThan(-1);
expect(html).toMatch(/data-slot="document-preview"[^>]*aspect-\[4\/3\]/);
// Preview first, title after it.
expect(html.indexOf("MRT Knie")).toBeGreaterThan(preview);
// No thumbnail rendered yet: the kind icon fills the preview, no <img>.
expect(html).not.toContain("<img");
});
it("keeps the row card as the default for every other surface", () => {
const html = render(
<DocumentCard
document={doc()}
selected={false}
onToggleSelected={noop}
onOpen={noop}
highlighted={false}
/>,
);
expect(html).toContain('data-variant="row"');
expect(html).not.toContain('data-slot="document-preview"');
});
});
@@ -0,0 +1,52 @@
/**
* The archive grid's shape: two tiles side by side on a phone, three or four
* on a desktop, measured from the grid's own width (the AuthShell inset is
* already taken off by the time the grid measures itself).
*/
import { describe, expect, it } from "vitest";
import { renderToStaticMarkup } from "react-dom/server";
import { I18nProvider } from "@/lib/i18n/context";
import {
columnsForWidth,
DocumentMonthHeading,
estimatedRowHeight,
} from "../document-month-grid";
describe("columnsForWidth", () => {
it("lays a 390 px phone out in two columns, the narrowest screens in one", () => {
// 390 viewport minus the shell's 16 px gutters.
expect(columnsForWidth(358)).toBe(2);
expect(columnsForWidth(320 - 32)).toBe(1);
});
it("uses three columns on a small desktop and four on a wide one", () => {
expect(columnsForWidth(1024 - 48)).toBe(3);
// 1440 viewport: the shell caps the container at 1280 minus its gutters.
expect(columnsForWidth(1280 - 48)).toBe(4);
});
it("never asks for a fifth column", () => {
expect(columnsForWidth(4000)).toBe(4);
});
});
describe("estimatedRowHeight", () => {
it("grows with the tile's width, so the first guess is close to the measured row", () => {
expect(estimatedRowHeight(358, 2)).toBeLessThan(
estimatedRowHeight(1232, 2),
);
expect(estimatedRowHeight(358, 2)).toBeGreaterThan(200);
});
});
describe("<DocumentMonthHeading>", () => {
it("keeps the month heading as the grid's section label", () => {
const html = renderToStaticMarkup(
<I18nProvider initialLocale="en">
<DocumentMonthHeading label="March 2026" />
</I18nProvider>,
);
expect(html).toMatch(/^<h2 [^>]*uppercase[^>]*>March 2026<\/h2>$/);
});
});
+112 -67
View File
@@ -52,7 +52,14 @@ export function DocumentCard({
tabIndex = 0,
onCardFocus,
onPrefetch,
variant = "row",
}: {
/**
* `row` (default): the compact card with the preview at its leading edge.
* `tile`: the archive grid's tile, the preview filling the top of the card
* so a page is recognisable before its title is read.
*/
variant?: "row" | "tile";
document: InboundDocumentDto;
selected: boolean;
/** `range` = extend the selection from the last anchor (shift-click). */
@@ -127,9 +134,76 @@ export function DocumentCard({
wasProcessingRef.current = processing;
}, [processing]);
const tile = variant === "tile";
const showThumbnail = !!thumbnailUrl && !thumbnailFailed;
// An object URL over bytes the app transport already fetched, not a
// `/api/…` subresource: the browser issues a subresource itself and so
// cannot carry the record-session assertion, which the fence refuses on any
// session that has been inside a shared record. `next/image` is wrong here
// for the older reason too — it would proxy a PHI blob we deliberately
// never cache. Decorative (alt="") — the title beside it names the
// document. The laziness that `loading="lazy"` used to provide now lives in
// the hook's null path: a card with no thumbnail, or one whose thumbnail
// already failed, issues no request at all. onError falls back to the kind
// icon.
const thumbnail = showThumbnail ? (
// eslint-disable-next-line @next/next/no-img-element
<img
src={thumbnailUrl}
alt=""
decoding="async"
onError={() => setThumbFailed(true)}
className={cn("size-full object-cover", tile && "object-top")}
/>
) : null;
const selection = onToggleSelected ? (
<Checkbox
checked={selected}
// Explicit click handling instead of onCheckedChange: the mouse
// event carries `shiftKey` for file-manager range selection.
// preventDefault stops Radix's internal toggle (state is fully
// controlled by the page's selection set anyway).
onClick={(e) => {
e.preventDefault();
onToggleSelected(document.id, e.shiftKey);
}}
aria-label={t("documents.card.selectLabel", { title })}
className={cn(
"relative z-10 shrink-0 transition-opacity",
"opacity-0 group-focus-within:opacity-100 group-hover:opacity-100",
selected && "opacity-100",
// On a tile the box floats over the preview, which can be any
// colour; the card background behind it keeps it readable.
tile && "bg-background absolute top-4 right-4",
)}
/>
) : null;
const titleBlock = (
<div className="flex min-w-0 flex-1 flex-col">
<p className="truncate text-sm font-medium">{title}</p>
<p className="text-muted-foreground truncate text-xs">
{date} · {size}
</p>
{showFilename ? (
// Filename on its OWN muted line so it never clips the date/size
// meta; the full name stays reachable on hover via `title`.
<p
data-slot="document-card-filename"
className="text-muted-foreground truncate text-xs"
title={document.filename ?? undefined}
>
{document.filename}
</p>
) : null}
</div>
);
return (
<Card
data-slot="document-card"
data-variant={variant}
data-document-id={document.id}
className={cn(
"group relative h-full gap-2 py-3 transition-shadow md:py-4",
@@ -137,76 +211,47 @@ export function DocumentCard({
highlighted && "ring-primary ring-2",
)}
>
<CardContent className="flex h-full flex-col gap-2 px-4">
<div className="flex items-start gap-2">
{thumbnailUrl && !thumbnailFailed ? (
// Leading-edge preview tile. Decorative (alt="") — the title
// beside it names the document. The laziness that `loading="lazy"`
// used to provide now lives in the hook's null path: a card with no
// thumbnail, or one whose thumbnail already failed, issues no
// request at all. onError falls back to the kind icon.
<CardContent
className={cn(
"flex h-full flex-col gap-2",
// A dense tile (UI standards §1): two or more of them sit side by
// side on a phone, where the default inset would eat the preview.
tile ? "px-3" : "px-4",
)}
>
{tile ? (
<>
<span
data-slot="document-thumbnail"
className="bg-muted mt-0.5 block size-12 shrink-0 overflow-hidden rounded-md"
data-slot="document-preview"
className="bg-muted flex aspect-[4/3] w-full items-center justify-center overflow-hidden rounded-lg"
>
{/* An object URL over bytes the app transport already fetched,
not a `/api/…` subresource: the browser issues a subresource
itself and so cannot carry the record-session assertion, which
the fence refuses on any session that has been inside a shared
record. `next/image` is wrong here for the older reason too —
it would proxy a PHI blob we deliberately never cache. */}
{/* eslint-disable-next-line @next/next/no-img-element */}
<img
src={thumbnailUrl}
alt=""
decoding="async"
onError={() => setThumbFailed(true)}
className="size-full object-cover"
/>
</span>
) : (
<Icon
className="text-foreground mt-0.5 size-5 shrink-0"
aria-hidden
/>
)}
<div className="flex min-w-0 flex-1 flex-col">
<p className="truncate text-sm font-medium">{title}</p>
<p className="text-muted-foreground truncate text-xs">
{date} · {size}
</p>
{showFilename ? (
// Filename on its OWN muted line so it never clips the date/size
// meta; the full name stays reachable on hover via `title`.
<p
data-slot="document-card-filename"
className="text-muted-foreground truncate text-xs"
title={document.filename ?? undefined}
>
{document.filename}
</p>
) : null}
</div>
{onToggleSelected && (
<Checkbox
checked={selected}
// Explicit click handling instead of onCheckedChange: the mouse
// event carries `shiftKey` for file-manager range selection.
// preventDefault stops Radix's internal toggle (state is fully
// controlled by the page's selection set anyway).
onClick={(e) => {
e.preventDefault();
onToggleSelected(document.id, e.shiftKey);
}}
aria-label={t("documents.card.selectLabel", { title })}
className={cn(
"relative z-10 shrink-0 transition-opacity",
"opacity-0 group-focus-within:opacity-100 group-hover:opacity-100",
selected && "opacity-100",
{thumbnail ?? (
<Icon className="text-foreground size-8" aria-hidden />
)}
/>
)}
</div>
</span>
{titleBlock}
{selection}
</>
) : (
<div className="flex items-start gap-2">
{thumbnail ? (
// Leading-edge preview tile.
<span
data-slot="document-thumbnail"
className="bg-muted mt-0.5 block size-12 shrink-0 overflow-hidden rounded-md"
>
{thumbnail}
</span>
) : (
<Icon
className="text-foreground mt-0.5 size-5 shrink-0"
aria-hidden
/>
)}
{titleBlock}
{selection}
</div>
)}
{document.conditionLinks.length > 0 ||
document.servingClass === "attachment" ||
processing ||
@@ -0,0 +1,92 @@
"use client";
/**
* The archive's month grid: a month heading, then that month's documents as
* preview tiles, so a page is recognisable by its look before its title is
* read. The timeline owns windowing and keyboard focus; this module owns how
* one windowed item is laid out and how many tiles share a row.
*
* Two tiles side by side on a phone (one on the narrowest screens), three or
* four on a desktop. The count comes from the grid's measured width, not from
* viewport breakpoints, so the virtualizer's row model and the painted grid
* can never disagree.
*/
import type { InboundDocumentDto } from "@/lib/validations/inbound-documents";
import { DocumentCard } from "./document-card";
/** Measured grid width → tiles per row. */
export function columnsForWidth(width: number): number {
if (width >= 1100) return 4;
if (width >= 760) return 3;
if (width >= 330) return 2;
return 1;
}
/** Gap between tiles and between rows, in px (`gap-4` / `pb-4`). */
const GRID_GAP_PX = 16;
/**
* First guess at a row's height before the virtualizer measures it: a 4:3
* preview across the tile's width plus the title and meta lines under it.
*/
export function estimatedRowHeight(width: number, columns: number): number {
const cols = Math.max(1, columns);
const tileWidth = Math.max(0, (width - GRID_GAP_PX * (cols - 1)) / cols);
return Math.round(tileWidth * 0.75) + 96 + GRID_GAP_PX;
}
export function DocumentMonthHeading({ label }: { label: string }) {
return (
<h2 className="text-muted-foreground pt-2 pb-3 text-xs font-medium tracking-wide uppercase">
{label}
</h2>
);
}
export function DocumentMonthRow({
documents,
columns,
selectedIds,
onToggleSelected,
onOpen,
onDelete,
highlightId,
rovingId,
onCardFocus,
onPrefetch,
}: {
documents: InboundDocumentDto[];
columns: number;
selectedIds: ReadonlySet<string>;
onToggleSelected?: (id: string, range?: boolean) => void;
onOpen: (id: string) => void;
onDelete?: (id: string) => void;
highlightId: string | null;
rovingId: string | null;
onCardFocus: (id: string) => void;
onPrefetch?: (id: string) => void;
}) {
return (
<div
data-slot="document-month-row"
className="grid gap-4 pb-4"
style={{ gridTemplateColumns: `repeat(${columns}, minmax(0, 1fr))` }}
>
{documents.map((doc) => (
<DocumentCard
key={doc.id}
variant="tile"
document={doc}
selected={selectedIds.has(doc.id)}
onToggleSelected={onToggleSelected}
onOpen={onOpen}
onDelete={onDelete}
highlighted={highlightId === doc.id}
tabIndex={rovingId === doc.id ? 0 : -1}
onCardFocus={onCardFocus}
onPrefetch={onPrefetch}
/>
))}
</div>
);
}
+36 -38
View File
@@ -1,7 +1,8 @@
"use client";
/**
* The vault timeline: a virtualized, month-sectioned card grid windowed
* The vault timeline: a virtualized, month-sectioned grid of preview tiles
* (`document-month-grid.tsx`) windowed
* with `@tanstack/react-virtual` over the shell's scroll container
* (`#main-content` — single scroll owner per the design standards; the
* timeline never brings its own scrollport). The flat item list (month
@@ -9,8 +10,9 @@
* mounted DOM stays bounded (< ~400 nodes) regardless of corpus size.
*
* Columns are measured, not breakpoint-classed: a ResizeObserver on the
* grid container drives the per-row chunking (4 / 3 / 2 / 1), which keeps
* the virtualizer's row model and the painted grid in lockstep.
* grid container drives the per-row chunking (4 / 3 on a desktop, 2 on a
* phone, 1 on the narrowest screens), which keeps the virtualizer's row model
* and the painted grid in lockstep.
*
* In-flight / failed uploads render as a small non-virtualized grid above
* the timeline — they are few (client concurrency 3) and must appear
@@ -28,20 +30,18 @@ import { useVirtualizer } from "@tanstack/react-virtual";
import { useTranslations } from "@/lib/i18n/context";
import type { InboundDocumentDto } from "@/lib/validations/inbound-documents";
import { DocumentCard, UploadStateCard } from "./document-card";
import { UploadStateCard } from "./document-card";
import {
columnsForWidth,
DocumentMonthHeading,
DocumentMonthRow,
estimatedRowHeight,
} from "./document-month-grid";
import type { UploadQueueItem } from "./use-document-upload";
import { buildTimelineItems, formatMonthLabel } from "./vault-utils";
const SCROLL_CONTAINER_ID = "main-content";
/** Measured-width → column count (desktop 4/3, tablet 2, phone 1). */
function columnsForWidth(width: number): number {
if (width >= 1200) return 4;
if (width >= 900) return 3;
if (width >= 600) return 2;
return 1;
}
export function DocumentTimeline({
documents,
uploadItems,
@@ -77,6 +77,7 @@ export function DocumentTimeline({
const { t, locale } = useTranslations();
const listRef = useRef<HTMLDivElement | null>(null);
const [columns, setColumns] = useState(1);
const [gridWidth, setGridWidth] = useState(0);
const [scrollMargin, setScrollMargin] = useState(0);
// Roving tabindex over the card grid: exactly one card is tabbable; the
@@ -88,7 +89,10 @@ export function DocumentTimeline({
useEffect(() => {
const el = listRef.current;
if (!el) return;
const update = () => setColumns(columnsForWidth(el.clientWidth));
const update = () => {
setColumns(columnsForWidth(el.clientWidth));
setGridWidth(el.clientWidth);
};
update();
const ro = new ResizeObserver(update);
ro.observe(el);
@@ -127,7 +131,10 @@ export function DocumentTimeline({
const virtualizer = useVirtualizer({
count: items.length,
getScrollElement: () => document.getElementById(SCROLL_CONTAINER_ID),
estimateSize: (index) => (items[index].type === "month" ? 40 : 140),
estimateSize: (index) =>
items[index].type === "month"
? 40
: estimatedRowHeight(gridWidth, columns),
getItemKey: (index) => items[index].key,
overscan: 6,
scrollMargin,
@@ -282,31 +289,22 @@ export function DocumentTimeline({
}}
>
{item.type === "month" ? (
<h2 className="text-muted-foreground pt-2 pb-3 text-xs font-medium tracking-wide uppercase">
{formatMonthLabel(item.key, locale)}
</h2>
<DocumentMonthHeading
label={formatMonthLabel(item.key, locale)}
/>
) : (
<div
className="grid gap-4 pb-4"
style={{
gridTemplateColumns: `repeat(${columns}, minmax(0, 1fr))`,
}}
>
{item.documents.map((doc) => (
<DocumentCard
key={doc.id}
document={doc}
selected={selectedIds.has(doc.id)}
onToggleSelected={onToggleSelected}
onOpen={onOpen}
onDelete={onDelete}
highlighted={highlightId === doc.id}
tabIndex={rovingId === doc.id ? 0 : -1}
onCardFocus={setActiveId}
onPrefetch={onPrefetch}
/>
))}
</div>
<DocumentMonthRow
documents={item.documents}
columns={columns}
selectedIds={selectedIds}
onToggleSelected={onToggleSelected}
onOpen={onOpen}
onDelete={onDelete}
highlightId={highlightId}
rovingId={rovingId}
onCardFocus={setActiveId}
onPrefetch={onPrefetch}
/>
)}
</div>
);
+10 -3
View File
@@ -993,10 +993,17 @@ export function DocumentsView() {
{list.isPending ? (
<div
data-slot="documents-loading"
className="grid grid-cols-1 gap-4 sm:grid-cols-2 lg:grid-cols-3"
// The archive's tile shape (a 4:3 preview over two text lines), in
// the timeline's column counts, so the grid does not jump when the
// first page lands.
className="grid grid-cols-2 gap-4 lg:grid-cols-3 xl:grid-cols-4"
>
{Array.from({ length: 9 }, (_, i) => (
<Skeleton key={i} className="h-28 rounded-xl" />
{Array.from({ length: 8 }, (_, i) => (
<div key={i} className="space-y-2">
<Skeleton className="aspect-[4/3] w-full rounded-xl" />
<Skeleton className="h-4 w-3/4" />
<Skeleton className="h-3 w-1/2" />
</div>
))}
</div>
) : list.isError ? (
@@ -0,0 +1,144 @@
/**
* A saved conversation opens at its last answer and stays there while late
* layout (charts, tables) grows the thread, until the reader takes over.
* Driven against a fake scroller: the test environment has no layout, and
* the behaviour under test is which scroll the thread asks for, and when.
*/
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { OPEN_AT_END_SETTLE_MS, openAtEnd } from "../open-at-end";
type Listener = () => void;
function fakeScroller(children = 3) {
const listeners = new Map<string, Set<Listener>>();
const el = {
scrollHeight: 1000,
children: Array.from({ length: children }, () => ({}) as Element),
scrollTo: vi.fn(),
addEventListener: (type: string, fn: Listener) => {
if (!listeners.has(type)) listeners.set(type, new Set());
listeners.get(type)!.add(fn);
},
removeEventListener: (type: string, fn: Listener) => {
listeners.get(type)?.delete(fn);
},
fire: (type: string) => {
for (const fn of [...(listeners.get(type) ?? [])]) fn();
},
listenerCount: () =>
[...listeners.values()].reduce((n, set) => n + set.size, 0),
};
return el;
}
/** A ResizeObserver whose callback the test fires by hand. */
function fakeResizeObserver() {
const instances: Array<{ fire: () => void; observed: unknown[] }> = [];
class FakeResizeObserver {
observed: unknown[] = [];
disconnected = false;
constructor(private readonly cb: () => void) {
instances.push(this as never);
}
observe(node: unknown) {
this.observed.push(node);
}
disconnect() {
this.disconnected = true;
}
fire() {
if (!this.disconnected) this.cb();
}
}
return {
Ctor: FakeResizeObserver as unknown as typeof ResizeObserver,
instances,
};
}
beforeEach(() => {
vi.useFakeTimers();
});
afterEach(() => {
vi.useRealTimers();
});
describe("openAtEnd", () => {
it("jumps to the end at once, without the smooth animation that lost it", () => {
const el = fakeScroller();
openAtEnd(el, { ResizeObserver: undefined, MutationObserver: undefined });
expect(el.scrollTo).toHaveBeenCalledTimes(1);
expect(el.scrollTo).toHaveBeenCalledWith({
top: 1000,
behavior: "instant",
});
});
it("follows the end when a chart that loads later grows the thread", () => {
const el = fakeScroller();
const ro = fakeResizeObserver();
openAtEnd(el, { ResizeObserver: ro.Ctor, MutationObserver: undefined });
expect(ro.instances[0].observed).toHaveLength(3);
el.scrollHeight = 1070; // one chart's height, the phone shortfall
ro.instances[0].fire();
expect(el.scrollTo).toHaveBeenLastCalledWith({
top: 1070,
behavior: "instant",
});
});
it("lets go the moment the reader scrolls, touches or presses a key", () => {
for (const event of ["wheel", "touchstart", "keydown", "pointerdown"]) {
const el = fakeScroller();
const ro = fakeResizeObserver();
openAtEnd(el, { ResizeObserver: ro.Ctor, MutationObserver: undefined });
el.fire(event);
el.scrollHeight = 2000;
ro.instances[0].fire();
expect(el.scrollTo, event).toHaveBeenCalledTimes(1);
expect(el.listenerCount(), event).toBe(0);
}
});
it("stops following on its own once the layout has had time to settle", () => {
const el = fakeScroller();
const ro = fakeResizeObserver();
openAtEnd(el, { ResizeObserver: ro.Ctor, MutationObserver: undefined });
vi.advanceTimersByTime(OPEN_AT_END_SETTLE_MS);
el.scrollHeight = 3000;
ro.instances[0].fire();
expect(el.scrollTo).toHaveBeenCalledTimes(1);
expect(el.listenerCount()).toBe(0);
});
it("stops when the caller says so, as on switching conversations", () => {
const el = fakeScroller();
const ro = fakeResizeObserver();
const stop = openAtEnd(el, {
ResizeObserver: ro.Ctor,
MutationObserver: undefined,
});
stop();
ro.instances[0].fire();
expect(el.scrollTo).toHaveBeenCalledTimes(1);
});
});
describe("the thread wires it to the conversation it opens", () => {
it("runs on a layout effect keyed on the conversation", async () => {
const { readFileSync } = await import("node:fs");
const { join } = await import("node:path");
const source = readFileSync(
join(
process.cwd(),
"src/components/insights/coach-panel/message-thread.tsx",
),
"utf8",
);
expect(source).toMatch(
/useLayoutEffect\(\(\) => \{[\s\S]*?return openAtEnd\(el\);[\s\S]*?\}, \[conversationId, hasMessages\]\);/,
);
});
});
@@ -4,6 +4,7 @@ import {
Fragment,
useCallback,
useEffect,
useLayoutEffect,
useMemo,
useRef,
useState,
@@ -18,6 +19,7 @@ import { ChatBubble, type FollowUpOffer, type ReplyOffer } from "./chat-bubble";
import type { SuggestedReply } from "./suggested-replies";
import { CoachMessageDatesProvider } from "./coach-results";
import { ScrollToBottomButton } from "./scroll-to-bottom-button";
import { openAtEnd } from "./open-at-end";
import { focusCoachComposer } from "./composer-focus";
import {
EMPTY_LIVE_TURN_KEYS,
@@ -579,6 +581,21 @@ export function MessageThread({
el.scrollTo({ top: el.scrollHeight, behavior: scrollBehaviorForUser() });
}, []);
// Opening a saved conversation lands on its last answer, and stays there
// while the answers' charts and tables finish loading (see `open-at-end`).
// Keyed on the conversation, so switching to another one re-opens at its
// end even when both have the same number of messages; a layout effect, so
// the first painted frame is already the end rather than the top.
const conversationId = conversation?.id ?? null;
const hasMessages = messages.length > 0;
useLayoutEffect(() => {
const el = scrollerRef.current;
if (!el || !conversationId || !hasMessages) return;
wasPinnedRef.current = true;
setPinned(true);
return openAtEnd(el);
}, [conversationId, hasMessages]);
// Auto-scroll on new messages OR streaming-content growth, but only
// when the user was already at the bottom. v1.4.25 W5 — the
// optimistic user bubble counts as a new message; scroll on its
@@ -0,0 +1,102 @@
/**
* Open a saved conversation at its end, and keep it there while the answers
* finish laying out.
*
* A conversation opened from the history used to land at the top on a wide
* screen and short of the last answer on a phone. Two things worked against
* the thread's ordinary auto-scroll. It scrolled smoothly, and the scroll
* events of that animation passed through positions that were not at the
* bottom, so the thread concluded the reader had scrolled away and stopped
* following. And the answers' charts and tables load after the messages, so
* the end moved down after the scroll had already finished: about 70 px on a
* phone, one chart's height.
*
* So the opening jump is instant, and for a short while afterwards every
* growth of the thread's content moves the view to the new end. The settling
* stops early the moment the reader does anything that means "let me look
* around" (a wheel, a touch, a key, a pointer press inside the thread), and
* on its own after {@link OPEN_AT_END_SETTLE_MS}.
*/
/** How long late layout (charts, tables, images) may still move the end. */
export const OPEN_AT_END_SETTLE_MS = 4000;
/** Events that mean the reader has taken over the scroll position. */
const READER_EVENTS = [
"wheel",
"touchstart",
"keydown",
"pointerdown",
] as const;
/** The part of an element the settling needs; a real `HTMLElement` fits. */
export interface OpenAtEndScroller {
readonly scrollHeight: number;
readonly children: ArrayLike<Element>;
scrollTo(options: ScrollToOptions): void;
addEventListener(type: string, listener: () => void): void;
removeEventListener(type: string, listener: () => void): void;
}
/** The observers to use; the browser's by default, fakes in a test. */
interface Observers {
ResizeObserver?: typeof ResizeObserver;
MutationObserver?: typeof MutationObserver;
}
/**
* Jump to the end now and follow the end while the content settles. Returns
* the function that stops following; call it on unmount or when another
* conversation opens.
*/
export function openAtEnd(
el: OpenAtEndScroller,
observers: Observers = {
ResizeObserver: globalThis.ResizeObserver,
MutationObserver: globalThis.MutationObserver,
},
): () => void {
// `instant`, not `auto`: the thread carries `scroll-smooth`, and under it
// `auto` animates, which is exactly the motion that lost the end before.
const toEnd = () =>
el.scrollTo({ top: el.scrollHeight, behavior: "instant" });
toEnd();
let stopped = false;
const resize = observers.ResizeObserver
? new observers.ResizeObserver(() => {
if (!stopped) toEnd();
})
: null;
const watch = (node: Element) => resize?.observe(node);
for (const child of Array.from(el.children)) watch(child);
// A bubble that mounts after the opening (a lazily loaded answer part)
// is watched from then on, and its own arrival moves the end too.
const mutations = observers.MutationObserver
? new observers.MutationObserver((records) => {
if (stopped) return;
for (const record of records) {
for (const node of Array.from(record.addedNodes)) {
// An element (nodeType 1), not a text node: only elements resize.
if (node.nodeType === 1) watch(node as Element);
}
}
toEnd();
})
: null;
mutations?.observe(el as unknown as Node, { childList: true });
const stop = () => {
if (stopped) return;
stopped = true;
resize?.disconnect();
mutations?.disconnect();
clearTimeout(timer);
for (const type of READER_EVENTS) el.removeEventListener(type, stop);
};
for (const type of READER_EVENTS) el.addEventListener(type, stop);
const timer = setTimeout(stop, OPEN_AT_END_SETTLE_MS);
return stop;
}
@@ -0,0 +1,193 @@
"use client";
import dynamic from "next/dynamic";
import { useEffect, type ComponentType } from "react";
import { Skeleton } from "@/components/ui/skeleton";
import { SettingsCard } from "@/components/settings/settings-card";
import type { SettingsSectionSlug } from "@/components/settings/section-slugs";
import type { IntegrationCallbackUrls } from "@/lib/integrations/callback-urls";
/**
* One settings section, loaded on its own.
*
* The section route renders exactly one of twenty-one sections, but importing
* them statically put all twenty-one (and everything under them: the import
* panel, the integration cards, the MCP and API token tables, the score
* editor) into the route's entry bundle, so opening "About" downloaded the
* whole settings tree. Each section is now its own chunk. A first load still
* renders the section on the server (`ssr` stays on), so nothing jumps; the
* placeholder below only shows while a client-side switch between sections
* fetches the next chunk.
*/
/** Props a section takes. Only Integrations takes any. */
interface SectionProps {
callbackUrls?: IntegrationCallbackUrls;
}
function SectionLoading() {
// The settings card shell itself, so the section does not move when the
// real cards arrive (UI standards §13: a loading state paints the card).
return (
<div className="space-y-6" data-slot="settings-section-loading">
<SettingsCard data-slot="settings-section-loading-card">
<Skeleton className="h-6 w-40" />
<Skeleton className="h-4 w-full max-w-md" />
<Skeleton className="h-9 w-full" />
</SettingsCard>
<SettingsCard data-slot="settings-section-loading-card">
<Skeleton className="h-6 w-32" />
<Skeleton className="h-4 w-full max-w-sm" />
</SettingsCard>
</div>
);
}
/**
* One import per section, shared by the lazy component below and by the
* preload. One call site per file keeps the bundler to one chunk per section;
* a second `import()` of the same file elsewhere emitted a second copy.
*/
const LOADERS: Record<
SettingsSectionSlug,
() => Promise<ComponentType<SectionProps>>
> = {
account: () =>
import("@/components/settings/account-section").then(
(m) => m.AccountSection,
),
access: () =>
import("@/components/settings/access-section").then((m) => m.AccessSection),
security: () =>
import("@/components/settings/security-section").then(
(m) => m.SecuritySection,
),
modules: () =>
import("@/components/settings/modules-section").then(
(m) => m.ModulesSection,
),
about: () =>
import("@/components/settings/about-section").then((m) => m.AboutSection),
ai: () => import("@/components/settings/ai-section").then((m) => m.AiSection),
coach: () =>
import("@/components/settings/coach-section").then((m) => m.CoachSection),
integrations: () =>
import("@/components/settings/integrations-section").then(
(m) =>
function IntegrationsWithUrls({ callbackUrls }: SectionProps) {
// The route always passes the server-resolved URLs; the guard
// keeps the section's own prop contract required.
if (!callbackUrls) return null;
return <m.IntegrationsSection callbackUrls={callbackUrls} />;
},
),
sources: () =>
import("@/components/settings/sources-section").then(
(m) => m.SourcesSection,
),
notifications: () =>
import("@/components/settings/notifications-section").then(
(m) => m.NotificationsSection,
),
layout: () =>
import("@/components/settings/layout-section").then((m) => m.LayoutSection),
environment: () =>
import("@/components/settings/environment-section").then(
(m) => m.EnvironmentSection,
),
anamnesis: () =>
import("@/components/settings/anamnesis-section").then(
(m) => m.AnamnesisSection,
),
score: () =>
import("@/components/settings/score-section").then((m) => m.ScoreSection),
thresholds: () =>
import("@/components/settings/thresholds-section").then(
(m) => m.ThresholdsSection,
),
api: () =>
import("@/components/settings/api-section").then((m) => m.ApiSection),
mcp: () =>
import("@/components/settings/mcp-section").then((m) => m.McpSection),
gesundheitsakte: () =>
import("@/components/settings/gesundheitsakte-section").then(
(m) => m.GesundheitsakteSection,
),
export: () =>
import("@/components/settings/export-section").then((m) => m.ExportSection),
advanced: () =>
import("@/components/settings/advanced-section").then(
(m) => m.AdvancedSection,
),
privacy: () =>
import("@/components/settings/privacy-section").then(
(m) => m.PrivacySection,
),
};
const SECTIONS: Record<SettingsSectionSlug, ComponentType<SectionProps>> = {
account: dynamic(LOADERS.account, { loading: () => <SectionLoading /> }),
access: dynamic(LOADERS.access, { loading: () => <SectionLoading /> }),
security: dynamic(LOADERS.security, { loading: () => <SectionLoading /> }),
modules: dynamic(LOADERS.modules, { loading: () => <SectionLoading /> }),
about: dynamic(LOADERS.about, { loading: () => <SectionLoading /> }),
ai: dynamic(LOADERS.ai, { loading: () => <SectionLoading /> }),
coach: dynamic(LOADERS.coach, { loading: () => <SectionLoading /> }),
integrations: dynamic(LOADERS.integrations, {
loading: () => <SectionLoading />,
}),
sources: dynamic(LOADERS.sources, { loading: () => <SectionLoading /> }),
notifications: dynamic(LOADERS.notifications, {
loading: () => <SectionLoading />,
}),
layout: dynamic(LOADERS.layout, { loading: () => <SectionLoading /> }),
environment: dynamic(LOADERS.environment, {
loading: () => <SectionLoading />,
}),
anamnesis: dynamic(LOADERS.anamnesis, { loading: () => <SectionLoading /> }),
score: dynamic(LOADERS.score, { loading: () => <SectionLoading /> }),
thresholds: dynamic(LOADERS.thresholds, {
loading: () => <SectionLoading />,
}),
api: dynamic(LOADERS.api, { loading: () => <SectionLoading /> }),
mcp: dynamic(LOADERS.mcp, { loading: () => <SectionLoading /> }),
gesundheitsakte: dynamic(LOADERS.gesundheitsakte, {
loading: () => <SectionLoading />,
}),
export: dynamic(LOADERS.export, { loading: () => <SectionLoading /> }),
advanced: dynamic(LOADERS.advanced, { loading: () => <SectionLoading /> }),
privacy: dynamic(LOADERS.privacy, { loading: () => <SectionLoading /> }),
};
/**
* The section mounts only once the record gate has the account
* (`RecordSettingsSectionGate`), so without a head start its chunk would be
* fetched after that and the reader would see two loading states in a row.
* This starts the fetch at hydration, beside the gate's own read; the module
* cache makes the later lazy render of the same file free.
*/
export function SettingsSectionPreload({
section,
}: {
section: SettingsSectionSlug;
}) {
useEffect(() => {
void LOADERS[section]().catch(() => {
// The section's own lazy import retries and reports; a failed head
// start changes nothing.
});
}, [section]);
return null;
}
export function SettingsSectionLoader({
section,
callbackUrls,
}: {
section: SettingsSectionSlug;
callbackUrls?: IntegrationCallbackUrls;
}) {
const Section = SECTIONS[section];
return <Section callbackUrls={callbackUrls} />;
}
+1 -1
View File
@@ -37,7 +37,7 @@ import {
settleRefusedRecordSessionTransition,
} from "@/lib/query-keys/record-session-transition";
import type { AccountAccess } from "@/lib/sharing/account-access-view";
import { parseAccountAccess } from "@/lib/sharing/account-access-schema";
import { parseAccountAccess } from "@/lib/sharing/account-access-parse";
/**
* v1.36.0 — an account with no sharing at all. The shape `fetchMe` falls back
+19
View File
@@ -496,9 +496,20 @@ export function calculateCompliance(
* `[ledgerFrom, now]`; the caller carves the 90-day heatmap out of it by
* filtering on `row.at`.
*/
/**
* The report windows a client may ask the batched compliance read for
* (`GET /api/medications/compliance?days=N`), beyond the 7 and 30 days every
* payload carries. Each is a suffix of the 365-day ledger window, so all of
* them are tallies over the rows the bundle already minted.
*/
export const COMPLIANCE_REPORT_DAYS = [30, 60, 90, 180, 365] as const;
export type ComplianceReportDays = (typeof COMPLIANCE_REPORT_DAYS)[number];
export interface MedicationComplianceBundle {
compliance7: ComplianceResult;
compliance30: ComplianceResult;
/** One result per report window, keyed by its length in days. */
reportWindows: Record<ComplianceReportDays, ComplianceResult>;
complianceDisplay: ComplianceDisplay;
/** Unified ledger rows over `[ledgerFrom, now]`, chronological. */
ledgerRows: DoseHistoryRow[];
@@ -704,9 +715,17 @@ export function buildMedicationComplianceBundle(
currentDose,
};
const reportWindows = Object.fromEntries(
COMPLIANCE_REPORT_DAYS.map((days) => [
days,
days === 30 ? compliance30 : resultForWindow(days),
]),
) as Record<ComplianceReportDays, ComplianceResult>;
return {
compliance7,
compliance30,
reportWindows,
complianceDisplay,
ledgerRows,
ledgerFrom,
+14
View File
@@ -6,6 +6,20 @@ export function apiSuccess<T>(data: T, status = 200) {
return NextResponse.json({ data, error: null }, { status });
}
/**
* A success envelope that also carries `meta`: figures ABOUT the payload
* (an aggregate across its rows, the window it was cut to) that do not belong
* inside any one row. `data` keeps the shape the route always had, so a
* client that never reads `meta` decodes the response unchanged.
*/
export function apiSuccessWithMeta<T>(
data: T,
meta: Record<string, unknown>,
status = 200,
) {
return NextResponse.json({ data, error: null, meta }, { status });
}
/**
* Sanitised view of a single Zod issue. We surface `path`, `code`,
* `message` and — for `unrecognized_keys` only — the bounded `keys`
+63 -16
View File
@@ -304,6 +304,33 @@ export async function createAuthenticationOptions(userId?: string) {
return { options, challengeId: challenge.id };
}
/**
* Why a passkey assertion could not be checked at all — as opposed to an
* assertion that was checked and did not verify. Each kind is a case a
* client can name to the person (the passkey was removed here, the sign-in
* took too long), so the sign-in route answers it with its own status and
* `meta.errorCode` instead of letting it surface as a server fault.
*
* - `challenge_expired`: the challenge is gone (expired, already used, never
* issued) or was begun for a different account.
* - `unknown_passkey`: no passkey with this credential id is registered here.
* - `malformed`: the assertion body is not an authentication response.
* - `verification_failed`: the WebAuthn library refused the assertion
* (origin, RP id, challenge or signature mismatch).
*/
export type PasskeyAuthErrorKind =
"challenge_expired" | "unknown_passkey" | "malformed" | "verification_failed";
export class PasskeyAuthError extends Error {
constructor(
readonly kind: PasskeyAuthErrorKind,
message: string,
) {
super(message);
this.name = "PasskeyAuthError";
}
}
export async function verifyAuthentication(
challengeId: string,
response: unknown,
@@ -318,7 +345,10 @@ export async function verifyAuthentication(
type: "authentication",
});
if (!challenge) {
throw new Error("Challenge expired or not found");
throw new PasskeyAuthError(
"challenge_expired",
"Challenge expired or not found",
);
}
// v1.4.43 W13 L-3 — explicit Zod narrowing instead of the previous
@@ -329,7 +359,10 @@ export async function verifyAuthentication(
// type-narrowing gap a future refactor could trip on.
const parsed = authenticationResponseSchema.safeParse(response);
if (!parsed.success) {
throw new Error("Malformed passkey authentication response");
throw new PasskeyAuthError(
"malformed",
"Malformed passkey authentication response",
);
}
const typedResponse = parsed.data as unknown as AuthenticationResponseJSON;
@@ -340,27 +373,41 @@ export async function verifyAuthentication(
});
if (!passkey) {
throw new Error("Passkey not found");
throw new PasskeyAuthError("unknown_passkey", "Passkey not found");
}
// A challenge begun for one account (the re-proof arm names the account)
// is answered only by that account's passkey.
if (challenge.userId !== null && challenge.userId !== passkey.userId) {
throw new Error("Challenge expired or not found");
throw new PasskeyAuthError(
"challenge_expired",
"Challenge expired or not found",
);
}
const verification = await verifyAuthenticationResponse({
response: typedResponse,
expectedChallenge: challenge.challenge,
expectedOrigin: getExpectedOrigin(),
expectedRPID: getRpId(),
credential: {
id: passkey.credentialId,
publicKey: passkey.credentialPublicKey,
counter: Number(passkey.counter),
transports: passkey.transports as Transport[],
},
});
let verification: VerifiedAuthenticationResponse;
try {
verification = await verifyAuthenticationResponse({
response: typedResponse,
expectedChallenge: challenge.challenge,
expectedOrigin: getExpectedOrigin(),
expectedRPID: getRpId(),
credential: {
id: passkey.credentialId,
publicKey: passkey.credentialPublicKey,
counter: Number(passkey.counter),
transports: passkey.transports as Transport[],
},
});
} catch (err) {
// The library throws, rather than answering `verified: false`, for an
// origin, RP id or challenge mismatch and for a bad signature. Those are
// a refused assertion, not a server fault.
throw new PasskeyAuthError(
"verification_failed",
err instanceof Error ? err.message : "Passkey verification failed",
);
}
if (verification.verified) {
// Update counter + stamp last-used so the management UI can surface
+12
View File
@@ -95,6 +95,18 @@ export function glucoseBandParams(
};
}
/**
* The stored glucose-unit choice as the closed pair, or `null` when none was
* made. The column is free text (a restored backup writes it unchecked), so a
* value that is neither unit reads as no choice rather than passing through to
* a client that decodes the pair.
*/
export function storedGlucoseUnit(
value: string | null | undefined,
): GlucoseUnit | null {
return value === "mg/dL" || value === "mmol/L" ? value : null;
}
export function resolveGlucoseUnit(
userPreference: string | null | undefined,
): GlucoseUnit {
@@ -410,6 +410,23 @@ describe("computeMoodAggregates", () => {
]);
expect(agg.stability).toBeNull();
});
it("scores stability per trailing window, so a steady month after a turbulent year reads steady", () => {
// Days 0..29 sit at 4; days 30..119 swing between 1 and 5.
const entries: MoodAggregateEntry[] = [];
for (let d = 0; d < 30; d++) entries.push(entry(d, 4));
for (let d = 30; d < 120; d++) entries.push(entry(d, d % 2 ? 1 : 5));
const agg = computeMoodAggregates({ entries, measurements: [], now: NOW });
expect(agg.stabilityByWindow[30]?.score).toBe(100);
expect(agg.stabilityByWindow[30]?.days).toBe(30);
expect(agg.stabilityByWindow[90]?.score).toBeLessThan(
agg.stabilityByWindow[30]!.score,
);
// The whole-year entry is the score `stability` has always carried.
expect(agg.stabilityByWindow[365]).toEqual(agg.stability);
expect(agg.stability?.days).toBe(120);
});
});
describe("bucketForHour", () => {
+26
View File
@@ -328,6 +328,14 @@ export function pairDailyBuckets(
export type HeatmapWindowDays = 30 | 90 | 365;
/**
* The trailing windows the stability score is offered over. 365 is the
* whole daily series the aggregate keeps, which is what `stability` has
* always covered.
*/
export const MOOD_STABILITY_WINDOWS = [30, 90, 180, 365] as const;
export type MoodStabilityWindow = (typeof MOOD_STABILITY_WINDOWS)[number];
/**
* Adaptive heatmap window so the grid is never mostly-empty.
*
@@ -497,6 +505,13 @@ export interface MoodAggregates {
* descriptive band. `null` for a sparse logger (< STABILITY_MIN_DAYS).
*/
stability: MoodStability | null;
/**
* The same score over the shorter trailing windows a client can pick
* (`GET /api/mood/insights?days=N`). Cached with the rest of the aggregate
* so a period switch costs nothing; the route serves the chosen one as
* `stability` and does not publish this map.
*/
stabilityByWindow: Record<MoodStabilityWindow, MoodStability | null>;
tags: TagSummaryRow[];
/**
* v1.38 — how the day's pleasantness sat on days carrying each context
@@ -608,6 +623,16 @@ export function computeMoodAggregates(args: {
const weekday = computeWeekdayAverages(moodDaily, now, tz);
const timeOfDay = computeTimeOfDayAverages(entries);
const stability = computeMoodStability(moodDaily);
const stabilityByWindow = Object.fromEntries(
MOOD_STABILITY_WINDOWS.map((days) => [
days,
days === 365
? stability
: computeMoodStability(
moodDaily.filter((bucket) => bucket.dayOffset < days),
),
]),
) as Record<MoodStabilityWindow, MoodStability | null>;
const tags = computeTagSummary(entries, now);
const structuredTags = computeStructuredTagSummary(entries, now);
const tagInfluence = computeTagInfluence(entries, now);
@@ -689,6 +714,7 @@ export function computeMoodAggregates(args: {
weekday,
timeOfDay,
stability,
stabilityByWindow,
tags,
structuredTags,
tagInfluence,
@@ -223,6 +223,7 @@ describe("handleReminderCheck per-slot reminder windows", () => {
metadata: expect.objectContaining({
phase: "ORANGE",
timeOfDay: "08:00",
followUp: true,
}),
}),
);
@@ -248,6 +249,34 @@ describe("handleReminderCheck per-slot reminder windows", () => {
metadata: expect.objectContaining({
phase: "YELLOW",
timeOfDay: "08:00",
// GREEN announced this window; YELLOW escalates an open dose.
followUp: true,
}),
}),
);
});
it("marks the phase that announces the dose as the one reminder that is not a follow-up", async () => {
vi.useFakeTimers();
// 55 minutes before the 09:30 end of a 07:30 to 09:30 window: GREEN.
vi.setSystemTime(new Date("2026-07-28T08:35:00.000Z"));
prismaMock.medication.findMany.mockResolvedValue([
medicationWithSchedule({
windowEnd: "18:00",
timesOfDay: ["08:00", "18:00"],
doseWindows: [{ timeOfDay: "08:00", start: "07:30", end: "09:30" }],
}),
] as never);
setIntakeEvents([]);
await handleReminderCheck([]);
expect(dispatchNotification).toHaveBeenCalledWith(
expect.objectContaining({
metadata: expect.objectContaining({
phase: "GREEN",
timeOfDay: "08:00",
followUp: false,
}),
}),
);
@@ -3,6 +3,7 @@ import { describe, it, expect } from "vitest";
import {
determinePhase,
getPhaseKeyboard,
openingPhase,
getPhaseMessage,
resolvePhaseThresholds,
DEFAULT_PHASE_CONFIG,
@@ -142,3 +143,26 @@ describe("getPhaseKeyboard — localised", () => {
}
});
});
describe("openingPhase", () => {
it("is GREEN for a window longer than the YELLOW lead", () => {
const t = resolvePhaseThresholds(DEFAULT_PHASE_CONFIG, 120);
expect(openingPhase(t, 120)).toBe("GREEN");
});
it("is YELLOW for a point slot, which never shows GREEN", () => {
const t = resolvePhaseThresholds(DEFAULT_PHASE_CONFIG, 0);
expect(openingPhase(t, 0)).toBe("YELLOW");
// The same window walked tick by tick reaches YELLOW before anything else.
expect(determinePhase(30, -30, t)).toBe("YELLOW");
expect(determinePhase(45, -45, t)).toBeNull();
});
it("is YELLOW when the GREEN lead is not longer than the YELLOW lead", () => {
const t = resolvePhaseThresholds(
{ ...DEFAULT_PHASE_CONFIG, greenValue: 20, yellowValue: 30 },
120,
);
expect(openingPhase(t, 120)).toBe("YELLOW");
});
});
@@ -0,0 +1,129 @@
/**
* What the admin card shows about the measurement table maintenance: the
* newest run and where it stands, whether the compaction-tombstone purge is
* still at work (the run refuses to start while it is), and the table's size
* right now.
*
* Read straight from `pgboss.job`, the same source `job-failures.ts` reads,
* and fail-soft the same way: a web-only deployment has no `pgboss` schema,
* and the card says "no background worker" instead of failing.
*/
import { prisma } from "@/lib/db";
import { MEASUREMENT_MAINTENANCE_QUEUE } from "@/lib/jobs/measurement-maintenance";
const PURGE_QUEUE = "compaction-tombstone-purge";
/** Where the newest run stands, in the words the card uses. */
export type MaintenanceRunState = "queued" | "running" | "completed" | "failed";
/**
* How a finished run ended. `completed` did the work; the two refusals
* finished without touching the table.
*/
export type MaintenanceRunOutcome =
"completed" | "refused_purge_running" | "already_running";
export interface MeasurementMaintenanceStatus {
/** False when there is no background queue to ask (web-only deployment). */
available: boolean;
/** The purge is queued or running; a new run would refuse to start. */
purgePending: boolean;
run: {
state: MaintenanceRunState;
requestedAt: string;
startedAt: string | null;
finishedAt: string | null;
/** Only for `completed`: what the finished run actually did. */
outcome: MaintenanceRunOutcome | null;
} | null;
/** `measurements` with its indexes and TOAST, and its indexes alone. */
sizes: { tableBytes: number; indexBytes: number } | null;
}
const OUTCOMES: ReadonlySet<string> = new Set([
"completed",
"refused_purge_running",
"already_running",
]);
/** pg-boss's row state → the card's run state. */
export function runStateOf(state: string): MaintenanceRunState {
if (state === "created" || state === "retry") return "queued";
if (state === "active") return "running";
if (state === "completed") return "completed";
return "failed";
}
async function readSizes(): Promise<MeasurementMaintenanceStatus["sizes"]> {
try {
const rows = await prisma.$queryRaw<
Array<{ table_bytes: bigint; index_bytes: bigint }>
>`
SELECT pg_total_relation_size('measurements'::regclass) AS table_bytes,
pg_indexes_size('measurements'::regclass) AS index_bytes
`;
const row = rows[0];
if (!row) return null;
return {
tableBytes: Number(row.table_bytes),
indexBytes: Number(row.index_bytes),
};
} catch {
return null;
}
}
export async function readMeasurementMaintenanceStatus(): Promise<MeasurementMaintenanceStatus> {
const sizes = await readSizes();
try {
const [runs, purge] = await Promise.all([
prisma.$queryRaw<
Array<{
state: string;
created_on: Date;
started_on: Date | null;
completed_on: Date | null;
outcome: string | null;
}>
>`
SELECT state, created_on, started_on, completed_on,
output->'did'->>'outcome' AS outcome
FROM pgboss.job
WHERE name = ${MEASUREMENT_MAINTENANCE_QUEUE}
ORDER BY created_on DESC
LIMIT 1
`,
prisma.$queryRaw<Array<{ n: number }>>`
SELECT count(*)::int AS n
FROM pgboss.job
WHERE name = ${PURGE_QUEUE}
AND state IN ('created', 'retry', 'active')
`,
]);
const row = runs[0];
const state = row ? runStateOf(row.state) : null;
return {
available: true,
purgePending: (purge[0]?.n ?? 0) > 0,
run:
row && state
? {
state,
requestedAt: row.created_on.toISOString(),
startedAt: row.started_on?.toISOString() ?? null,
finishedAt: row.completed_on?.toISOString() ?? null,
outcome:
state === "completed" &&
row.outcome !== null &&
OUTCOMES.has(row.outcome)
? (row.outcome as MaintenanceRunOutcome)
: null,
}
: null,
sizes,
};
} catch {
// No `pgboss` schema (web-only deployment) or no permission to read it.
return { available: false, purgePending: false, run: null, sizes };
}
}
+25
View File
@@ -84,6 +84,31 @@ export function resolvePhaseThresholds(
};
}
/**
* The first phase a slot's window reaches, which is the reminder that
* announces the dose; every later phase is a follow-up for a dose that is
* still open.
*
* It is not always GREEN. GREEN needs the window to have opened AND to be
* within `greenMinBefore` of its end, while YELLOW needs only the second
* condition with the smaller `yellowMinBefore`. A window no longer than the
* YELLOW lead (a point slot such as 07:00 to 07:00 is zero minutes long)
* reaches YELLOW first and never shows GREEN, and so does any configuration
* whose GREEN lead is not longer than its YELLOW lead.
*/
export function openingPhase(
thresholds: ReturnType<typeof resolvePhaseThresholds>,
windowDurationMin: number,
): ReminderPhase {
if (
windowDurationMin <= thresholds.yellowMinBefore ||
thresholds.greenMinBefore <= thresholds.yellowMinBefore
) {
return "YELLOW";
}
return "GREEN";
}
/**
* Determine the current phase for a schedule based on minutes to window end.
*
@@ -31,6 +31,7 @@ import {
determinePhase,
getPhaseMessage,
getPhaseKeyboard,
openingPhase,
} from "@/lib/jobs/reminder-phases";
import {
claimNotificationEvent,
@@ -555,6 +556,9 @@ export async function handleReminderCheck(
windowStart: phaseWindow.start,
minutesToEnd,
currentPhase,
followUp:
currentPhase !==
openingPhase(thresholds, windowDuration),
}
: null;
})
@@ -570,6 +574,7 @@ export async function handleReminderCheck(
windowStart,
minutesToEnd,
currentPhase,
followUp,
} = phaseCandidate;
const slotInstant = slotScheduledFor.getTime();
if (liveEraStart !== null && slotInstant < liveEraStart) {
@@ -767,6 +772,12 @@ export async function handleReminderCheck(
medicationId: med.id,
scheduleId: schedule.id,
phase: currentPhase,
// False for the reminder that announces the dose (the
// slot's opening phase), true for every escalation after
// it. A client that reminds locally at dose time
// (`medication.clientManaged`) replaces only the first
// one, so only that one is kept off APNs.
followUp,
date: slotScheduledFor.toLocaleDateString("sv-SE", {
timeZone: userTz,
}),
+1 -1
View File
@@ -66,7 +66,7 @@ import {
resolveGlucoseUnit,
type GlucoseUnit,
} from "@/lib/glucose";
import { getUnitForType } from "@/lib/validations/measurement";
import { getUnitForType } from "@/lib/measurements/unit-map";
export type UnitPreference = "metric" | "imperial";
+163
View File
@@ -0,0 +1,163 @@
/**
* The canonical storage unit of every measurement type.
*
* Its own module, with no imports, because both ends read it: the write
* validation in `validations/measurement.ts` and the client's display
* transform (`display-transform.ts`), which runs on nearly every chart and
* tile. Living inside the validation module it dragged Zod into each of those
* routes for one table lookup. `validations/measurement.ts` re-exports
* `getUnitForType`, so server callers keep their import.
*/
const unitMap: Record<string, string> = {
WEIGHT: "kg",
BLOOD_PRESSURE_SYS: "mmHg",
BLOOD_PRESSURE_DIA: "mmHg",
PULSE: "bpm",
BODY_FAT: "%",
// v1.4.23 — sleep duration shifted from hours to minutes so HealthKit
// category-sample stages can be stored without precision loss. Older
// surfaces that need hours convert at read time (`minutes / 60`).
SLEEP_DURATION: "minutes",
ACTIVITY_STEPS: "steps",
BLOOD_GLUCOSE: "mg/dL",
TOTAL_BODY_WATER: "kg",
BONE_MASS: "kg",
OXYGEN_SATURATION: "%",
// ── v1.4.23 Apple Health canonical units ──
HEART_RATE_VARIABILITY: "ms",
RESTING_HEART_RATE: "bpm",
ACTIVE_ENERGY_BURNED: "kcal",
FLIGHTS_CLIMBED: "flights",
WALKING_RUNNING_DISTANCE: "m",
VO2_MAX: "mL/(kg·min)",
BODY_TEMPERATURE: "celsius",
// ── v1.4.25 W5d Withings full coverage ──
FAT_FREE_MASS: "kg",
FAT_MASS: "kg",
MUSCLE_MASS: "kg",
// Distinct from BODY_TEMPERATURE — surface temps run ~32 °C; sharing
// the bucket would corrupt analytics. Same canonical unit (°C).
SKIN_TEMPERATURE: "celsius",
PULSE_WAVE_VELOCITY: "m/s",
VASCULAR_AGE: "years",
// Withings reports visceral fat as a 1–12 rating, not a percent. The
// string mirrors what Withings prints in Health Mate.
VISCERAL_FAT: "rating",
// ── v1.4.25 W8d Apple Health server-prep ──
// Sound-pressure level — A-weighted decibels (dBA). HealthKit reports
// both audio-exposure metrics in dBASPL; we store the unweighted "dBA"
// label because the A-weighting is implicit (every HealthKit audio
// sample carries it). 30 dBA = quiet bedroom; 140 dBA = pain threshold.
AUDIO_EXPOSURE_ENV: "dBA",
AUDIO_EXPOSURE_HEADPHONE: "dBA",
// Daily-rollup pattern (one sample = one day's outdoor-light minutes).
// 0–1440 covers the 24-hour day; in practice indoor users sit near 0
// and outdoor athletes accumulate a few hours.
TIME_IN_DAYLIGHT: "minutes",
// ── v1.5.5 iOS-coord additions ──
// Respiratory rate breaths-per-minute — the HK identifier ships as
// `count/min`; we keep the more conventional clinical label.
RESPIRATORY_RATE: "breaths/min",
// BMI kg/m² — HealthKit ships the unitless ratio; the canonical
// display string mirrors clinical convention.
BODY_MASS_INDEX: "kg/m²",
// Lean body mass kg — body-composition partner to FAT_MASS.
LEAN_BODY_MASS: "kg",
// Walking heart rate average bpm — daily rollup; distinct from
// RESTING_HEART_RATE (sleep-window minimum) and spot PULSE.
WALKING_HEART_RATE_AVERAGE: "bpm",
// Walking gait percent (0-100 after server-side ×100 scaling).
// Same convention as WALKING_STEADINESS / BODY_FAT / OXYGEN_SATURATION
// — see the project convention block in `apple-health-mapping.ts`.
WALKING_ASYMMETRY: "%",
WALKING_DOUBLE_SUPPORT: "%",
// ── v1.5.5 iOS-coord follow-up — raw-SI gait pair ──
// Step length is metres; speed is metres per second. Both flow
// raw on the wire — no server-side scaling. The unit strings
// match HealthKit's `m` / `m/s` defaults.
WALKING_STEP_LENGTH: "m",
WALKING_SPEED: "m/s",
// ── v1.10.0 — additive HealthKit signals (WX-A) ──
// Cardio recovery is the bpm drop one minute after peak exercise.
CARDIO_RECOVERY: "bpm",
// Overnight wrist temperature in °C (absolute reading; Apple's own
// display frames it as a baseline deviation, we store the reading).
WRIST_TEMPERATURE: "celsius",
// Hard-fall detections — a plain count.
FALL_COUNT: "count",
// Apple's estimated six-minute-walk-test distance in metres.
SIX_MINUTE_WALK_DISTANCE: "m",
// Stair gait speeds — raw metres-per-second (no scaling).
STAIR_ASCENT_SPEED: "m/s",
STAIR_DESCENT_SPEED: "m/s",
// Per-night breathing-disturbance index — a unitless count Apple
// classifies as NotElevated / Elevated.
BREATHING_DISTURBANCES: "count",
// ── v1.10.0 — categorical events (WX-B) ──
// EVENT rows are dimensionless occurrences (value is always 1). The
// canonical unit is the bare "event" so any accidental numeric surfacing
// reads sensibly; the awareness timeline never displays the value.
IRREGULAR_RHYTHM_NOTIFICATION: "event",
HIGH_HEART_RATE_EVENT: "event",
LOW_HEART_RATE_EVENT: "event",
WALKING_STEADINESS_EVENT: "event",
BREATHING_DISTURBANCE_EVENT: "event",
// ── v1.10.0 — computed scores (WX-C) ──
// Server-derived 0–100 wellness scores. The canonical unit is the bare
// "score" so the value reads sensibly anywhere it surfaces.
RECOVERY_SCORE: "score",
STRESS_SCORE: "score",
STRAIN_SCORE: "score",
// ── v1.11.0 — WHOOP-native score classes ──
// RMSSD HRV is in milliseconds, same canonical unit as the SDNN
// HEART_RATE_VARIABILITY (different estimator, same dimension).
HRV_RMSSD: "ms",
// Day / workout strain ride WHOOP's bounded 0–21 scale; the bare "score"
// unit reads sensibly wherever the value surfaces (distinct from the
// 0–100 COMPUTED STRAIN_SCORE).
DAY_STRAIN: "score",
WORKOUT_STRAIN: "score",
// Sleep quality percentages (0–100).
SLEEP_PERFORMANCE: "%",
SLEEP_EFFICIENCY: "%",
SLEEP_CONSISTENCY: "%",
// Recommended sleep duration in minutes (WHOOP reports ms; mapper ÷60000).
SLEEP_NEED: "minutes",
// Day energy expenditure in kilojoules (WHOOP-native; kept in kJ so the
// device value round-trips rather than being converted to kcal).
ENERGY_EXPENDITURE_KJ: "kJ",
// ── v1.12.8 — WHOOP cycle + sleep coverage completion ──
// Daily average / max heart rate bpm — whole-cycle aggregates, distinct
// from the spot PULSE / RESTING_HEART_RATE / WALKING_HEART_RATE_AVERAGE.
AVERAGE_HEART_RATE: "bpm",
MAX_HEART_RATE: "bpm",
// Per-night sleep disturbance tally — a plain integer count.
SLEEP_DISTURBANCE_COUNT: "count",
// ── v1.17.1 — Polar Nightly Recharge + Training Load Pro components ──
ANS_CHARGE: "score",
CARDIO_LOAD: "score",
// ── v1.17.1 — Oura coverage completion ──
// Oura's headline 0–100 Sleep Score — bare "score" like the other 0–100 scores.
SLEEP_SCORE: "score",
// Signed body-temperature deviation in °C (Oura nightly baseline offset).
BODY_TEMPERATURE_DEVIATION: "celsius",
// ── v1.19.0 — Oura resilience ──
// Ordinal level scale (1=limited … 5=exceptional) — the categorical band
// encoded into the numeric value. See RESILIENCE_LEVELS in src/lib/oura/client.
RESILIENCE: "level",
// ── v1.25 — clinical-signals wave ──
PHQ9_SCORE: "score",
GAD7_SCORE: "score",
// ── v1.27.9 — screening scores ──
WHO5_SCORE: "score",
SCI_SCORE: "score",
GRIP_STRENGTH: "kg",
PAIN_NRS: "score",
WAIST_CIRCUMFERENCE: "cm",
WAIST_TO_HEIGHT: "ratio",
};
export function getUnitForType(type: string): string {
return unitMap[type] ?? "unknown";
}
@@ -0,0 +1,44 @@
import { describe, expect, it } from "vitest";
import { aggregateCompliance } from "../compliance-payload";
function result(taken: number, missed: number, skipped = 0, streak = 0) {
return {
totalExpected: taken + missed + skipped,
taken,
skipped,
missed,
rate:
taken + missed > 0 ? Math.round((100 * taken) / (taken + missed)) : 100,
streak,
};
}
describe("aggregateCompliance", () => {
it("weights by expected doses rather than averaging the rates", () => {
// A three-times-daily tablet at 60/90 and a weekly injection at 4/4.
// The mean of the rates would read 83 %; the doses say 64/94 = 68 %.
const out = aggregateCompliance([result(60, 30), result(4, 0)]);
expect(out).toMatchObject({
totalExpected: 94,
taken: 64,
missed: 30,
rate: 68,
});
});
it("keeps skipped doses out of the rate, as a single medication's tally does", () => {
expect(aggregateCompliance([result(9, 1, 5)])?.rate).toBe(90);
expect(aggregateCompliance([result(9, 1, 5)])?.totalExpected).toBe(15);
});
it("takes the shortest streak, because a day counts only when every medication was taken", () => {
expect(
aggregateCompliance([result(5, 0, 0, 12), result(5, 0, 0, 3)])?.streak,
).toBe(3);
});
it("is null when nothing contributes", () => {
expect(aggregateCompliance([])).toBeNull();
});
});
@@ -1,6 +1,9 @@
import { describe, expect, it, vi } from "vitest";
import { assertMedicationOwnership } from "../route-guards";
import {
assertMedicationOwnership,
assertMedicationTakesIntake,
} from "../route-guards";
function buildClient(med: { id: string; userId: string } | null) {
return {
@@ -72,3 +75,34 @@ describe("assertMedicationOwnership", () => {
expect(call.select).toEqual({ id: true, userId: true });
});
});
describe("assertMedicationTakesIntake", () => {
function client(
med: { id: string; userId: string; trackIntake: boolean } | null,
) {
return { medication: { findUnique: vi.fn().mockResolvedValue(med) } };
}
it("admits a tracked medication the caller holds", async () => {
const c = client({ id: "med-1", userId: "user-1", trackIntake: true });
expect(await assertMedicationTakesIntake("med-1", "user-1", c)).toBeNull();
expect(c.medication.findUnique).toHaveBeenCalledWith({
where: { id: "med-1" },
select: { id: true, userId: true, trackIntake: true },
});
});
it("refuses a record-only medication by name", async () => {
const c = client({ id: "med-1", userId: "user-1", trackIntake: false });
const result = await assertMedicationTakesIntake("med-1", "user-1", c);
expect(result?.status).toBe(422);
const body = await result!.json();
expect(body.meta.errorCode).toBe("medication.intake.notTracked");
});
it("answers 404, not 422, for a record-only medication of another account", async () => {
const c = client({ id: "med-1", userId: "owner", trackIntake: false });
const result = await assertMedicationTakesIntake("med-1", "intruder", c);
expect(result?.status).toBe(404);
});
});
+64
View File
@@ -15,7 +15,9 @@ import {
buildMedicationComplianceBundle,
expectsDoses,
lastNonSkippedTakenAt,
COMPLIANCE_REPORT_DAYS,
type ComplianceDisplay,
type ComplianceReportDays,
type ComplianceResult,
type DailyComplianceEntry,
} from "@/lib/analytics/compliance";
@@ -47,8 +49,17 @@ export interface CompliancePayload {
compliance30: ComplianceResult;
dailyCompliance: Record<string, DailyComplianceEntry>;
complianceDisplay: ComplianceDisplay | null;
/**
* The report windows the batched read serves on `?days=N`. Cached with the
* rest of the cell so a report read costs no second ledger pass; NOT on the
* per-medication wire, which keeps its published shape.
*/
reportWindows: Record<ComplianceReportDays, ComplianceResult>;
}
/** The cached payload minus the fields only the batched read serves. */
export type CompliancePayloadWire = Omit<CompliancePayload, "reportWindows">;
/**
* Legacy-compatible placeholder for a medication whose adherence percentage
* is explicitly not applicable.
@@ -68,6 +79,13 @@ const NOT_APPLICABLE_LEGACY_COMPLIANCE: ComplianceResult = {
streak: 0,
};
const NOT_APPLICABLE_REPORT_WINDOWS = Object.fromEntries(
COMPLIANCE_REPORT_DAYS.map((days) => [
days,
NOT_APPLICABLE_LEGACY_COMPLIANCE,
]),
) as Record<ComplianceReportDays, ComplianceResult>;
/** The medication slice the payload builder consumes. */
export interface ComplianceMedicationInput {
id: string;
@@ -194,6 +212,7 @@ export async function buildCompliancePayload(
compliance30: NOT_APPLICABLE_LEGACY_COMPLIANCE,
dailyCompliance: {},
complianceDisplay: null,
reportWindows: NOT_APPLICABLE_REPORT_WINDOWS,
};
}
@@ -207,6 +226,7 @@ export async function buildCompliancePayload(
compliance30: NOT_APPLICABLE_LEGACY_COMPLIANCE,
dailyCompliance: {},
complianceDisplay: null,
reportWindows: NOT_APPLICABLE_REPORT_WINDOWS,
};
}
@@ -314,5 +334,49 @@ export async function buildCompliancePayload(
compliance30: bundle.compliance30,
dailyCompliance,
complianceDisplay: bundle.complianceDisplay,
reportWindows: bundle.reportWindows,
};
}
/**
* One adherence figure for the whole account, in the per-medication
* `ComplianceResult` shape, weighted by expected doses: the counts are summed
* across every applicable medication and the rate is recomputed from the sums
* with the same rule a single medication's tally uses
* (`round(100 · taken / (taken + missed))`, capped at 100, 100 when nothing
* was expected). Averaging the per-medication rates instead would let a
* weekly injection weigh as much as a three-times-daily tablet.
*
* `streak` is the shortest per-medication streak: a day only extends the
* account's streak when every medication's doses were taken that day.
*
* `null` when no medication contributes, so a client shows nothing rather
* than a vacuous 100 %.
*/
export function aggregateCompliance(
results: readonly ComplianceResult[],
): ComplianceResult | null {
if (results.length === 0) return null;
let taken = 0;
let skipped = 0;
let missed = 0;
let streak = Number.POSITIVE_INFINITY;
for (const r of results) {
taken += r.taken;
skipped += r.skipped;
missed += r.missed;
streak = Math.min(streak, r.streak);
}
const denominator = taken + missed;
return {
totalExpected: taken + skipped + missed,
taken,
skipped,
missed,
rate:
denominator > 0
? Math.min(100, Math.round((taken / denominator) * 100))
: 100,
streak,
};
}
+12
View File
@@ -66,3 +66,15 @@ export function scheduleWireFields<T>(
? { schedules: [], recordedSchedules: schedules }
: { schedules };
}
/**
* Error code for a dose written against a record-only medication. Every route
* that records a dose answers it the same way (iOS #116, item 15): the history
* the medication already has stays, but nothing new is counted, so a new
* write is refused by name rather than stored and then counted nowhere.
* The bulk route reports the same decision per entry as `intake_not_tracked`.
*/
export const INTAKE_NOT_TRACKED_ERROR_CODE = "medication.intake.notTracked";
/** Per-entry skip reason for the bulk route, the batch form of the code. */
export const INTAKE_NOT_TRACKED_REASON = "intake_not_tracked";
+46
View File
@@ -22,6 +22,7 @@
*/
import { apiError } from "@/lib/api-response";
import { INTAKE_NOT_TRACKED_ERROR_CODE } from "@/lib/medications/intake-tracking";
interface MedicationOwnershipPrisma {
medication: {
@@ -53,6 +54,51 @@ export async function assertMedicationOwnership(
return null;
}
/** The 422 a dose write against a record-only medication answers with. */
export function refuseUntrackedIntake(): Response {
return apiError(
"This medication is kept as a record; its intake is not tracked",
422,
{ errorCode: INTAKE_NOT_TRACKED_ERROR_CODE },
);
}
interface MedicationIntakeGuardPrisma {
medication: {
findUnique: (args: {
where: { id: string };
select: { id: true; userId: true; trackIntake: true };
}) => Promise<{ id: string; userId: string; trackIntake: boolean } | null>;
};
}
/**
* The ownership guard for a route that RECORDS a dose against the
* medication: the same 404 as {@link assertMedicationOwnership}, and then a
* 422 `medication.intake.notTracked` when the medication is kept as a record
* only (`trackIntake: false`). One read answers both, so the refusal cannot
* be reached for a medication the caller does not hold — an unknown id and a
* foreign one still look identical.
*/
export async function assertMedicationTakesIntake(
medicationId: string,
userId: string,
prismaClient?: MedicationIntakeGuardPrisma,
): Promise<Response | null> {
const client =
prismaClient ??
((await loadPrisma()) as unknown as MedicationIntakeGuardPrisma);
const med = await client.medication.findUnique({
where: { id: medicationId },
select: { id: true, userId: true, trackIntake: true },
});
if (!med || med.userId !== userId) {
return apiError("Medication not found", 404);
}
if (med.trackIntake === false) return refuseUntrackedIntake();
return null;
}
async function loadPrisma(): Promise<MedicationOwnershipPrisma> {
// Lazy import so test files that stub `@/lib/db` at the module level
// see their stub instead of the real Prisma client. Matches the
@@ -146,6 +146,43 @@ describe("dispatchNotification — client-managed APNs suppression", () => {
});
});
it("keeps a follow-up for a dose still open on APNs, because the phone sends none", async () => {
vi.mocked(prisma.user.findUnique).mockResolvedValue({
notificationPrefs: { medication: { clientManaged: true } },
} as never);
await dispatchNotification({
...MEDICATION_PAYLOAD,
metadata: {
...MEDICATION_PAYLOAD.metadata,
phase: "ORANGE",
followUp: true,
},
});
expect(sendViaApnsMock).toHaveBeenCalledTimes(1);
expect(sendViaTelegramMock).toHaveBeenCalledTimes(1);
expect(recordPushAttemptMock).not.toHaveBeenCalled();
});
it("still keeps the reminder that announces the dose off APNs", async () => {
vi.mocked(prisma.user.findUnique).mockResolvedValue({
notificationPrefs: { medication: { clientManaged: true } },
} as never);
await dispatchNotification({
...MEDICATION_PAYLOAD,
metadata: {
...MEDICATION_PAYLOAD.metadata,
phase: "YELLOW",
followUp: false,
},
});
expect(sendViaApnsMock).not.toHaveBeenCalled();
expect(sendViaTelegramMock).toHaveBeenCalledTimes(1);
});
it("honours the roaming deliveryDefault mapping", async () => {
vi.mocked(prisma.user.findUnique).mockResolvedValue({
notificationPrefs: { medication: { deliveryDefault: "client" } },
+23 -4
View File
@@ -37,6 +37,12 @@ interface ClientManagedGate {
userId: string,
metadata: Record<string, unknown> | undefined,
) => Record<string, unknown>;
/**
* Which dispatches of the event the flag covers. Absent: all of them. The
* flag says the phone delivers this reminder itself, so it covers exactly
* what the phone replaces and nothing the phone does not send.
*/
covers?: (metadata: Record<string, unknown> | undefined) => boolean;
}
function str(value: unknown): string {
@@ -62,6 +68,13 @@ export const CLIENT_MANAGED_APNS_EVENTS: Record<string, ClientManagedGate> = {
phase: str(metadata?.phase),
dose_at: str(metadata?.scheduledAt),
}),
// The iOS client reminds once, at dose time, and sends no follow-ups of
// its own (iOS #116, item 21). So the flag keeps only the reminder that
// announces the dose off APNs; the escalations for a dose that is still
// open (`followUp: true`, set by the reminder cron) are pushed as usual.
// A dispatch that does not say is treated as the announcement, the
// behaviour every reminder had before the cron started saying.
covers: (metadata) => metadata?.followUp !== true,
},
MEASUREMENT_REMINDER: {
isClientManaged: isMeasurementReminderClientManaged,
@@ -71,9 +84,15 @@ export const CLIENT_MANAGED_APNS_EVENTS: Record<string, ClientManagedGate> = {
};
/**
* Does this event type have a client-managed opt-out at all? Cheap check
* the dispatcher runs before paying for the preferences read.
* Does a client-managed opt-out apply to this dispatch at all? Cheap check
* the dispatcher runs before paying for the preferences read: the event type
* has to have the opt-out, and the opt-out has to cover this dispatch.
*/
export function hasClientManagedApnsGate(eventType: string): boolean {
return eventType in CLIENT_MANAGED_APNS_EVENTS;
export function hasClientManagedApnsGate(
eventType: string,
metadata?: Record<string, unknown>,
): boolean {
const gate = CLIENT_MANAGED_APNS_EVENTS[eventType];
if (!gate) return false;
return gate.covers ? gate.covers(metadata) : true;
}
+4 -1
View File
@@ -326,7 +326,10 @@ export async function dispatchNotification(
if (
channel.type === "APNS" &&
!delivery.managed &&
hasClientManagedApnsGate(recipientPayload.eventType) &&
hasClientManagedApnsGate(
recipientPayload.eventType,
recipientPayload.metadata,
) &&
(await resolveClientManagedApns())
) {
const gate = CLIENT_MANAGED_APNS_EVENTS[recipientPayload.eventType];
+10 -1
View File
@@ -250,7 +250,10 @@ export const ERROR_CODE_CATALOGUE: Readonly<Record<string, readonly string[]>> =
"measurement.restore.invalid",
"measurement.update.server_owned_source",
],
medication: ["medication.intake.import.invalid_format"],
medication: [
"medication.intake.import.invalid_format",
"medication.intake.notTracked",
],
medications: [
"medications.category.invalid",
"medications.category.limitReached",
@@ -308,6 +311,12 @@ export const ERROR_CODE_CATALOGUE: Readonly<Record<string, readonly string[]>> =
"onboarding.restart.rateLimited",
"onboarding.tour.invalid",
],
passkey: [
"passkey.challenge.expired",
"passkey.response.invalid",
"passkey.unknown",
"passkey.verification.failed",
],
personal_records: ["personal_records.invalid_query"],
practitioner: ["practitioner.invalid"],
profile: [
+24
View File
@@ -501,6 +501,30 @@ const accountPayload = z
.looseObject({
id: z.string(),
username: z.string(),
// Enumerated because clients cut days and convert glucose by them: the
// day key and the unit must be the server's, not the device's.
timezone: z
.string()
.describe(
"The IANA zone the server cuts this account's days in: the stored zone, or the instance default when the stored one is unusable. Resolved, never the raw column, so bucket day keys by this value.",
),
glucoseUnit: z
.enum(["mg/dL", "mmol/L"])
.nullable()
.describe(
"The account's chosen glucose display unit, as stored. `null` means the person never chose one (or the stored value is neither unit), and the server then shows glucose in mg/dL.",
),
features: z
.object({
trackIntake: z
.literal(true)
.describe(
"Medications take `trackIntake`: a medication can be kept as a record whose doses are never due, and a dose written against one is refused with `medication.intake.notTracked`.",
),
})
.describe(
"What this server understands, for a client released apart from it. Constant across accounts; a flag appears once the server supports the feature and stays `true`. Absent on servers older than v1.42.0. A client that meets a flag it does not know ignores it.",
),
accountAccess: accountAccessBlock,
moduleAccess: moduleAccessMap,
// v1.39 — enumerated because every AI surface decides on it: a client
+61
View File
@@ -275,8 +275,69 @@ const adminMeasurementMaintenanceResult = z
})
.meta({ id: "AdminMeasurementMaintenanceResult" });
const adminMeasurementMaintenanceStatus = z
.object({
available: z
.boolean()
.describe(
"False when there is no background queue to ask (a web-only deployment); nothing can be started then.",
),
purgePending: z
.boolean()
.describe(
"The compaction-tombstone purge is queued or running. A run started now finishes at once with `refused_purge_running`.",
),
run: z
.object({
state: z.enum(["queued", "running", "completed", "failed"]),
requestedAt: z.iso.datetime(),
startedAt: z.iso.datetime().nullable(),
finishedAt: z.iso.datetime().nullable(),
outcome: z
.enum(["completed", "refused_purge_running", "already_running"])
.nullable()
.describe(
"How a `completed` run ended: `completed` did the work, the two refusals finished without touching the table. Null for any other state.",
),
})
.nullable()
.describe(
"The newest run pg-boss still keeps (terminal rows live seven days), or null when there is none.",
),
sizes: z
.object({
tableBytes: z
.number()
.int()
.describe("`measurements` with its indexes and TOAST."),
indexBytes: z.number().int().describe("Its indexes alone."),
})
.nullable(),
})
.meta({ id: "AdminMeasurementMaintenanceStatus" });
export const adminDiagnosticPaths: NonNullable<ZodOpenApiObject["paths"]> = {
"/api/admin/maintenance/measurements": {
get: {
tags: ["Admin"],
summary: "Where measurement table maintenance stands",
description:
"The newest maintenance run and its state, whether the compaction-tombstone purge is still at work, and the table's size right now. The admin card polls it while a run is queued or running. Cookie auth only: `requireAdmin()` refuses every Bearer caller.",
responses: {
"200": {
description: "The status.",
content: {
"application/json": {
schema: dataEnvelope(
adminMeasurementMaintenanceStatus,
"AdminMeasurementMaintenanceStatusResponse",
),
},
},
},
...stdResponses,
},
},
post: {
tags: ["Admin"],
summary: "Queue measurement table maintenance",
+13 -8
View File
@@ -46,6 +46,7 @@ import {
stdResponses,
errorEnvelope,
loginPasswordSchema,
validationIssue,
} from "./shared";
import { passkeyLoginOptionsSchema } from "@/lib/validations/auth";
import {
@@ -637,13 +638,7 @@ const authProfileUpdateResponse = z
"Whether an insurance number is stored. The number itself is encrypted at rest and is never returned — only its presence.",
),
rejectedFields: z
.array(
z.object({
path: z.string(),
code: z.string(),
message: z.string(),
}),
)
.array(validationIssue)
.optional()
.describe(
"Present only on a PARTIAL success: the fields that were skipped while the rest of the patch was written. A 200 carrying this key means the save was incomplete — surface it, do not treat the response as a clean save. `code` is the validator code for a field that failed validation, or `rate_limited` for an email-address change that has spent the account's hourly budget; that one is not a bad value and the same address will be accepted once the window rolls over.",
@@ -1442,10 +1437,20 @@ export const authPaths: NonNullable<ZodOpenApiObject["paths"]> = {
},
"404": {
description:
"The assertion resolved to a user row that no longer exists.",
"`meta.errorCode` = `passkey.unknown` (v1.42.0): no passkey with this credential id is registered on this server — it was removed here, or belongs to another server. Tell the person to sign in another way. Without a code: the assertion resolved to a user row that no longer exists.",
content: { "application/json": { schema: errorEnvelope } },
},
...stdResponses,
"401": {
description:
"The sign-in did not prove anything (v1.42.0 codes; before, the first case answered 500). `meta.errorCode` = `passkey.challenge.expired` when the challenge is gone — it expired after five minutes, was already used, or was begun for a different account — so start a new sign-in; `passkey.verification.failed` when the assertion was checked and refused (signature, origin, relying-party id or challenge mismatch).",
content: { "application/json": { schema: errorEnvelope } },
},
"422": {
description:
"`challengeId` or `credential` is missing, or (`meta.errorCode` = `passkey.response.invalid`, v1.42.0) `credential` is not a WebAuthn authentication response.",
content: { "application/json": { schema: errorEnvelope } },
},
},
},
},
+1 -1
View File
@@ -87,7 +87,7 @@ export const ingestPaths: NonNullable<ZodOpenApiObject["paths"]> = {
},
"422": {
description:
"Validation failed, with every issue listed rather than the first — an integration operator should see the whole shape at once. An empty or unstable `idempotencyKey` fails here: the column is unique table-wide, so an empty key would resolve to whichever unrelated row stored it first.",
"Validation failed, with every issue listed rather than the first — an integration operator should see the whole shape at once. An empty or unstable `idempotencyKey` fails here: the column is unique table-wide, so an empty key would resolve to whichever unrelated row stored it first. Also 422 with `meta.errorCode` = `medication.intake.notTracked` (v1.42.0) when the named medication is kept as a record only (`trackIntake: false`); checked after the token's scope, so a token without this medication's scope learns nothing about it.",
content: { "application/json": { schema: errorEnvelope } },
},
"429": {
+1 -1
View File
@@ -1079,7 +1079,7 @@ export const measurementPaths: NonNullable<ZodOpenApiObject["paths"]> = {
...stdResponses,
"422": {
description:
"The batch exceeded the 500-entry limit (`measurement.batch.too_large`), failed validation (`measurement.batch.invalid`, with every issue under `details.issues`), or (`measurement.batch.source_not_permitted`) carried an entry naming a source, any source, under a narrow `measurements:write` credential. Nothing was written in any of the three cases, and all three are permanent for the batch as sent: resending it unchanged is refused the same way.",
'The batch exceeded the 500-entry limit (`measurement.batch.too_large`), failed validation (`measurement.batch.invalid`, with every issue under `details.issues`), or (`measurement.batch.source_not_permitted`) carried an entry naming a source, any source, under a narrow `measurements:write` credential. Nothing was written in any of the three cases, and all three are permanent for the batch as sent: resending it unchanged is refused the same way. Which issues belong to an entry: every issue caused by one entry has a `path` that starts `entries.<n>` (the entry\'s index in the request, then the field, e.g. `entries.3.startDate`, or just `entries.4` when the entry is not an object). Those are the only per-entry issues, so a client may drop the named entries and resend the rest. An issue whose `path` is `""` (the body is not an object), `entries` (missing, not an array, or empty) or `syncTrigger` is about the batch itself, and no split recovers it.',
content: { "application/json": { schema: errorEnvelope } },
},
},
+51 -8
View File
@@ -88,6 +88,7 @@ import {
medicationCadenceResponse,
medicationComplianceResponse,
medicationComplianceSummaryEntry,
medicationComplianceAggregate,
scheduleRevisionResource,
scheduleRevisionListResponse,
medicationExtractRequest,
@@ -212,7 +213,12 @@ const bulkIntakeEntryResult = z
.describe(
"`inserted`/`updated`/`duplicate` — the row landed (advance the cursor). `skipped` — not stored; see `reason`.",
),
reason: z.string().optional(),
reason: z
.string()
.optional()
.describe(
"Why a `skipped` entry was not stored. Among others: `medication_not_found`, `unstable_external_id`, `force_slot_invalid`, `force_slot_occupied`, `injection_site_not_allowed`, and (v1.42.0) `intake_not_tracked` for an entry against a medication kept as a record only (`trackIntake: false`), the per-entry form of `medication.intake.notTracked`. A skip is final: resending the entry gives the same answer.",
),
id: z.string().optional().describe("The landed row id (absent on skips)."),
})
.meta({ id: "BulkMedicationIntakeEntryResult" });
@@ -312,7 +318,7 @@ export const medicationPaths: NonNullable<ZodOpenApiObject["paths"]> = {
},
"422": {
description:
"Body validation failed (multi-issue envelope, breadcrumbed as `medications.intake.update.validation-failed`), or `meta.errorCode` = `medications.intake.injection_site.disallowed` when the site is outside the medication's effective allowed set, or `medications.intake.force_slot.invalid` when `forceSlotInstant` is not a real slot of the medication. The latter two carry no issue list — branch on the code.",
"Body validation failed (multi-issue envelope, breadcrumbed as `medications.intake.update.validation-failed`), or `meta.errorCode` = `medications.intake.injection_site.disallowed` when the site is outside the medication's effective allowed set, or `medications.intake.force_slot.invalid` when `forceSlotInstant` is not a real slot of the medication, or (v1.42.0) `medication.intake.notTracked` when the event is still open and its medication is kept as a record only (`trackIntake: false`): resolving or snoozing it would record a new dose that is counted nowhere. Correcting an event that is already taken or skipped stays open. The coded refusals carry no issue list — branch on the code.",
content: { "application/json": { schema: errorEnvelope } },
},
"401": stdResponses["401"],
@@ -1437,6 +1443,11 @@ export const medicationPaths: NonNullable<ZodOpenApiObject["paths"]> = {
},
...stdResponses,
...recordWriteRateLimitResponse,
"422": {
description:
"Body validation failed (multi-issue envelope), or `meta.errorCode` names the refusal: `medications.intake.injection_site.disallowed`, `medications.intake.force_slot.invalid`, or (v1.42.0) `medication.intake.notTracked` when the medication is kept as a record only (`trackIntake: false`). Its stored history stays; a new dose is refused rather than stored and counted nowhere. The check runs after ownership, so a foreign medication is still a 404.",
content: { "application/json": { schema: errorEnvelope } },
},
},
},
get: {
@@ -1699,17 +1710,49 @@ export const medicationPaths: NonNullable<ZodOpenApiObject["paths"]> = {
tags: ["Medications"],
summary: "Batched adherence read for every medication of the caller",
description:
"Returns one compact row per non-PRN medication. A scheduled medication with no local schedule remains in the array with applicable=false and reason NO_LOCAL_SCHEDULE. compliance7/compliance30 stay non-null as all-zero compatibility placeholders for released clients; aware clients must ignore those percentages when applicable=false. complianceDisplay is null.",
"Returns one compact row per non-PRN medication. A scheduled medication with no local schedule remains in the array with applicable=false and reason NO_LOCAL_SCHEDULE. compliance7/compliance30 stay non-null as all-zero compatibility placeholders for released clients; aware clients must ignore those percentages when applicable=false. complianceDisplay is null.\n\n" +
"v1.42.0, additive: `meta.aggregate` carries one figure for the whole account (`MedicationComplianceAggregate`, weighted by expected doses across the applicable medications; `null` when none applies), so a client never averages the rows itself. `days` (30, 60, 90, 180 or 365) adds a `complianceN` block in the same shape to every row and to the aggregate, for a report that covers its own window; `meta.days` echoes it. Any other `days` is a 422 rather than a rounded window.",
requestParams: {
query: z.object({
days: z
.enum(["30", "60", "90", "180", "365"])
.optional()
.describe(
"Report window in days. 30 is already `compliance30`; the others add `compliance60` / `compliance90` / `compliance180` / `compliance365`.",
),
}),
},
responses: {
...recordRefusal(),
"200": {
description: "One adherence row per medication.",
description:
"One adherence row per medication, and the account aggregate in `meta`.",
content: {
"application/json": {
schema: dataEnvelope(
z.array(medicationComplianceSummaryEntry),
"ListMedicationComplianceResponse",
),
schema: z
.object({
data: z.array(medicationComplianceSummaryEntry),
error: z.null(),
meta: z
.object({
aggregate: medicationComplianceAggregate.nullable(),
days: z
.union([
z.literal(30),
z.literal(60),
z.literal(90),
z.literal(180),
z.literal(365),
])
.optional()
.describe("The `days` the request asked for."),
requestId: z.string().optional(),
})
.describe(
"Absent on servers older than v1.42.0; a client that reads it treats absence as no aggregate.",
),
})
.meta({ id: "ListMedicationComplianceResponse" }),
},
},
},
@@ -936,6 +936,18 @@ export const medicationComplianceSummaryEntry = z
compliance30: complianceResult.describe(
"Thirty-day adherence summary, or an all-zero compatibility placeholder when applicable is false.",
),
compliance60: complianceResult
.optional()
.describe("Present only on `?days=60`: the trailing 60 days."),
compliance90: complianceResult
.optional()
.describe("Present only on `?days=90`: the trailing 90 days."),
compliance180: complianceResult
.optional()
.describe("Present only on `?days=180`: the trailing 180 days."),
compliance365: complianceResult
.optional()
.describe("Present only on `?days=365`: the trailing 365 days."),
complianceDisplay: complianceDisplay.nullable(),
})
.meta({
@@ -1732,3 +1744,27 @@ export const medicationSideEffect = z
description:
"One logged side effect. Not a clinical record — the account owns it, and it stays deletable at any time rather than locking after a retraction window.",
});
/**
* v1.42.0 — the account-wide adherence figure the batched read carries in
* `meta.aggregate`, beside the per-medication rows.
*/
export const medicationComplianceAggregate = z
.object({
compliance7: complianceResult,
compliance30: complianceResult,
compliance60: complianceResult.nullable().optional(),
compliance90: complianceResult.nullable().optional(),
compliance180: complianceResult.nullable().optional(),
compliance365: complianceResult.nullable().optional(),
medicationCount: z
.number()
.int()
.positive()
.describe("How many applicable medications the figure is built from."),
})
.meta({
id: "MedicationComplianceAggregate",
description:
"One adherence figure for the whole account in the `ComplianceResult` shape, weighted by expected doses: `taken`, `skipped` and `missed` are summed across every medication with `applicable: true`, and `rate` is recomputed from the sums by the per-medication rule (round(100 · taken / (taken + missed)), capped at 100, 100 when nothing was expected). Averaging the per-medication rates would let a weekly injection weigh as much as a three-times-daily tablet. `streak` is the shortest per-medication streak. The `complianceN` block for a requested `days` is present when `days` was sent and is not 30.",
});
+19 -2
View File
@@ -955,7 +955,14 @@ const moodAggregatesResponse = z
days: z.number().int(),
})
.nullable()
.describe("Null for a sparse logger below the day floor."),
.describe(
"Day-to-day steadiness over the trailing `stabilityWindowDays` days. Null below the day floor (seven days with an entry) inside that window, so a short window can be null where the year is not.",
),
stabilityWindowDays: z
.union([z.literal(30), z.literal(90), z.literal(180), z.literal(365)])
.describe(
"The window `stability` covers: the `days` query parameter, or 365 (the whole daily series) when it was not sent. Added in v1.42.0; absent from older servers, whose score always covers the year.",
),
tags: z
.array(
z.object({
@@ -1277,7 +1284,17 @@ export const moodPaths: NonNullable<ZodOpenApiObject["paths"]> = {
tags: ["Mood"],
summary: "Pre-computed mood aggregates (v1.8.5)",
description:
"The whole Mood Insights page in one read. The compute runs server-side and only pre-shaped blocks leave — no raw mood row is on this wire, and no LLM is reachable from this path. Stale-while-revalidate: past the fresh window the prior aggregate is served immediately while one background recompute warms a new one, so an active logger never re-pays the cold compute. Module-gated on `mood`; a disabled module answers 403 `module.disabled` even for a valid Bearer token. Cookie or Bearer auth; the caller is always resolved as themselves, so this read cannot be delegated to a shared record — which makes it the one mood surface a delegate cannot reach.",
"The whole Mood Insights page in one read. The compute runs server-side and only pre-shaped blocks leave — no raw mood row is on this wire, and no LLM is reachable from this path. Stale-while-revalidate: past the fresh window the prior aggregate is served immediately while one background recompute warms a new one, so an active logger never re-pays the cold compute. Module-gated on `mood`; a disabled module answers 403 `module.disabled` even for a valid Bearer token. Cookie or Bearer auth; the caller is always resolved as themselves, so this read cannot be delegated to a shared record — which makes it the one mood surface a delegate cannot reach. v1.42.0 — `days` cuts `stability` to the period a client shows; every other block is unchanged by it.",
requestParams: {
query: z.object({
days: z
.enum(["30", "90", "180", "365"])
.optional()
.describe(
"Trailing window for `stability`, in days. Omitted: 365. Any other value is a 422.",
),
}),
},
responses: {
"200": {
description: "The aggregate bundle.",
+4 -9
View File
@@ -56,6 +56,7 @@ import {
recordRefusal,
stdResponses,
updatedAtTokenField,
validationIssue,
} from "./shared";
// v1.18.0 — module enable/disable. The PATCH request is the REAL runtime
@@ -259,7 +260,7 @@ const notificationPrefsResolved = z
clientManaged: z
.boolean()
.describe(
"True when the iOS app owns local medication reminders; the server-side MEDICATION_REMINDER APNs cron is suppressed.",
"True when the iOS app delivers medication reminders locally. The server then keeps the reminder that announces a dose off APNs (the phone shows its own at dose time) and still pushes the follow-ups for a dose that stays open, which the phone does not send (v1.42.0; before, every MEDICATION_REMINDER push was suppressed). Other channels are never affected.",
),
deliveryDefault: z
.enum(["server", "client"])
@@ -587,13 +588,7 @@ const profileUpdateResponse = z
.boolean()
.describe("Whether a KVNR is on file (the value itself is not echoed)."),
rejectedFields: z
.array(
z.object({
path: z.string(),
code: z.string(),
message: z.string(),
}),
)
.array(validationIssue)
.optional()
.describe(
"Present only on a PARTIAL success: the fields that were skipped while the rest of the patch was written. A 200 carrying this key means the save was incomplete — surface it, do not treat the response as a clean save. `code` is the validator code for a field that failed validation, or `rate_limited` for an email-address change that has spent the account's hourly budget; that one is not a bad value and the same address will be accepted once the window rolls over. The handler has always been able to answer with this key on this path; it was published only on PUT /api/auth/profile.",
@@ -1638,7 +1633,7 @@ export const profilePaths: NonNullable<ZodOpenApiObject["paths"]> = {
tags: ["Notifications"],
summary: "Update per-user notification preferences",
description:
'Deep-merges the supplied partial shape over the persisted row — a PATCH touching only one category leaves the siblings intact. Always returns the fully-resolved next state so clients can hard-set their optimistic update. `medication.clientManaged: true` (or `deliveryDefault: "client"`) suppresses server-side MEDICATION_REMINDER APNs; `medication.lowStockRunwayDays` (1–60, nullable, default 7) tunes the low-stock alert — null switches it off. Rate-limit 60/min per user.',
'Deep-merges the supplied partial shape over the persisted row — a PATCH touching only one category leaves the siblings intact. Always returns the fully-resolved next state so clients can hard-set their optimistic update. `medication.clientManaged: true` (or `deliveryDefault: "client"`) keeps the MEDICATION_REMINDER that announces a dose off APNs and leaves the follow-ups for a dose still open on it (v1.42.0); `medication.lowStockRunwayDays` (1–60, nullable, default 7) tunes the low-stock alert — null switches it off. Rate-limit 60/min per user.',
requestBody: {
required: true,
content: {
+1 -1
View File
@@ -32,7 +32,7 @@ import { createBatchWorkoutSchema as createBatchWorkoutSchemaBase } from "@/lib/
* built for could not read it from the contract. `params` never ships: some
* Zod codes embed the offending value in it and that is user content.
*/
const validationIssue = z
export const validationIssue = z
.object({
path: z
.string()
+2
View File
@@ -48,6 +48,8 @@ export const adminKeys = {
adminBackupRestores: () => ["admin", "backup-restores"] as const,
/** v1.23 — encryption coverage + rotation progress (admin Encryption section). */
adminEncryptionStatus: () => ["admin", "encryption", "status"] as const,
adminMeasurementMaintenance: () =>
["admin", "maintenance", "measurements"] as const,
/** v1.40.0 — the "Back up your encryption key" step (admin + dashboard banner). */
adminEncryptionKeyBackup: () =>
["admin", "encryption", "key-backup"] as const,
@@ -1,6 +1,10 @@
import { describe, expect, it } from "vitest";
import { parseAccountAccess } from "../account-access-schema";
import {
parseAccountAccess,
validateAccountAccessBlock,
} from "../account-access-parse";
import { accountAccessBlockSchema } from "../account-access-schema";
const sharedEntry = {
accountId: "record-a",
@@ -220,3 +224,108 @@ describe("parseAccountAccess", () => {
).toBeNull();
});
});
/**
* The browser parse carries no Zod (it rides the shell every route shares),
* so it is a second statement of the published schema. This holds the two to
* one verdict: over every fixture below, and every single-field breakage of
* each, the hand-written check accepts exactly what the schema accepts and
* returns the same stripped value. Change one without the other and this
* fails with the input that tells them apart.
*/
describe("validateAccountAccessBlock agrees with the published schema", () => {
const BAD_VALUES: unknown[] = [
undefined,
null,
0,
1,
true,
"",
"bogus",
[],
["labs"],
["labs", "labs"],
["nope"],
{},
];
const managerEntry = {
...sharedEntry,
accountId: "record-m",
username: "record-m",
access: "write",
level: "manage",
recordKind: "managed",
sections: null,
canWrite: true,
writableDomains: ["measurements", "mind"],
manageableDomains: ["measurements"],
};
const writerEntry = {
...sharedEntry,
accountId: "record-w",
username: "record-w",
access: "write",
level: "write",
sections: ["labs", "measurements"],
canWrite: true,
writableDomains: ["measurements"],
};
const bases: Record<string, unknown>[] = [
accessBlock(),
{ accounts: [], active: null, recordKind: "self", canSwitch: false },
{
accounts: [managerEntry, writerEntry],
active: null,
recordKind: "self",
canSwitch: true,
},
{
accounts: [writerEntry],
active: { ...writerEntry, extra: "stripped" },
recordKind: "shared",
canSwitch: true,
},
];
function variants(): unknown[] {
const out: unknown[] = [...bases, null, "x", [], 42];
for (const base of bases) {
for (const key of Object.keys(base)) {
for (const bad of BAD_VALUES) out.push({ ...base, [key]: bad });
}
const accounts = base.accounts as Record<string, unknown>[];
accounts.forEach((entry, index) => {
for (const key of [...Object.keys(entry), "unknownKey"]) {
for (const bad of BAD_VALUES) {
const broken = { ...entry, [key]: bad };
const next = [...accounts];
next[index] = broken;
out.push({ ...base, accounts: next });
if (base.active) out.push({ ...base, active: broken });
}
}
});
}
return out;
}
it("accepts and rejects the same blocks, with the same output", () => {
const corpus = variants();
expect(corpus.length).toBeGreaterThan(500);
let accepted = 0;
for (const input of corpus) {
const zod = accountAccessBlockSchema.safeParse(input);
const mine = validateAccountAccessBlock(input);
expect(mine !== null, JSON.stringify(input)).toBe(zod.success);
if (zod.success) {
expect(mine, JSON.stringify(input)).toEqual(zod.data);
accepted += 1;
}
}
// Both arms exercised: the corpus is not all-reject or all-accept.
expect(accepted).toBeGreaterThan(10);
expect(accepted).toBeLessThan(corpus.length - 100);
});
});
+212
View File
@@ -0,0 +1,212 @@
/**
* The browser's parse of the account-access block on `GET /api/auth/me`.
*
* Plain TypeScript, no Zod, on purpose. `use-auth.ts` runs this parse on every
* app boot, so whatever it imports lands in the shell every route shares, and
* this parse was the shell's only Zod import: about 60 KB gzip on every first
* paint for one structural check. A tree-shaken `zod/mini` build measured
* almost the same under Turbopack, because the shared core comes along either
* way.
*
* The Zod schema stays the contract: `account-access-schema.ts` publishes it
* to OpenAPI, and `account-access-parse.test.ts` runs both over the same
* corpus of good and broken blocks and fails the moment they disagree on
* whether a block is accepted or on what comes out of it.
*/
import type {
AccountAccess,
AccountAccessEntry,
} from "@/lib/sharing/account-access-view";
import { SHARE_DOMAINS, type ShareDomain } from "@/lib/sharing/scope";
const DOMAINS: ReadonlySet<string> = new Set(SHARE_DOMAINS);
type Raw = Record<string, unknown>;
function isRecord(value: unknown): value is Raw {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
function isNonEmptyString(value: unknown): value is string {
return typeof value === "string" && value.length >= 1;
}
function isNullableString(value: unknown): value is string | null {
return value === null || typeof value === "string";
}
function domainList(value: unknown): ShareDomain[] | null {
if (!Array.isArray(value)) return null;
for (const domain of value) {
if (typeof domain !== "string" || !DOMAINS.has(domain)) return null;
}
return [...(value as ShareDomain[])];
}
function hasRepeat(domains: readonly string[]): boolean {
return new Set(domains).size !== domains.length;
}
function isSubset(
inner: readonly string[],
outer: readonly string[] | null,
): boolean {
if (outer === null) return true;
const set = new Set(outer);
return inner.every((domain) => set.has(domain));
}
/**
* One entry, checked field by field and copied out with only the fields the
* contract names (unknown keys are dropped, as the schema strips them), or
* null. The invariants after the field checks are the schema's refinements.
*/
function parseEntry(value: unknown): AccountAccessEntry | null {
if (!isRecord(value)) return null;
const {
accountId,
username,
displayName,
fullName,
access,
level,
recordKind,
sections: rawSections,
canWrite,
writableDomains: rawWritable,
manageableDomains: rawManageable,
} = value;
if (!isNonEmptyString(accountId) || !isNonEmptyString(username)) return null;
if (!isNullableString(displayName) || !isNullableString(fullName)) {
return null;
}
if (access !== "read" && access !== "write") return null;
if (level !== "read" && level !== "write" && level !== "manage") return null;
if (recordKind !== "shared" && recordKind !== "managed") return null;
const sections = rawSections === null ? null : domainList(rawSections);
if (rawSections !== null && sections === null) return null;
if (typeof canWrite !== "boolean") return null;
const writableDomains = domainList(rawWritable);
const manageableDomains = domainList(rawManageable);
if (writableDomains === null || manageableDomains === null) return null;
const isManage = level === "manage";
if (sections !== null && hasRepeat(sections)) return null;
if (isManage && (access !== "write" || sections !== null)) return null;
if (canWrite !== (level !== "read")) return null;
if (!isManage && access !== level) return null;
if (hasRepeat(writableDomains) || hasRepeat(manageableDomains)) return null;
if (
!isSubset(writableDomains, sections) ||
!isSubset(manageableDomains, sections)
) {
return null;
}
if (!isSubset(manageableDomains, writableDomains)) return null;
if (level === "read" && writableDomains.length > 0) return null;
if (!isManage && manageableDomains.length > 0) return null;
return {
accountId,
username,
displayName,
fullName,
access,
level,
recordKind,
sections,
canWrite,
writableDomains,
manageableDomains,
};
}
/**
* The block's structure, without the cross-entry checks: what the schema
* accepts, and the same stripped value it returns. Exported for the
* equivalence test; the app calls {@link parseAccountAccess}.
*/
export function validateAccountAccessBlock(
value: unknown,
): AccountAccess | null {
if (!isRecord(value)) return null;
const {
accounts: rawAccounts,
active: rawActive,
recordKind,
canSwitch,
} = value;
if (!Array.isArray(rawAccounts)) return null;
const accounts: AccountAccessEntry[] = [];
for (const raw of rawAccounts) {
const entry = parseEntry(raw);
if (!entry) return null;
accounts.push(entry);
}
const active = rawActive === null ? null : parseEntry(rawActive);
if (rawActive !== null && active === null) return null;
if (
recordKind !== "self" &&
recordKind !== "shared" &&
recordKind !== "managed"
) {
return null;
}
if (typeof canSwitch !== "boolean") return null;
return { accounts, active, recordKind, canSwitch };
}
/** Both published views of the active record must name the same resolved grant. */
function sameEntry(a: AccountAccessEntry, b: AccountAccessEntry): boolean {
const sameList = (x: readonly string[], y: readonly string[]) =>
x.length === y.length && x.every((domain, index) => domain === y[index]);
const sameSections =
a.sections === null || b.sections === null
? a.sections === b.sections
: sameList(a.sections, b.sections);
return (
sameList(a.writableDomains, b.writableDomains) &&
sameList(a.manageableDomains, b.manageableDomains) &&
a.accountId === b.accountId &&
a.username === b.username &&
a.displayName === b.displayName &&
a.fullName === b.fullName &&
a.access === b.access &&
a.level === b.level &&
a.recordKind === b.recordKind &&
a.canWrite === b.canWrite &&
sameSections
);
}
/** Parse the server-resolved access block as a closed presentation contract. */
export function parseAccountAccess(value: unknown): AccountAccess | null {
const block = validateAccountAccessBlock(value);
if (!block) return null;
const { accounts, active, recordKind, canSwitch } = block;
const accountIds = new Set(accounts.map((entry) => entry.accountId));
if (
accountIds.size !== accounts.length ||
canSwitch !== accounts.length > 0
) {
return null;
}
if (active === null) {
return recordKind === "self"
? { accounts, active: null, recordKind, canSwitch }
: null;
}
if (!accountIds.has(active.accountId) || recordKind !== active.recordKind) {
return null;
}
const canonicalActive = accounts.find(
(entry) => entry.accountId === active.accountId,
);
if (!canonicalActive || !sameEntry(active, canonicalActive)) return null;
return { accounts, active: canonicalActive, recordKind, canSwitch };
}
+7 -72
View File
@@ -1,6 +1,11 @@
/**
* The account-access block's contract as a Zod schema, for the OpenAPI
* document. The browser does not import it: its parse is the Zod-free
* `account-access-parse.ts`, kept out of the shell every route shares, and
* `account-access-parse.test.ts` holds the two to the same verdicts.
*/
import { z } from "zod/v4";
import type { AccountAccess } from "./account-access-view";
import { SHARE_DOMAINS } from "./scope";
const accountAccessLevelSchema = z.enum(["read", "write", "manage"]);
@@ -21,7 +26,7 @@ function isSubset(
return inner.every((domain) => set.has(domain));
}
/** The browser's resolved account-access payload, shared with OpenAPI. */
/** One account-access entry, as OpenAPI publishes it. */
export const accountAccessEntrySchema = z
.object({
accountId: z.string().min(1),
@@ -125,73 +130,3 @@ export const accountAccessBlockSchema = z.object({
recordKind: z.enum(["self", "shared", "managed"]),
canSwitch: z.boolean(),
});
/** Both published views of the active record must name the same resolved grant. */
function matchesCanonicalAccountAccessEntry(
active: z.infer<typeof accountAccessEntrySchema>,
canonical: z.infer<typeof accountAccessEntrySchema>,
): boolean {
const activeSections = active.sections;
const canonicalSections = canonical.sections;
const sameSections =
activeSections === null || canonicalSections === null
? activeSections === canonicalSections
: activeSections.length === canonicalSections.length &&
activeSections.every(
(section, index) => section === canonicalSections[index],
);
const sameList = (a: readonly string[], b: readonly string[]) =>
a.length === b.length && a.every((domain, index) => domain === b[index]);
return (
sameList(active.writableDomains, canonical.writableDomains) &&
sameList(active.manageableDomains, canonical.manageableDomains) &&
active.accountId === canonical.accountId &&
active.username === canonical.username &&
active.displayName === canonical.displayName &&
active.fullName === canonical.fullName &&
active.access === canonical.access &&
active.level === canonical.level &&
active.recordKind === canonical.recordKind &&
active.canWrite === canonical.canWrite &&
sameSections
);
}
/** Parse the server-resolved access block as a closed presentation contract. */
export function parseAccountAccess(value: unknown): AccountAccess | null {
const parsed = accountAccessBlockSchema.safeParse(value);
if (!parsed.success) return null;
const { accounts, active, recordKind, canSwitch } = parsed.data;
const accountIds = new Set(accounts.map((entry) => entry.accountId));
if (
accountIds.size !== accounts.length ||
canSwitch !== accounts.length > 0
) {
return null;
}
if (active === null) {
return recordKind === "self"
? { accounts, active: null, recordKind, canSwitch }
: null;
}
if (!accountIds.has(active.accountId) || recordKind !== active.recordKind) {
return null;
}
const canonicalActive = accounts.find(
(entry) => entry.accountId === active.accountId,
);
if (
!canonicalActive ||
!matchesCanonicalAccountAccessEntry(active, canonicalActive)
) {
return null;
}
return { accounts, active: canonicalActive, recordKind, canSwitch };
}
+3 -152
View File
@@ -298,158 +298,9 @@ export const USER_CORRECTABLE_MEASUREMENT_SOURCES = [
EXTERNAL_SOURCE,
] as const;
const unitMap: Record<string, string> = {
WEIGHT: "kg",
BLOOD_PRESSURE_SYS: "mmHg",
BLOOD_PRESSURE_DIA: "mmHg",
PULSE: "bpm",
BODY_FAT: "%",
// v1.4.23 — sleep duration shifted from hours to minutes so HealthKit
// category-sample stages can be stored without precision loss. Older
// surfaces that need hours convert at read time (`minutes / 60`).
SLEEP_DURATION: "minutes",
ACTIVITY_STEPS: "steps",
BLOOD_GLUCOSE: "mg/dL",
TOTAL_BODY_WATER: "kg",
BONE_MASS: "kg",
OXYGEN_SATURATION: "%",
// ── v1.4.23 Apple Health canonical units ──
HEART_RATE_VARIABILITY: "ms",
RESTING_HEART_RATE: "bpm",
ACTIVE_ENERGY_BURNED: "kcal",
FLIGHTS_CLIMBED: "flights",
WALKING_RUNNING_DISTANCE: "m",
VO2_MAX: "mL/(kg·min)",
BODY_TEMPERATURE: "celsius",
// ── v1.4.25 W5d Withings full coverage ──
FAT_FREE_MASS: "kg",
FAT_MASS: "kg",
MUSCLE_MASS: "kg",
// Distinct from BODY_TEMPERATURE — surface temps run ~32 °C; sharing
// the bucket would corrupt analytics. Same canonical unit (°C).
SKIN_TEMPERATURE: "celsius",
PULSE_WAVE_VELOCITY: "m/s",
VASCULAR_AGE: "years",
// Withings reports visceral fat as a 1–12 rating, not a percent. The
// string mirrors what Withings prints in Health Mate.
VISCERAL_FAT: "rating",
// ── v1.4.25 W8d Apple Health server-prep ──
// Sound-pressure level — A-weighted decibels (dBA). HealthKit reports
// both audio-exposure metrics in dBASPL; we store the unweighted "dBA"
// label because the A-weighting is implicit (every HealthKit audio
// sample carries it). 30 dBA = quiet bedroom; 140 dBA = pain threshold.
AUDIO_EXPOSURE_ENV: "dBA",
AUDIO_EXPOSURE_HEADPHONE: "dBA",
// Daily-rollup pattern (one sample = one day's outdoor-light minutes).
// 0–1440 covers the 24-hour day; in practice indoor users sit near 0
// and outdoor athletes accumulate a few hours.
TIME_IN_DAYLIGHT: "minutes",
// ── v1.5.5 iOS-coord additions ──
// Respiratory rate breaths-per-minute — the HK identifier ships as
// `count/min`; we keep the more conventional clinical label.
RESPIRATORY_RATE: "breaths/min",
// BMI kg/m² — HealthKit ships the unitless ratio; the canonical
// display string mirrors clinical convention.
BODY_MASS_INDEX: "kg/m²",
// Lean body mass kg — body-composition partner to FAT_MASS.
LEAN_BODY_MASS: "kg",
// Walking heart rate average bpm — daily rollup; distinct from
// RESTING_HEART_RATE (sleep-window minimum) and spot PULSE.
WALKING_HEART_RATE_AVERAGE: "bpm",
// Walking gait percent (0-100 after server-side ×100 scaling).
// Same convention as WALKING_STEADINESS / BODY_FAT / OXYGEN_SATURATION
// — see the project convention block in `apple-health-mapping.ts`.
WALKING_ASYMMETRY: "%",
WALKING_DOUBLE_SUPPORT: "%",
// ── v1.5.5 iOS-coord follow-up — raw-SI gait pair ──
// Step length is metres; speed is metres per second. Both flow
// raw on the wire — no server-side scaling. The unit strings
// match HealthKit's `m` / `m/s` defaults.
WALKING_STEP_LENGTH: "m",
WALKING_SPEED: "m/s",
// ── v1.10.0 — additive HealthKit signals (WX-A) ──
// Cardio recovery is the bpm drop one minute after peak exercise.
CARDIO_RECOVERY: "bpm",
// Overnight wrist temperature in °C (absolute reading; Apple's own
// display frames it as a baseline deviation, we store the reading).
WRIST_TEMPERATURE: "celsius",
// Hard-fall detections — a plain count.
FALL_COUNT: "count",
// Apple's estimated six-minute-walk-test distance in metres.
SIX_MINUTE_WALK_DISTANCE: "m",
// Stair gait speeds — raw metres-per-second (no scaling).
STAIR_ASCENT_SPEED: "m/s",
STAIR_DESCENT_SPEED: "m/s",
// Per-night breathing-disturbance index — a unitless count Apple
// classifies as NotElevated / Elevated.
BREATHING_DISTURBANCES: "count",
// ── v1.10.0 — categorical events (WX-B) ──
// EVENT rows are dimensionless occurrences (value is always 1). The
// canonical unit is the bare "event" so any accidental numeric surfacing
// reads sensibly; the awareness timeline never displays the value.
IRREGULAR_RHYTHM_NOTIFICATION: "event",
HIGH_HEART_RATE_EVENT: "event",
LOW_HEART_RATE_EVENT: "event",
WALKING_STEADINESS_EVENT: "event",
BREATHING_DISTURBANCE_EVENT: "event",
// ── v1.10.0 — computed scores (WX-C) ──
// Server-derived 0–100 wellness scores. The canonical unit is the bare
// "score" so the value reads sensibly anywhere it surfaces.
RECOVERY_SCORE: "score",
STRESS_SCORE: "score",
STRAIN_SCORE: "score",
// ── v1.11.0 — WHOOP-native score classes ──
// RMSSD HRV is in milliseconds, same canonical unit as the SDNN
// HEART_RATE_VARIABILITY (different estimator, same dimension).
HRV_RMSSD: "ms",
// Day / workout strain ride WHOOP's bounded 0–21 scale; the bare "score"
// unit reads sensibly wherever the value surfaces (distinct from the
// 0–100 COMPUTED STRAIN_SCORE).
DAY_STRAIN: "score",
WORKOUT_STRAIN: "score",
// Sleep quality percentages (0–100).
SLEEP_PERFORMANCE: "%",
SLEEP_EFFICIENCY: "%",
SLEEP_CONSISTENCY: "%",
// Recommended sleep duration in minutes (WHOOP reports ms; mapper ÷60000).
SLEEP_NEED: "minutes",
// Day energy expenditure in kilojoules (WHOOP-native; kept in kJ so the
// device value round-trips rather than being converted to kcal).
ENERGY_EXPENDITURE_KJ: "kJ",
// ── v1.12.8 — WHOOP cycle + sleep coverage completion ──
// Daily average / max heart rate bpm — whole-cycle aggregates, distinct
// from the spot PULSE / RESTING_HEART_RATE / WALKING_HEART_RATE_AVERAGE.
AVERAGE_HEART_RATE: "bpm",
MAX_HEART_RATE: "bpm",
// Per-night sleep disturbance tally — a plain integer count.
SLEEP_DISTURBANCE_COUNT: "count",
// ── v1.17.1 — Polar Nightly Recharge + Training Load Pro components ──
ANS_CHARGE: "score",
CARDIO_LOAD: "score",
// ── v1.17.1 — Oura coverage completion ──
// Oura's headline 0–100 Sleep Score — bare "score" like the other 0–100 scores.
SLEEP_SCORE: "score",
// Signed body-temperature deviation in °C (Oura nightly baseline offset).
BODY_TEMPERATURE_DEVIATION: "celsius",
// ── v1.19.0 — Oura resilience ──
// Ordinal level scale (1=limited … 5=exceptional) — the categorical band
// encoded into the numeric value. See RESILIENCE_LEVELS in src/lib/oura/client.
RESILIENCE: "level",
// ── v1.25 — clinical-signals wave ──
PHQ9_SCORE: "score",
GAD7_SCORE: "score",
// ── v1.27.9 — screening scores ──
WHO5_SCORE: "score",
SCI_SCORE: "score",
GRIP_STRENGTH: "kg",
PAIN_NRS: "score",
WAIST_CIRCUMFERENCE: "cm",
WAIST_TO_HEIGHT: "ratio",
};
export function getUnitForType(type: string): string {
return unitMap[type] ?? "unknown";
}
// The canonical unit per type lives in a Zod-free module so the client's
// display transform can read it without pulling Zod into every chart route.
export { getUnitForType } from "@/lib/measurements/unit-map";
// Plausible ranges per measurement type
export const VALUE_RANGES: Record<string, { min: number; max: number }> = {