feat: serve the day, its index, the timeline and life events

Replace the day, timeline and life-event stubs with their implementations
(#613) and drop the not-implemented helper, its error code and its OpenAPI
response with the last stub.

loadDay reads one local day for every reader: the readings live inside the
record's own day window (never the UTC rollups), through the canonical-source
engine the mood sheet already uses (resolveDayReadings in linked-context.ts),
with the person's usual range over the 30 days before; the record sections
from their own tables, each in the storage form it speaks (an instant in the
local window, a date string with its own zone, a calendar date). A switched-off
module's section is not read; a section the grant does not cover is named
not_shared and not read.

The day, the day index and the new visit preparation (GET /api/day/notable)
are admitted on the readings and narrowed per section through
actingDomainVisibility, so a scoped grant sees exactly its sections. The
timeline and its readiness stay whole-record reads and narrow their lanes the
same way.

Notable days are deterministic keys: a three-month high or low with history
behind it, a first reading, and in the visit preparation a regular reading
that stopped. The timeline lays out spans and points from the owning tables,
standing items without a date, and series by zoom: months from the rollup
tier inside its five-year window and from one cached live query before it.
The readiness inventory rates each lane with one link per gap.

Life events are created, edited and soft-deleted as MANAGE verbs with audit
rows, encrypted at rest, and join the sharing guard and the handler matrix.
get_day reads a day for the Coach and the MCP endpoint without life events,
notes or document names; its step carries the date it read.
This commit is contained in:
Marc-André Bombeck committed 2026-10-08 14:31:13 +02:00
1 parent b8f6372963
commit 0924285cd6
65 files changed
+7642 -209

No files matched your search

+48 -11
View File
@@ -2,21 +2,58 @@
* `GET /api/day/{date}` — one local day across the record (v1.42, #613): what
* ran through it, the readings in its window, what happened on it, and the
* few deterministic observations worth a second look. The shape is
* `DayResponse` in `src/lib/day/contract.ts`.
* `DayResponse` in `src/lib/day/contract.ts`; `loadDay` builds it.
*
* Core, not a module: the day opens for every account. Sections of a
* switched-off module are left out; a section the caller's grant does not
* cover is named in `sections` and not read.
* switched-off module are left out.
*
* Contract stub: answers 501 behind its admission. It declares the whole
* record for now, the posture every cross-section read in the tree has; a
* scoped grant is refused until the loader narrows each section to the
* grant's domains and the admission is reviewed for that.
* Admission: a read of the record's readings (`measurements`), narrowed
* section by section after that. The day is built around the readings, so a
* grant has to open them before it opens the day; every other section is then
* read only when the grant also covers that section's own domain
* (`actingDomainVisibility`, the same predicate the body-site and visit routes
* narrow with), and a section it does not cover is named in `sections` with
* `not_shared` and never read. No section can show a delegate more than the
* section's own route would: the domain each one maps to is the one those
* routes declare (`src/lib/day/sections.ts`).
*/
import { apiHandler, requireRecordAuth } from "@/lib/api-handler";
import { notImplemented } from "@/lib/http/not-implemented";
import { apiSuccess, returnAllZodIssues } from "@/lib/api-response";
import { loadDay } from "@/lib/day/load-day";
import { resolveDayAccess } from "@/lib/day/sections";
import { dayPathSchema } from "@/lib/day/wire-schemas";
import { prisma } from "@/lib/db";
import { annotate } from "@/lib/logging/context";
import { actingDomainVisibility } from "@/lib/sharing/acting-domains";
export const GET = apiHandler(async () => {
await requireRecordAuth("read", "record");
return notImplemented();
type RouteParams = { params: Promise<{ date: string }> };
export const GET = apiHandler(async (_request: Request, ctx: RouteParams) => {
const { user, grantId } = await requireRecordAuth("read", "measurements");
const parsed = dayPathSchema.safeParse(await ctx.params);
if (!parsed.success) {
return returnAllZodIssues(parsed.error, 422, { errorCode: "day.invalid" });
}
const access = await resolveDayAccess({
recordId: user.id,
domainVisible: await actingDomainVisibility(prisma, grantId),
owner: grantId === null,
});
const day = await loadDay({
recordId: user.id,
day: parsed.data.date,
access,
});
annotate({
action: { name: "day.read" },
meta: {
values: day.counts.values,
entries: day.counts.entries,
running: day.running.length,
notable: day.notable.length,
not_shared: Object.keys(day.sections).length,
delegated: grantId !== null,
},
});
return apiSuccess(day);
});
+46 -5
View File
@@ -5,12 +5,53 @@
* `DAY_INDEX_MAX_SPAN_DAYS` days per call. The shape is `DayIndexResponse` in
* `src/lib/day/contract.ts`.
*
* Contract stub: answers 501 behind the same admission as the day itself.
* Same admission and the same section narrowing as the day itself: a grant
* that does not cover a section never sees that section's days.
*/
import { apiHandler, requireRecordAuth } from "@/lib/api-handler";
import { notImplemented } from "@/lib/http/not-implemented";
import { apiSuccess, returnAllZodIssues } from "@/lib/api-response";
import { loadDayIndex } from "@/lib/day/day-index";
import { resolveDayAccess } from "@/lib/day/sections";
import { dayIndexQuerySchema } from "@/lib/day/wire-schemas";
import { prisma } from "@/lib/db";
import { annotate } from "@/lib/logging/context";
import { actingDomainVisibility } from "@/lib/sharing/acting-domains";
import { resolveUserTimezone } from "@/lib/tz/resolver";
export const GET = apiHandler(async () => {
await requireRecordAuth("read", "record");
return notImplemented();
export const GET = apiHandler(async (request: Request) => {
const { user, grantId } = await requireRecordAuth("read", "measurements");
const params = new URL(request.url).searchParams;
const parsed = dayIndexQuerySchema.safeParse({
from: params.get("from") ?? undefined,
to: params.get("to") ?? undefined,
});
if (!parsed.success) {
return returnAllZodIssues(parsed.error, 422, { errorCode: "day.invalid" });
}
const [access, tz] = await Promise.all([
actingDomainVisibility(prisma, grantId).then((domainVisible) =>
resolveDayAccess({
recordId: user.id,
domainVisible,
owner: grantId === null,
}),
),
resolveUserTimezone(user.id),
]);
const index = await loadDayIndex({
recordId: user.id,
from: parsed.data.from,
to: parsed.data.to,
access,
tz,
});
annotate({
action: { name: "day.index.read" },
meta: {
days: Object.keys(index.days).length,
notable: index.notable.length,
delegated: grantId !== null,
},
});
return apiSuccess(index);
});
+60
View File
@@ -0,0 +1,60 @@
/**
* `GET /api/day/notable?from=&to=` — what changed and what stood out in a
* window, for the preparation of the next visit (v1.42, #613). Without
* `from` the window starts at the last completed visit the caller may see;
* without `to` it ends today. The shape is `DayNotableWindowResponse` in
* `src/lib/day/contract.ts`.
*
* Observations and changes only, as keys and the record's own names: no
* value judgement, no cause. Same admission and section narrowing as the day.
*/
import { apiHandler, requireRecordAuth } from "@/lib/api-handler";
import { apiSuccess, returnAllZodIssues } from "@/lib/api-response";
import { resolveDayAccess } from "@/lib/day/sections";
import { loadSinceLastVisit } from "@/lib/day/visit-preparation";
import { dayNotableQuerySchema } from "@/lib/day/wire-schemas";
import { prisma } from "@/lib/db";
import { annotate } from "@/lib/logging/context";
import { actingDomainVisibility } from "@/lib/sharing/acting-domains";
import { userDayKey } from "@/lib/tz/format";
import { resolveUserTimezone } from "@/lib/tz/resolver";
export const GET = apiHandler(async (request: Request) => {
const { user, grantId } = await requireRecordAuth("read", "measurements");
const params = new URL(request.url).searchParams;
const parsed = dayNotableQuerySchema.safeParse({
from: params.get("from") ?? undefined,
to: params.get("to") ?? undefined,
});
if (!parsed.success) {
return returnAllZodIssues(parsed.error, 422, { errorCode: "day.invalid" });
}
const [access, tz] = await Promise.all([
actingDomainVisibility(prisma, grantId).then((domainVisible) =>
resolveDayAccess({
recordId: user.id,
domainVisible,
owner: grantId === null,
}),
),
resolveUserTimezone(user.id),
]);
const window = await loadSinceLastVisit({
recordId: user.id,
access,
tz,
today: userDayKey(new Date(), tz),
from: parsed.data.from,
to: parsed.data.to,
});
annotate({
action: { name: "day.notable.read" },
meta: {
anchor: window.anchor,
observations: window.observations.length,
changes: window.changes.length,
delegated: grantId !== null,
},
});
return apiSuccess(window);
});