mirror of
https://github.com/MBombeck/HealthLog.git
synced 2026-11-15 23:12:04 +00:00
Two directions, folding the vault and labs pipelines into one linking path without weakening either manual flow. Vault document → lab values (auto-stage). After the per-document auto-index job transcribes a stored document, a lab-looking document is run through the same inbound extraction the manual "Extract" button uses, but the facts land PENDING for the existing human review — nothing is committed. Gated on both the documents and labs modules plus the auto-AI-read consent gate the auto-index external path already uses; a text-structuring pass over the transcription the index just produced, so no second vision call is spent. The staging is a guarded STORED→EXTRACTED transition, and a keyword heuristic (or an explicit LAB_RESULT kind) keeps an arbitrary photo from burning a call. Everyone without the opt-in keeps the manual extract button. Lab scan → vault. A lab report scanned in the labs area is now also filed into the Documents vault (kind LAB_RESULT) through the existing upload — encrypted at rest, EXIF-stripped, thumbnailed, sha256-deduped — and the committed labs are cross-linked back to it with the same APPROVED-observation provenance the manual vault → labs path produces. Text-mode scans keep the image on-device and file nothing. Idempotent: a re-commit inserts no rows and links nothing new, and the vault dedupe means no duplicate document. Owner-scoped and module-gated on both sides; the cross-link is best-effort so it never fails the authoritative write.
170 lines
5.7 KiB
TypeScript
170 lines
5.7 KiB
TypeScript
"use client";
|
|
|
|
/**
|
|
* v1.18.9 — client hooks for the Lab-OCR ingestion flow.
|
|
*
|
|
* - `useOcrCapability()` — the cheap capability probe that decides whether the
|
|
* "Scan a report" affordance shows.
|
|
* - `useOcrExtract()` — uploads the photo / PDF and returns the proposed rows.
|
|
* A vision call is slow, so it opts out of the default 15 s fetch timeout in
|
|
* favour of a generous 90 s window.
|
|
* - `useOcrCommit()` — writes the user-confirmed rows and invalidates the
|
|
* labs + biomarker query keys.
|
|
*/
|
|
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
|
|
|
|
import { apiFetch, apiGet, apiPatch, apiPost } from "@/lib/api/api-fetch";
|
|
import { ocrImageToText } from "@/lib/labs/local-ocr";
|
|
import { queryKeys } from "@/lib/query-keys";
|
|
import type {
|
|
OcrCapabilityDto,
|
|
OcrCommitResponseDto,
|
|
OcrExtractResponseDto,
|
|
} from "@/lib/validations/labs-ocr";
|
|
|
|
import type { LabResultDto } from "./types";
|
|
|
|
/** Per-row payload the commit endpoint accepts (the human-confirmed shape). */
|
|
export interface OcrCommitRowInput {
|
|
analyte: string;
|
|
panel?: string;
|
|
value?: number;
|
|
valueText?: string;
|
|
unit?: string;
|
|
referenceLow?: number;
|
|
referenceHigh?: number;
|
|
takenAt: string;
|
|
}
|
|
|
|
export interface OcrCommitResult extends OcrCommitResponseDto {
|
|
inserted: LabResultDto[];
|
|
}
|
|
|
|
/** Capability probe — refetched when the scan dialog opens. */
|
|
export function useOcrCapability(enabled: boolean) {
|
|
return useQuery<OcrCapabilityDto>({
|
|
queryKey: queryKeys.ocrCapability(),
|
|
queryFn: () => apiFetch<OcrCapabilityDto>("/api/labs/ocr/capability"),
|
|
enabled,
|
|
staleTime: 60_000,
|
|
});
|
|
}
|
|
|
|
/** Upload + extract (VISION mode). Resolves with the proposed review rows. */
|
|
export function useOcrExtract() {
|
|
return useMutation<OcrExtractResponseDto, Error, File>({
|
|
mutationFn: (file: File) => {
|
|
const form = new FormData();
|
|
form.append("file", file);
|
|
return apiFetch<OcrExtractResponseDto>("/api/labs/ocr/extract", {
|
|
method: "POST",
|
|
body: form,
|
|
// Vision extraction is slow; a generous ceiling beats the 15 s default.
|
|
signal: AbortSignal.timeout(90_000),
|
|
});
|
|
},
|
|
});
|
|
}
|
|
|
|
/**
|
|
* TEXT mode (v1.18.10) — OCR the image IN THE BROWSER (tesseract.js), then POST
|
|
* only the extracted text. The raw image never leaves the device. Resolves with
|
|
* the same proposed-rows DTO the vision path returns, so the review/commit flow
|
|
* is shared verbatim.
|
|
*/
|
|
export function useOcrTextExtract() {
|
|
return useMutation<OcrExtractResponseDto, Error, File>({
|
|
mutationFn: async (file: File) => {
|
|
const text = await ocrImageToText(file);
|
|
return apiPost<OcrExtractResponseDto>("/api/labs/ocr/extract", {
|
|
mode: "text",
|
|
text,
|
|
});
|
|
},
|
|
});
|
|
}
|
|
|
|
/** The local-OCR opt-in preference (read + toggle). */
|
|
export interface LabsLocalOcrPref {
|
|
labsLocalOcrEnabled: boolean;
|
|
}
|
|
|
|
/** Read the current local-OCR opt-in flag. */
|
|
export function useLabsLocalOcr(enabled = true) {
|
|
return useQuery<LabsLocalOcrPref>({
|
|
queryKey: queryKeys.labsLocalOcr(),
|
|
queryFn: () => apiGet<LabsLocalOcrPref>("/api/auth/me/labs-local-ocr"),
|
|
enabled,
|
|
staleTime: 60_000,
|
|
});
|
|
}
|
|
|
|
/** Toggle the local-OCR opt-in; invalidates the flag + the capability probe. */
|
|
export function useUpdateLabsLocalOcr() {
|
|
const queryClient = useQueryClient();
|
|
return useMutation<LabsLocalOcrPref, Error, boolean>({
|
|
mutationFn: (labsLocalOcrEnabled: boolean) =>
|
|
apiPatch<LabsLocalOcrPref>("/api/auth/me/labs-local-ocr", {
|
|
labsLocalOcrEnabled,
|
|
}),
|
|
onSuccess: (data) => {
|
|
queryClient.setQueryData(queryKeys.labsLocalOcr(), data);
|
|
// The toggle changes whether text-mode scanning is available.
|
|
queryClient.invalidateQueries({ queryKey: queryKeys.ocrCapability() });
|
|
},
|
|
});
|
|
}
|
|
|
|
/** The commit payload: the confirmed rows plus, in vision mode, the source file. */
|
|
export interface OcrCommitInput {
|
|
rows: OcrCommitRowInput[];
|
|
/**
|
|
* S9 — the scanned file, threaded from the vision-mode extract. When present
|
|
* (and the documents module is on) it is filed into the Documents vault and
|
|
* the committed labs are cross-linked to it. Absent in text mode, where the
|
|
* image stays on-device.
|
|
*/
|
|
file?: File | null;
|
|
}
|
|
|
|
/**
|
|
* S9 — file the scanned bytes into the Documents vault (kind LAB_RESULT) via the
|
|
* existing upload endpoint (encrypted at rest, EXIF-stripped, thumbnailed,
|
|
* sha256-deduped). Best-effort: a module-off account 403s and a re-scan dedupes,
|
|
* so any failure resolves to `undefined` and the commit proceeds unlinked.
|
|
*/
|
|
async function fileScanToVault(file: File): Promise<string | undefined> {
|
|
const form = new FormData();
|
|
form.append("file", file);
|
|
form.append("kind", "LAB_RESULT");
|
|
const doc = await apiFetch<{ id: string }>("/api/documents/inbound", {
|
|
method: "POST",
|
|
body: form,
|
|
});
|
|
return doc?.id;
|
|
}
|
|
|
|
/** Commit the confirmed rows and invalidate the dependent reads. */
|
|
export function useOcrCommit() {
|
|
const queryClient = useQueryClient();
|
|
return useMutation<OcrCommitResult, Error, OcrCommitInput>({
|
|
mutationFn: async ({ rows, file }: OcrCommitInput) => {
|
|
const documentId = file
|
|
? await fileScanToVault(file).catch(() => undefined)
|
|
: undefined;
|
|
return apiPost<OcrCommitResult>("/api/labs/ocr/commit", {
|
|
rows,
|
|
...(documentId ? { documentId } : {}),
|
|
});
|
|
},
|
|
onSuccess: (_result, { file }) => {
|
|
queryClient.invalidateQueries({ queryKey: queryKeys.labResults() });
|
|
queryClient.invalidateQueries({ queryKey: queryKeys.biomarkers() });
|
|
// A scan filed into the vault adds a document — refresh its lists.
|
|
if (file) {
|
|
queryClient.invalidateQueries({ queryKey: queryKeys.documents() });
|
|
}
|
|
},
|
|
});
|
|
}
|