mirror of
https://github.com/MBombeck/HealthLog.git
synced 2026-11-19 08:12:52 +00:00
The MCP writes, the Telegram reply, the CSV and backup importers and the Apple export import refreshed the rollups by hand and never re-warmed the cached status assessments, so a reading logged there kept the day's old assessment until the nightly pass. They now run the shared post-write tail, and the export import re-warms every type it wrote. The WHOOP body sync removed its legacy weight row without refolding that day; it does now. A structural test lists every file that writes measurements and how it keeps both readers current, so a new write site fails until it says.
170 lines
5.8 KiB
TypeScript
170 lines
5.8 KiB
TypeScript
/**
|
|
* v1.19.2 — server-authoritative measurement capture from the Telegram bot.
|
|
*
|
|
* The HTTP measurement-create path (`POST /api/measurements`) is bound to a
|
|
* cookie/Bearer session via `requireAuth`; the Telegram webhook resolves the
|
|
* user from the linked chat instead. This helper holds the shared write so
|
|
* the two entry points agree on the canonical shape: the same range guard,
|
|
* the same canonical unit, the same cache invalidation + DAY-rollup
|
|
* recompute the manual route fires. `source` is pinned to the `TELEGRAM`
|
|
* `MeasurementSource` value (added in migration 0189).
|
|
*
|
|
* The `userId` is NEVER taken from the Telegram payload — the caller passes
|
|
* the id it resolved from the stored `telegramChatId` binding. The capture
|
|
* is correlated to a specific `MeasurementReminder` (carrying the expected
|
|
* `measurementType`) through a `TelegramPromptContext` row, so a numeric
|
|
* reply can only ever land the metric that reminder asked for, for that
|
|
* user. BP (two values) is out of scope for the single-numeric-reply path.
|
|
*/
|
|
import type { Prisma, PrismaClient } from "@/generated/prisma/client";
|
|
import type { MeasurementType } from "@/generated/prisma/client";
|
|
import { prisma as defaultPrisma } from "@/lib/db";
|
|
import {
|
|
getUnitForType,
|
|
validateMeasurementRange,
|
|
} from "@/lib/validations/measurement";
|
|
import { invalidateUserMeasurements } from "@/lib/cache/invalidate";
|
|
import { afterMeasurementMutation } from "@/lib/rollups/after-measurement-mutation";
|
|
import { emitInsertedMeasurementArrivals } from "@/lib/arrivals/measurement-emit";
|
|
|
|
/**
|
|
* The single-value measurement types a numeric Telegram reply can capture.
|
|
*
|
|
* Excludes BLOOD_PRESSURE_SYS — a BP reading needs systolic AND diastolic,
|
|
* which a single numeric reply can't express unambiguously. The BP reminder
|
|
* keeps its existing satisfy-only "done" flow; a value capture for it is a
|
|
* documented follow-up (a guided two-number prompt).
|
|
*/
|
|
const TELEGRAM_CAPTURABLE_TYPES: ReadonlySet<MeasurementType> =
|
|
new Set<MeasurementType>([
|
|
"WEIGHT",
|
|
"PULSE",
|
|
"BLOOD_GLUCOSE",
|
|
"OXYGEN_SATURATION",
|
|
"BODY_TEMPERATURE",
|
|
"BODY_FAT",
|
|
"FAT_MASS",
|
|
"FAT_FREE_MASS",
|
|
"MUSCLE_MASS",
|
|
"LEAN_BODY_MASS",
|
|
"BONE_MASS",
|
|
"TOTAL_BODY_WATER",
|
|
"VISCERAL_FAT",
|
|
"BODY_MASS_INDEX",
|
|
]);
|
|
|
|
/**
|
|
* True when a numeric Telegram reply can capture a Measurement for this
|
|
* reminder's target type. The webhook gates the value-prompt on this so a
|
|
* BP reminder (or a free-text Vorsorge with no `measurementType`) never
|
|
* offers an ambiguous numeric capture.
|
|
*/
|
|
export function isTelegramCapturableType(
|
|
type: MeasurementType | null | undefined,
|
|
): type is MeasurementType {
|
|
return type != null && TELEGRAM_CAPTURABLE_TYPES.has(type);
|
|
}
|
|
|
|
export interface TelegramMeasurementResult {
|
|
/** `ok` — a row was written (or already existed under the dedup key).
|
|
* `invalid_number` — the reply did not parse to a finite number.
|
|
* `out_of_range` — the value fell outside the type's plausible range.
|
|
* `unsupported_type` — the type is not single-value capturable. */
|
|
status: "ok" | "invalid_number" | "out_of_range" | "unsupported_type";
|
|
}
|
|
|
|
/**
|
|
* Parse a free-text Telegram reply into a finite number. Tolerates a
|
|
* comma decimal separator (de-DE keyboards) and surrounding whitespace;
|
|
* rejects anything with trailing non-numeric noise so "72 bpm" doesn't
|
|
* silently capture 72.
|
|
*/
|
|
export function parseTelegramNumber(text: string): number | null {
|
|
const normalised = text.trim().replace(",", ".");
|
|
if (!/^-?\d+(\.\d+)?$/.test(normalised)) return null;
|
|
const n = Number(normalised);
|
|
return Number.isFinite(n) ? n : null;
|
|
}
|
|
|
|
/**
|
|
* Capture a measurement on behalf of a Telegram-linked user from a numeric
|
|
* reply to a measurement-reminder prompt.
|
|
*
|
|
* Idempotent on `externalId` (the per-prompt key the caller derives from
|
|
* `telegram:measure:<chatId>:<promptMsgId>`): a redelivered reply converges
|
|
* onto the same row via the `(userId, type, source, externalId)` unique
|
|
* instead of minting a duplicate.
|
|
*/
|
|
export async function logTelegramMeasurement(input: {
|
|
userId: string;
|
|
type: MeasurementType;
|
|
rawText: string;
|
|
tz: string | null;
|
|
/** Stable per-prompt id for Telegram redelivery dedup. */
|
|
externalId: string;
|
|
client?: PrismaClient | Prisma.TransactionClient;
|
|
}): Promise<TelegramMeasurementResult> {
|
|
const prisma = (input.client ?? defaultPrisma) as PrismaClient;
|
|
|
|
if (!isTelegramCapturableType(input.type)) {
|
|
return { status: "unsupported_type" };
|
|
}
|
|
|
|
const value = parseTelegramNumber(input.rawText);
|
|
if (value === null) {
|
|
return { status: "invalid_number" };
|
|
}
|
|
|
|
if (validateMeasurementRange(input.type, value) !== null) {
|
|
return { status: "out_of_range" };
|
|
}
|
|
|
|
const measuredAt = new Date();
|
|
|
|
const existing = await prisma.measurement.findUnique({
|
|
where: {
|
|
userId_type_source_externalId: {
|
|
userId: input.userId,
|
|
type: input.type,
|
|
source: "TELEGRAM",
|
|
externalId: input.externalId,
|
|
},
|
|
},
|
|
select: { id: true },
|
|
});
|
|
if (existing) {
|
|
return { status: "ok" };
|
|
}
|
|
|
|
const created = await prisma.measurement.create({
|
|
data: {
|
|
userId: input.userId,
|
|
type: input.type,
|
|
value,
|
|
unit: getUnitForType(input.type),
|
|
source: "TELEGRAM",
|
|
measuredAt,
|
|
externalId: input.externalId,
|
|
},
|
|
select: { id: true, type: true, measuredAt: true },
|
|
});
|
|
|
|
void emitInsertedMeasurementArrivals(
|
|
input.userId,
|
|
[created],
|
|
"telegram",
|
|
).catch(() => {});
|
|
|
|
invalidateUserMeasurements(input.userId, { evict: true });
|
|
|
|
// Rollup refresh plus the status re-warm, both best-effort — a cache
|
|
// tier, never a write-path invariant.
|
|
await afterMeasurementMutation(
|
|
input.userId,
|
|
[{ type: input.type, measuredAt }],
|
|
"telegram-measurement",
|
|
);
|
|
|
|
return { status: "ok" };
|
|
}
|