Files
HealthLog/src/components/documents/document-record-links.tsx
T
Marc-André Bombeck 73c4dda224 fix(visits): reach every lab result, condition, document and visit from the link pickers
The visit form's lab picker offered the newest 200 results, the condition
picker the newest 100 conditions, the document pickers the newest thousand
documents and the document sheet's visit picker the newest 100 visits.
On a long record everything older could not be linked.

Each picker now opens on the records around the date of the thing being
linked, pages older and newer from there, and searches through the list
route itself. Records already linked always show, from the labels the
record's own read carries and from what was picked in the sheet.

The lab list takes a q filter over analyte and panel, the condition list
from/to/q/offset/sortDir, and the visit list an offset.
2026-10-15 11:24:40 +02:00

337 lines
12 KiB
TypeScript

"use client";
/**
* "What is this page filed against?" — the document side of the visit and
* vaccination links, on the vault's detail sheet.
*
* Both links already existed as tables, but only one end could write them:
* a visit's form picked its documents, a dose's form picked its pages, and
* the document itself could show its visits read-only and its doses not at
* all. A childhood record covering a dozen doses had to be attached dose by
* dose, from twelve forms. Here the page lists what it is filed against and,
* for someone who may manage the vault, links and unlinks it in one place.
* Both ends write the SAME table through the link service, so the dose's
* form and this sheet cannot disagree about what is filed where.
*
* Every name and date comes from the server: the visit kind as its enum
* constant for the reader's bundle, the dose as its catalogue slug or the
* person's own wording. The pick lists come from the visit and vaccination
* list routes, with the records dated near the document on top under the
* same seven-day window the upload suggestion uses.
*
* A module that is off leaves no block behind, and a grant that does not
* reach the doses (`vaccinationLinks: null`) shows no dose block rather than
* an empty one that would claim the page records none.
*/
import { useMemo, useState } from "react";
import Link from "next/link";
import { CalendarDays, Syringe } from "lucide-react";
import {
EntityLinkPicker,
serverPagingFrom,
} from "@/components/links/entity-link-picker";
import type { EntityLinkOption } from "@/components/links/entity-link-picker";
import { isNearAnchor } from "@/components/links/vault-document-options";
import { encounterPickerUrl } from "@/components/links/picker-requests";
import {
PICKER_PAGE_SIZE,
pickerPivot,
useLinkPickerPages,
type PickerPage,
type PickerPageRequest,
} from "@/components/links/use-link-picker-pages";
import { encounterKindText } from "@/components/encounters/encounter-labels";
import { useVaccinations } from "@/components/vaccinations/use-vaccinations";
import { useAuth } from "@/hooks/use-auth";
import { apiGet } from "@/lib/api/api-fetch";
import { useFormatters, useTranslations } from "@/lib/i18n/context";
import { queryKeys } from "@/lib/query-keys";
import type { EncounterDTO, EncounterListDTO } from "@/lib/encounters/dto";
import type { EncounterKind } from "@/generated/prisma/client";
import type { InboundDocumentDetailDto } from "@/lib/validations/inbound-documents";
type Translate = ReturnType<typeof useTranslations>["t"];
/** Records near the document first, then the rest by year, newest first. */
export function recordOptions(
records: ReadonlyArray<{
id: string;
label: string;
meta?: string | null;
occurredAt: string;
href?: string | null;
}>,
anchor: string | null,
labels: { suggested: string; date: (iso: string) => string },
): EntityLinkOption[] {
const near: EntityLinkOption[] = [];
const rest: EntityLinkOption[] = [];
for (const record of records) {
const option = {
id: record.id,
label: record.label,
meta: record.meta ?? null,
dateLabel: labels.date(record.occurredAt),
href: record.href ?? null,
};
if (isNearAnchor(record.occurredAt, anchor)) {
near.push({
...option,
group: { key: "suggested", label: labels.suggested },
});
} else {
const year = record.occurredAt.slice(0, 4);
rest.push({ ...option, group: { key: year, label: year } });
}
}
return [...near, ...rest];
}
/**
* One picker page of visits. The route answers in two arms, each paged by the
* same offset; another page exists while either arm came back full.
*/
export async function fetchEncounterPage(
request: PickerPageRequest,
): Promise<PickerPage<EncounterDTO>> {
const list = await apiGet<EncounterListDTO>(encounterPickerUrl(request));
const full =
list.upcoming.length >= PICKER_PAGE_SIZE ||
list.past.length >= PICKER_PAGE_SIZE;
return {
items: [...list.upcoming, ...list.past],
next: full
? String(Number(request.cursor ?? "0") + PICKER_PAGE_SIZE)
: null,
};
}
/** Where a visit opens: its sheet on the checkups page. */
function visitHref(encounterId: string): string {
return `/checkups?visit=${encodeURIComponent(encounterId)}`;
}
/** Where a dose opens: its sheet on the vaccinations page. */
function doseHref(vaccinationId: string): string {
return `/vaccinations?dose=${encodeURIComponent(vaccinationId)}`;
}
/** A dose named the way the vaccination page names it. */
function doseName(
t: Translate,
catalogSlug: string | null,
vaccineName: string | null,
): string {
if (catalogSlug) return t(`vaccinations.catalog.${catalogSlug}`);
return vaccineName ?? t("vaccinations.suggestion.unnamed");
}
/**
* The caller mounts this keyed on the document and on its write-failure
* count, so the local selection below starts over from the server's answer
* whenever the sheet moves to another document or a write fails.
*/
export function DocumentRecordLinks({
doc,
canManage,
seedFresh,
seedError = false,
onRetrySeed,
onChange,
}: {
doc: InboundDocumentDetailDto;
canManage: boolean;
/**
* Whether `doc` was read from the server since the sheet opened. Every
* change is a replace-set write seeded from `doc`'s links, so a seed from a
* cached copy that predates a link made on the dose's or the visit's own
* form would delete that link on the first tap. The pickers wait for a
* fresh read instead.
*/
seedFresh: boolean;
/** That fresh read failed; the pickers show the retry row instead. */
seedError?: boolean;
onRetrySeed?: () => void;
onChange: (part: {
encounterIds?: string[];
vaccinationIds?: string[];
}) => void;
}) {
const { t } = useTranslations();
const format = useFormatters();
const { user } = useAuth();
const vaccinationsOn = user?.modules?.vaccinations !== false;
const anchor = doc.documentDate ?? doc.reportDate;
// The visits around the document's date, paged older and newer from
// there. The visit route has no text search (its free text is ciphertext
// at rest), so the term filters what is loaded.
const encounters = useLinkPickerPages<EncounterDTO>({
enabled: canManage,
pivot: pickerPivot(anchor),
queryKey: queryKeys.encounterPicker,
fetchPage: fetchEncounterPage,
serverSearch: false,
});
const vaccinations = useVaccinations(
null,
canManage && vaccinationsOn && doc.vaccinationLinks !== null,
);
// The selection the person is editing, ahead of the server. Each change is
// sent as the whole set (a replace-set PATCH), so a quick second tap never
// computes from a list the first tap has not refreshed yet.
const [visitIds, setVisitIds] = useState<string[] | null>(null);
const [doseIds, setDoseIds] = useState<string[] | null>(null);
const labels = {
suggested: t("links.picker.suggested"),
date: (iso: string) => format.date(iso),
};
const visitOptions = recordOptions(
[...encounters.items]
// Two arms per page arrive in two orders; the list reads newest first.
.sort((a, b) => b.occurredAt.localeCompare(a.occurredAt))
.map((visit) => ({
id: visit.id,
label: encounterKindText(t, visit.kind as EncounterKind),
meta: visit.practitioner?.name ?? null,
occurredAt: visit.occurredAt,
href: visitHref(visit.id),
})),
anchor,
labels,
);
const doseOptions = recordOptions(
(vaccinations.data?.vaccinations ?? []).map((dose) => ({
id: dose.id,
label: doseName(t, dose.catalogEntry?.slug ?? null, dose.vaccineName),
occurredAt: dose.occurredAt,
href: doseHref(dose.id),
})),
anchor,
labels,
);
const showDoses = vaccinationsOn && doc.vaccinationLinks !== null;
// The visits the document is filed against, as its own read names them,
// so their chips show whatever page of visits is loaded.
const knownVisits = useMemo(
() =>
doc.encounterLinks.map((link) => ({
id: link.encounterId,
label: encounterKindText(t, link.kind as EncounterKind),
dateLabel: link.occurredAt ? format.date(link.occurredAt) : null,
href: visitHref(link.encounterId),
})),
[doc.encounterLinks, t, format],
);
return (
<>
{canManage ? (
<EntityLinkPicker
icon={CalendarDays}
title={t("documents.detail.visitsLabel")}
slot="document-visit-links"
pending={encounters.pending || !seedFresh}
error={encounters.error || seedError}
errorLabel={t("links.picker.loadError")}
onRetry={() => {
if (encounters.error) encounters.retry();
if (seedError) onRetrySeed?.();
}}
selected={visitIds ?? doc.encounterLinks.map((l) => l.encounterId)}
onChange={(ids) => {
setVisitIds(ids);
onChange({ encounterIds: ids });
}}
options={visitOptions}
server={serverPagingFrom(encounters)}
knownOptions={knownVisits}
searchPlaceholder={t("links.picker.searchPlaceholder")}
emptyLabel={t("documents.detail.noVisitsToLink")}
/>
) : doc.encounterLinks.length > 0 ? (
<div className="space-y-1.5" data-slot="document-visit-links">
<p className="text-sm leading-none font-medium">
{t("documents.detail.visitsLabel")}
</p>
<div className="flex flex-wrap items-center gap-1.5">
{doc.encounterLinks.map((link) => (
<Link
key={link.encounterId}
href={visitHref(link.encounterId)}
className="bg-muted text-foreground hover:bg-muted/70 focus-visible:ring-ring/50 inline-flex max-w-64 items-center gap-1.5 rounded-full px-2.5 py-1 text-xs focus-visible:ring-[3px] focus-visible:outline-none"
>
<span className="truncate">
{encounterKindText(t, link.kind as EncounterKind)}
</span>
{link.occurredAt ? (
<span className="text-muted-foreground shrink-0">
{format.date(link.occurredAt)}
</span>
) : null}
</Link>
))}
</div>
</div>
) : null}
{showDoses && canManage ? (
<EntityLinkPicker
icon={Syringe}
title={t("documents.detail.vaccinationsLabel")}
slot="document-vaccination-links"
pending={vaccinations.isPending || !seedFresh}
error={vaccinations.isError || seedError}
errorLabel={t("links.picker.loadError")}
onRetry={() => {
if (vaccinations.isError) void vaccinations.refetch();
if (seedError) onRetrySeed?.();
}}
selected={
doseIds ??
(doc.vaccinationLinks ?? []).map((link) => link.vaccinationId)
}
onChange={(ids) => {
setDoseIds(ids);
onChange({ vaccinationIds: ids });
}}
options={doseOptions}
searchPlaceholder={t("links.picker.searchPlaceholder")}
emptyLabel={t("documents.detail.noVaccinationsToLink")}
/>
) : showDoses && (doc.vaccinationLinks?.length ?? 0) > 0 ? (
<div className="space-y-1.5" data-slot="document-vaccination-links">
<p className="text-sm leading-none font-medium">
{t("documents.detail.vaccinationsLabel")}
</p>
<div className="flex flex-wrap items-center gap-1.5">
{(doc.vaccinationLinks ?? []).map((link) => (
<Link
key={link.vaccinationId}
href={doseHref(link.vaccinationId)}
data-slot="document-vaccination-link"
className="bg-muted text-foreground hover:bg-muted/70 focus-visible:ring-ring/50 inline-flex max-w-64 items-center gap-1.5 rounded-full px-2.5 py-1 text-xs focus-visible:ring-[3px] focus-visible:outline-none"
>
<span className="truncate">
{doseName(t, link.catalogSlug, link.vaccineName)}
</span>
{link.occurredAt ? (
<span className="text-muted-foreground shrink-0">
{format.date(link.occurredAt)}
</span>
) : null}
</Link>
))}
</div>
</div>
) : null}
</>
);
}