(null);
const [fileInputKey, setFileInputKey] = useState(0);
const queryClient = useQueryClient();
@@ -62,7 +64,6 @@ export function IntakeImportDialog({
function resetImportForm() {
setJsonText("");
setResult(null);
- setResultType(null);
setSelectedFileName(null);
setFileInputKey((prev) => prev + 1);
}
@@ -77,18 +78,25 @@ export function IntakeImportDialog({
if (!file) return;
setResult(null);
- setResultType(null);
try {
const content = await file.text();
JSON.parse(content);
setJsonText(content);
setSelectedFileName(file.name);
- setResult(t("medications.importFileLoaded", { name: file.name }));
- setResultType("success");
+ // A readable file is a step, not an import. It says so in neutral tone —
+ // the success affordance belongs to a run that actually wrote rows.
+ setResult({
+ kind: "notice",
+ tone: "info",
+ text: t("medications.importFileLoaded", { name: file.name }),
+ });
} catch {
- setResult(t("medications.importInvalidJson"));
- setResultType("error");
+ setResult({
+ kind: "notice",
+ tone: "error",
+ text: t("medications.importInvalidJson"),
+ });
}
}
@@ -96,7 +104,6 @@ export function IntakeImportDialog({
if (!medicationId || !jsonText.trim()) return;
setImporting(true);
setResult(null);
- setResultType(null);
try {
let data = JSON.parse(jsonText.trim());
@@ -114,37 +121,41 @@ export function IntakeImportDialog({
statusUrl: string;
}>(`/api/medications/${medicationId}/intake/import`, data);
const d = await waitForMedicationIntakeImport(kickoff.statusUrl);
- setResult(
- t("medications.importResult", { imported: d.imported }) +
- (d.skippedDuplicates > 0
- ? `, ${t("medications.importDuplicatesSkipped", { count: d.skippedDuplicates })}`
- : "") +
- (d.skippedInvalid > 0
- ? `, ${t("medications.importInvalidSkipped", { count: d.skippedInvalid })}`
- : ""),
- );
- setResultType("success");
+ setResult({
+ kind: "outcome",
+ imported: d.imported,
+ skipped: d.skipped,
+ skipReasons: d.skipReasons,
+ });
// An import can land today-dated doses, so clear the Today hero +
// dashboard through the blessed helper (they are unmounted behind the
// import dialog on the detail page).
void invalidateMedicationReads(queryClient);
} catch (err) {
if (err instanceof MedicationIntakeImportError) {
- setResult(t("medications.importFailed"));
- setResultType("error");
+ setResult({
+ kind: "notice",
+ tone: "error",
+ text: t("medications.importFailed"),
+ });
return;
}
if (!(err instanceof ApiError)) throw err;
- setResult(err.message || t("medications.importFailed"));
- setResultType("error");
+ setResult({
+ kind: "notice",
+ tone: "error",
+ text: err.message || t("medications.importFailed"),
+ });
}
} catch (err) {
- setResult(
- err instanceof SyntaxError
- ? t("medications.importInvalidFormat")
- : (err as Error).message || t("medications.importFailed"),
- );
- setResultType("error");
+ setResult({
+ kind: "notice",
+ tone: "error",
+ text:
+ err instanceof SyntaxError
+ ? t("medications.importInvalidFormat")
+ : (err as Error).message || t("medications.importFailed"),
+ });
} finally {
setImporting(false);
}
@@ -226,8 +237,8 @@ export function IntakeImportDialog({
{`[
- {"datum": "2026-02-14", "uhrzeit": "10:27:43", "zaehler": 523},
- {"datum": "2026-02-14", "uhrzeit": "23:33:42", "zaehler": 524}
+ {"datum": "2026-02-14", "uhrzeit": "10:27:43"},
+ {"datum": "2026-02-14", "uhrzeit": "23:33:42"}
]`}
- {result && (
-
- {result}
-
- )}
+
+ {result && }
+
);
diff --git a/src/components/medications/intake-import-result.tsx b/src/components/medications/intake-import-result.tsx
new file mode 100644
index 000000000..69bbf5754
--- /dev/null
+++ b/src/components/medications/intake-import-result.tsx
@@ -0,0 +1,126 @@
+"use client";
+
+/**
+ * What the intake-import dialog says once an attempt has finished.
+ *
+ * Split out of the dialog so the outcome can be rendered and asserted on its
+ * own — the dialog itself is a sheet with a query client and a file input, and
+ * the thing that has to be right is the sentence at the end of the run.
+ *
+ * The rules are the ones the settings import panel already follows, reused
+ * rather than restated: `classifyImportOutcome` decides the tone from the
+ * counts, so an import that wrote nothing can never carry the success tick,
+ * and `ImportOutcomeLine` owns the tick and the success colour. The skips are
+ * grouped by reason with a count, because a file that trips one rule trips it
+ * on every row and a per-row list is the same sentence a hundred times.
+ *
+ * This dialog was not covered when that work landed for the CSV and JSON
+ * cards; the medication intake import is the third import surface and it now
+ * answers the same way.
+ */
+import {
+ classifyImportOutcome,
+ type ImportOutcome,
+} from "@/components/settings/import-panel/import-result-state";
+import { ImportOutcomeLine } from "@/components/settings/import-panel/import-result-view";
+import { useTranslations } from "@/lib/i18n/context";
+
+/** A skip group exactly as the import job reports it. */
+export interface IntakeImportSkipGroup {
+ reason: string;
+ count: number;
+}
+
+/**
+ * `notice` covers everything that happened before the importer had an opinion —
+ * a file was read, the JSON did not parse, the request was refused. `outcome`
+ * is the import itself.
+ */
+export type IntakeImportResultState =
+ | { kind: "notice"; tone: "info" | "error"; text: string }
+ | {
+ kind: "outcome";
+ imported: number;
+ skipped: number;
+ skipReasons: IntakeImportSkipGroup[];
+ };
+
+/**
+ * Plain language per machine-readable skip reason. Written as literal `t(…)`
+ * calls rather than a computed key so the i18n call-site coverage guard sees
+ * every one of them.
+ */
+function useSkipReasonLabel(): (reason: string) => string {
+ const { t } = useTranslations();
+ const labels: Record = {
+ duplicate_in_file: t("medications.import.reasonDuplicateInFile"),
+ already_recorded: t("medications.import.reasonAlreadyRecorded"),
+ };
+ const fallback = t("medications.import.reasonUnknown");
+ return (reason: string) => labels[reason] ?? fallback;
+}
+
+export function IntakeImportResultView({
+ result,
+}: {
+ result: IntakeImportResultState;
+}) {
+ const { t, tCount } = useTranslations();
+ const labelFor = useSkipReasonLabel();
+
+ if (result.kind === "notice") {
+ return (
+
+ {result.text}
+
+ );
+ }
+
+ const outcome: ImportOutcome = classifyImportOutcome({
+ written: result.imported,
+ skipped: result.skipped,
+ });
+
+ const message = (() => {
+ if (outcome === "empty") return t("medications.import.resultEmpty");
+ if (outcome === "failed") {
+ return t("medications.import.resultNothing", { skipped: result.skipped });
+ }
+ if (outcome === "partial") {
+ return t("medications.import.resultPartial", {
+ imported: result.imported,
+ skipped: result.skipped,
+ });
+ }
+ return t("medications.import.resultSuccess", { imported: result.imported });
+ })();
+
+ return (
+
+
+ {result.skipReasons.length > 0 && (
+
+ {result.skipReasons.map((group) => (
+ -
+ {tCount("medications.import.skipGroup", group.count, {
+ count: group.count,
+ reason: labelFor(group.reason),
+ })}
+
+ ))}
+
+ )}
+
+ {tCount(
+ "settings.sections.environment.fetchFailed",
+ data.lastFetchFailure.failures,
+ {
+ count: data.lastFetchFailure.failures,
+ when: formatDateTime(data.lastFetchFailure.lastFailedAt),
+ },
+ )}
+
+ )}
{/* Attribution (CC BY 4.0, required) */}
diff --git a/src/components/settings/import-panel/__tests__/import-result-guard.test.ts b/src/components/settings/import-panel/__tests__/import-result-guard.test.ts
index ee5f100df..defcda458 100644
--- a/src/components/settings/import-panel/__tests__/import-result-guard.test.ts
+++ b/src/components/settings/import-panel/__tests__/import-result-guard.test.ts
@@ -7,6 +7,13 @@
* exactly one key of the outcome table, and no card reaches for them
* directly. A future card that hand-rolls a green tick fails here rather than
* shipping and lying to a self-hoster about their sensor history.
+ *
+ * #650 widened it. The medication intake import is a third import surface, in
+ * another directory, and it was not covered when the rule landed — it kept its
+ * own success/error tone and reported a run that wrote one row out of
+ * twenty-eight as a success. "Every import surface" now means every one of
+ * them, listed by path, so a fourth surface has to be added here deliberately
+ * rather than inheriting the old behaviour by being somewhere else.
*/
import { describe, it, expect } from "vitest";
import { readFileSync, readdirSync } from "node:fs";
@@ -14,6 +21,34 @@ import { join } from "node:path";
const PANEL_DIR = join(__dirname, "..");
const PRESENTATION_FILE = "import-result-view.tsx";
+const REPO_ROOT = join(__dirname, "..", "..", "..", "..", "..");
+
+/**
+ * Every surface that reports an import result, and the module each one must
+ * render its outcome through. Paths from the repository root.
+ */
+const IMPORT_SURFACES: ReadonlyArray<{ path: string; through: RegExp }> = [
+ {
+ path: "src/components/settings/import-panel/csv-import-card.tsx",
+ through: /CsvImportResultView|ImportOutcomeLine/,
+ },
+ {
+ path: "src/components/settings/import-panel/json-import-card.tsx",
+ through: /CsvImportResultView|ImportOutcomeLine/,
+ },
+ {
+ path: "src/components/settings/import-panel/apple-health-import-card.tsx",
+ through: /CsvImportResultView|ImportOutcomeLine/,
+ },
+ {
+ path: "src/components/medications/intake-import-result.tsx",
+ through: /ImportOutcomeLine/,
+ },
+ {
+ path: "src/components/medications/intake-import-dialog.tsx",
+ through: /IntakeImportResultView/,
+ },
+];
/** The success affordance: the tick component and the success colour token. */
const SUCCESS_MARKERS = ["CheckCircle2", "text-success"] as const;
@@ -25,10 +60,16 @@ function panelSourceFiles(): string[] {
}
/** Code only — a comment naming the marker is prose, not an affordance. */
+function stripComments(source: string): string {
+ return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
+}
+
function readCode(name: string): string {
- return readFileSync(join(PANEL_DIR, name), "utf8")
- .replace(/\/\*[\s\S]*?\*\//g, "")
- .replace(/^\s*\/\/.*$/gm, "");
+ return stripComments(readFileSync(join(PANEL_DIR, name), "utf8"));
+}
+
+function readRepoCode(relativePath: string): string {
+ return stripComments(readFileSync(join(REPO_ROOT, relativePath), "utf8"));
}
describe("import panel — success affordance is owned by the outcome table", () => {
@@ -63,13 +104,27 @@ describe("import panel — success affordance is owned by the outcome table", ()
}
});
- it("routes every card's result line through the shared outcome line", () => {
- for (const name of [
- "csv-import-card.tsx",
- "json-import-card.tsx",
- "apple-health-import-card.tsx",
- ]) {
- expect(readCode(name)).toMatch(/CsvImportResultView|ImportOutcomeLine/);
+ it("routes every import surface's result line through the shared outcome line", () => {
+ for (const surface of IMPORT_SURFACES) {
+ expect(
+ readRepoCode(surface.path),
+ `${surface.path} must render its outcome through the shared line`,
+ ).toMatch(surface.through);
}
});
+
+ it("keeps the success markers out of every import surface", () => {
+ const offenders = IMPORT_SURFACES.filter((surface) =>
+ SUCCESS_MARKERS.some((marker) =>
+ readRepoCode(surface.path).includes(marker),
+ ),
+ ).map((surface) => surface.path);
+ expect(
+ offenders,
+ offenders.length > 0
+ ? `Import surface(s) hand-rolling the success affordance instead of ` +
+ `classifying the counts: ${offenders.join(", ")}`
+ : undefined,
+ ).toEqual([]);
+ });
});
diff --git a/src/lib/jobs/__tests__/medication-intake-import.test.ts b/src/lib/jobs/__tests__/medication-intake-import.test.ts
index ce3b81c28..205ecd0ba 100644
--- a/src/lib/jobs/__tests__/medication-intake-import.test.ts
+++ b/src/lib/jobs/__tests__/medication-intake-import.test.ts
@@ -5,9 +5,11 @@ import {
MEDICATION_INTAKE_IMPORT_ROLLUP_CHUNK_SIZE,
_setMedicationIntakeImportPrismaForTests,
advanceMedicationImportProgress,
+ groupMedicationImportSkips,
medicationImportChunk,
processMedicationIntakeImportJob,
sanitiseMedicationImportFailure,
+ totalMedicationImportSkips,
type MedicationImportProgress,
} from "@/lib/jobs/medication-intake-import";
@@ -15,7 +17,7 @@ const INITIAL: MedicationImportProgress = {
processed: 0,
total: 1_000,
imported: 0,
- skippedDuplicates: 0,
+ skippedByReason: {},
touchedDays: [],
rollupProcessed: 0,
};
@@ -43,21 +45,21 @@ describe("medication intake import worker bounds", () => {
from: 0,
processed: 100,
imported: 98,
- skippedDuplicates: 2,
+ skippedByReason: { duplicate_in_file: 2 },
touchedDays: ["2026-07-20", "2026-07-21"],
});
const second = advanceMedicationImportProgress(first, {
from: 100,
processed: 100,
imported: 97,
- skippedDuplicates: 3,
+ skippedByReason: { duplicate_in_file: 1, already_recorded: 2 },
touchedDays: ["2026-07-21", "2026-07-22"],
});
const replay = advanceMedicationImportProgress(second, {
from: 0,
processed: 100,
imported: 98,
- skippedDuplicates: 2,
+ skippedByReason: { duplicate_in_file: 2 },
touchedDays: ["2026-07-20"],
});
@@ -66,7 +68,7 @@ describe("medication intake import worker bounds", () => {
processed: 200,
total: 1_000,
imported: 195,
- skippedDuplicates: 5,
+ skippedByReason: { duplicate_in_file: 3, already_recorded: 2 },
touchedDays: ["2026-07-20", "2026-07-21", "2026-07-22"],
rollupProcessed: 0,
});
@@ -93,7 +95,7 @@ describe("medication intake import worker bounds", () => {
processed: 0,
total: 0,
imported: 0,
- skippedDuplicates: 0,
+ skippedByReason: {},
touchedDays,
};
let status = "running";
@@ -185,3 +187,62 @@ describe("medication intake import worker bounds", () => {
expect(auditCount).toBe(1);
});
});
+
+describe("medication import skip reporting (#650)", () => {
+ it("reports one entry per reason, count descending, and omits zero", () => {
+ expect(
+ groupMedicationImportSkips({
+ duplicate_in_file: 2,
+ already_recorded: 9,
+ }),
+ ).toEqual([
+ { reason: "already_recorded", count: 9 },
+ { reason: "duplicate_in_file", count: 2 },
+ ]);
+ expect(
+ groupMedicationImportSkips({
+ duplicate_in_file: 0,
+ already_recorded: 4,
+ }),
+ ).toEqual([{ reason: "already_recorded", count: 4 }]);
+ expect(groupMedicationImportSkips({})).toEqual([]);
+ });
+
+ it("totals every reason so the headline count matches the groups", () => {
+ const counts = { duplicate_in_file: 2, already_recorded: 9 };
+ expect(totalMedicationImportSkips(counts)).toBe(11);
+ expect(
+ groupMedicationImportSkips(counts).reduce(
+ (sum, group) => sum + group.count,
+ 0,
+ ),
+ ).toBe(totalMedicationImportSkips(counts));
+ expect(totalMedicationImportSkips({})).toBe(0);
+ });
+
+ it("keeps the two reasons apart while accumulating across chunks", () => {
+ const first = advanceMedicationImportProgress(INITIAL, {
+ from: 0,
+ processed: 100,
+ imported: 90,
+ skippedByReason: { duplicate_in_file: 10 },
+ touchedDays: [],
+ });
+ const second = advanceMedicationImportProgress(first, {
+ from: 100,
+ processed: 100,
+ imported: 95,
+ skippedByReason: { already_recorded: 5 },
+ touchedDays: [],
+ });
+
+ expect(second.skippedByReason).toEqual({
+ duplicate_in_file: 10,
+ already_recorded: 5,
+ });
+ expect(groupMedicationImportSkips(second.skippedByReason)).toEqual([
+ { reason: "duplicate_in_file", count: 10 },
+ { reason: "already_recorded", count: 5 },
+ ]);
+ });
+});
diff --git a/src/lib/jobs/job-failures.ts b/src/lib/jobs/job-failures.ts
new file mode 100644
index 000000000..5141bbd1b
--- /dev/null
+++ b/src/lib/jobs/job-failures.ts
@@ -0,0 +1,153 @@
+/**
+ * What the queue already knows about its own broken jobs, read back out.
+ *
+ * The `environment-fetch` job threw on every single run for the whole life of
+ * the environmental-context module. It was handled correctly at the call site —
+ * `recordError()`, a `workerLog("error", …)`, a rethrow so pg-boss retries —
+ * and none of that reached a screen. `recordError()` increments one unnamed
+ * counter, so `/api/admin/status` could say "errors: 41" and not which queue.
+ * The worker log only exists where someone is tailing the container. The user
+ * saw "0 days recorded" and had no way to tell an empty module from a broken
+ * one.
+ *
+ * pg-boss has held the answer the whole time: a job that exhausts its retries
+ * lands in `pgboss.job` with `state = 'failed'`, its queue name, the thrown
+ * error in `output`, and the instant it gave up. Reading that back is a
+ * complete signal for every queue at once, and it needs nothing from the ~30
+ * `recordError()` call sites — which is the point, because a visibility fix
+ * that has to be remembered at each call site is the same failure mode one
+ * level up.
+ *
+ * Both readers fail soft to `null`. The `pgboss` schema is created by the
+ * worker, so a web-only deployment legitimately has no such table, and the
+ * admin status page must not 500 because the queue is absent. `null` means "no
+ * queue to ask", which is not the same fact as an empty array ("asked, nothing
+ * broken") — the callers keep the two apart.
+ */
+import { prisma } from "@/lib/db";
+import { redactSecrets } from "@/lib/logging/redact";
+
+/** How far back a failure still counts as news. */
+export const JOB_FAILURE_WINDOW_HOURS = 72;
+
+/** Queues named in one report — enough to see a pattern, bounded for the wire. */
+const MAX_QUEUES = 20;
+
+/** The error text is for a human reading a status page, not for a stack trace. */
+const MAX_ERROR_CHARS = 300;
+
+export interface FailingQueue {
+ /** The pg-boss queue name, e.g. `environment-fetch`. */
+ queue: string;
+ /** Jobs that exhausted their retries inside the window. */
+ failures: number;
+ /** ISO instant of the newest failure. */
+ lastFailedAt: string;
+ /** The newest failure's message, redacted and truncated. */
+ lastError: string;
+}
+
+interface FailingQueueRow {
+ name: string;
+ failures: number;
+ last_failed_at: Date | null;
+ last_error: string | null;
+}
+
+/**
+ * Turn whatever pg-boss stored in `output` into one line. A thrown `Error`
+ * serialises to `{ message, stack, … }`; a thrown non-Error can be any JSON at
+ * all, so the raw text is the fallback rather than an invented placeholder.
+ */
+function presentError(raw: string | null): string {
+ if (raw === null) return "";
+ const trimmed = raw.trim();
+ if (trimmed.length === 0) return "";
+ const redacted = redactSecrets(trimmed);
+ return redacted.length > MAX_ERROR_CHARS
+ ? `${redacted.slice(0, MAX_ERROR_CHARS)}…`
+ : redacted;
+}
+
+/**
+ * Every queue with at least one exhausted-retry failure in the window, newest
+ * first. `null` when the queue schema is not present at all.
+ */
+export async function readFailingQueues(
+ withinHours: number = JOB_FAILURE_WINDOW_HOURS,
+): Promise {
+ try {
+ const rows = await prisma.$queryRaw`
+ SELECT
+ name,
+ count(*)::int AS failures,
+ max(completed_on) AS last_failed_at,
+ (
+ array_agg(
+ COALESCE(output->>'message', output::text)
+ ORDER BY completed_on DESC NULLS LAST
+ )
+ )[1] AS last_error
+ FROM pgboss.job
+ WHERE state = 'failed'
+ AND completed_on > now() - make_interval(hours => ${withinHours}::int)
+ GROUP BY name
+ ORDER BY max(completed_on) DESC
+ LIMIT ${MAX_QUEUES}
+ `;
+ return rows
+ .filter((row) => row.last_failed_at !== null)
+ .map((row) => ({
+ queue: row.name,
+ failures: row.failures,
+ lastFailedAt: row.last_failed_at!.toISOString(),
+ lastError: presentError(row.last_error),
+ }));
+ } catch {
+ // No `pgboss` schema (web-only deployment) or no permission to read it.
+ // Absence of a queue is not a failing queue, and it is not zero either.
+ return null;
+ }
+}
+
+export interface QueueFailureForUser {
+ /** ISO instant the user's newest job on this queue gave up. */
+ lastFailedAt: string;
+ /** Failures for this user on this queue inside the window. */
+ failures: number;
+}
+
+/**
+ * The newest exhausted-retry failure of `queue` for one account, matched on the
+ * `userId` the job payload carries. Used by a user-facing surface to say "the
+ * last background run failed" instead of rendering a zero as if it were a
+ * measurement. Deliberately carries no error text: the message is written for
+ * an operator and can name internals, so a non-admin reader gets the fact and
+ * the time only.
+ */
+export async function readQueueFailureForUser(
+ queue: string,
+ userId: string,
+ withinHours: number = JOB_FAILURE_WINDOW_HOURS,
+): Promise {
+ try {
+ const rows = await prisma.$queryRaw<
+ Array<{ failures: number; last_failed_at: Date | null }>
+ >`
+ SELECT count(*)::int AS failures, max(completed_on) AS last_failed_at
+ FROM pgboss.job
+ WHERE name = ${queue}
+ AND state = 'failed'
+ AND data->>'userId' = ${userId}
+ AND completed_on > now() - make_interval(hours => ${withinHours}::int)
+ `;
+ const row = rows[0];
+ if (!row || row.last_failed_at === null || row.failures === 0) return null;
+ return {
+ lastFailedAt: row.last_failed_at.toISOString(),
+ failures: row.failures,
+ };
+ } catch {
+ return null;
+ }
+}
diff --git a/src/lib/jobs/medication-intake-import.ts b/src/lib/jobs/medication-intake-import.ts
index 80a055333..1cc758146 100644
--- a/src/lib/jobs/medication-intake-import.ts
+++ b/src/lib/jobs/medication-intake-import.ts
@@ -32,19 +32,78 @@ export interface MedicationImportPayload {
entries: MedicationImportEntry[];
}
+/**
+ * Why a submitted entry did not become a row. Machine-readable; the client
+ * turns each into a sentence.
+ *
+ * `duplicate_in_file` — two entries in the same submission resolve to the same
+ * instant, so only one can be written.
+ * `already_recorded` — the dose is already on the ledger for that instant, from
+ * an earlier import or from any other intake surface.
+ *
+ * They used to be one `skippedDuplicates` number, which is how a file whose
+ * every row collapsed onto one key could report "27 duplicates skipped" about
+ * 27 doses that had no duplicate anywhere. Naming the reason is what makes the
+ * count checkable against what the person actually submitted.
+ */
+export const MEDICATION_IMPORT_SKIP_REASONS = [
+ "duplicate_in_file",
+ "already_recorded",
+] as const;
+
+export type MedicationImportSkipReason =
+ (typeof MEDICATION_IMPORT_SKIP_REASONS)[number];
+
+/** Skip counts keyed by reason. A reason with no skips is absent, not zero. */
+export type MedicationImportSkipCounts = Partial<
+ Record
+>;
+
export interface MedicationImportProgress {
processed: number;
total: number;
imported: number;
- skippedDuplicates: number;
+ skippedByReason: MedicationImportSkipCounts;
touchedDays: string[];
rollupProcessed: number;
}
+export interface MedicationImportSkipGroup {
+ reason: MedicationImportSkipReason;
+ count: number;
+}
+
export interface MedicationImportResult {
imported: number;
- skippedDuplicates: number;
- skippedInvalid: number;
+ /** Total entries that did not become a row. */
+ skipped: number;
+ /**
+ * One entry per reason, count descending then reason — never the same
+ * sentence repeated per row. Empty when nothing was skipped.
+ */
+ skipReasons: MedicationImportSkipGroup[];
+}
+
+/** Collapse the running counts into the wire shape, in a stable order. */
+export function groupMedicationImportSkips(
+ counts: MedicationImportSkipCounts,
+): MedicationImportSkipGroup[] {
+ return MEDICATION_IMPORT_SKIP_REASONS.map((reason) => ({
+ reason,
+ count: counts[reason] ?? 0,
+ }))
+ .filter((group) => group.count > 0)
+ .sort((a, b) => b.count - a.count || a.reason.localeCompare(b.reason));
+}
+
+/** Total skipped across every reason. */
+export function totalMedicationImportSkips(
+ counts: MedicationImportSkipCounts,
+): number {
+ return MEDICATION_IMPORT_SKIP_REASONS.reduce(
+ (sum, reason) => sum + (counts[reason] ?? 0),
+ 0,
+ );
}
export interface MedicationIntakeImportQueuePayload {
@@ -55,7 +114,7 @@ export interface MedicationImportChunkResult {
from: number;
processed: number;
imported: number;
- skippedDuplicates: number;
+ skippedByReason: MedicationImportSkipCounts;
touchedDays: string[];
}
@@ -98,13 +157,20 @@ export function advanceMedicationImportProgress(
}
}
+ const skippedByReason: MedicationImportSkipCounts = {
+ ...previous.skippedByReason,
+ };
+ for (const reason of MEDICATION_IMPORT_SKIP_REASONS) {
+ const added = Math.max(0, Math.trunc(chunk.skippedByReason[reason] ?? 0));
+ if (added === 0) continue;
+ skippedByReason[reason] = (skippedByReason[reason] ?? 0) + added;
+ }
+
return {
processed,
total: previous.total,
imported: previous.imported + Math.max(0, Math.trunc(chunk.imported)),
- skippedDuplicates:
- previous.skippedDuplicates +
- Math.max(0, Math.trunc(chunk.skippedDuplicates)),
+ skippedByReason,
rollupProcessed: previous.rollupProcessed,
touchedDays,
};
@@ -146,6 +212,32 @@ function parsePayload(value: Prisma.JsonValue): MedicationImportPayload {
return { entries };
}
+/**
+ * Read the persisted skip counts. Strict, like every other field of the
+ * progress blob: an unknown reason key or a non-integer count means the row was
+ * not written by this code, and the job fails rather than reporting a number it
+ * cannot stand behind. Returns null on anything malformed.
+ */
+function parseSkipCounts(
+ value: Prisma.JsonValue | undefined,
+): MedicationImportSkipCounts | null {
+ if (value === undefined || value === null) return null;
+ if (typeof value !== "object" || Array.isArray(value)) return null;
+ const counts: MedicationImportSkipCounts = {};
+ for (const [key, raw] of Object.entries(value)) {
+ if (
+ !(MEDICATION_IMPORT_SKIP_REASONS as readonly string[]).includes(key) ||
+ typeof raw !== "number" ||
+ !Number.isInteger(raw) ||
+ raw < 0
+ ) {
+ return null;
+ }
+ counts[key as MedicationImportSkipReason] = raw;
+ }
+ return counts;
+}
+
function parseProgress(
value: Prisma.JsonValue,
total: number,
@@ -155,7 +247,7 @@ function parseProgress(
}
const processed = Number(value.processed);
const imported = Number(value.imported);
- const skippedDuplicates = Number(value.skippedDuplicates);
+ const skippedByReason = parseSkipCounts(value.skippedByReason);
const rawTouchedDays = value.touchedDays;
const touchedDays =
Array.isArray(rawTouchedDays) &&
@@ -170,8 +262,7 @@ function parseProgress(
processed > total ||
!Number.isInteger(imported) ||
imported < 0 ||
- !Number.isInteger(skippedDuplicates) ||
- skippedDuplicates < 0 ||
+ skippedByReason === null ||
touchedDays === null ||
!Number.isInteger(rollupProcessed) ||
rollupProcessed < 0 ||
@@ -183,7 +274,7 @@ function parseProgress(
processed,
total,
imported,
- skippedDuplicates,
+ skippedByReason,
touchedDays,
rollupProcessed,
};
@@ -289,8 +380,8 @@ async function processNextChunk(
}
const result: MedicationImportResult = {
imported: progress.imported,
- skippedDuplicates: progress.skippedDuplicates,
- skippedInvalid: 0,
+ skipped: totalMedicationImportSkips(progress.skippedByReason),
+ skipReasons: groupMedicationImportSkips(progress.skippedByReason),
};
const completedAt = new Date();
await tx.auditLog.create({
@@ -301,8 +392,8 @@ async function processNextChunk(
jobId: row.id,
medicationId: row.medicationId,
imported: result.imported,
- skippedDuplicates: result.skippedDuplicates,
- skippedInvalid: 0,
+ skipped: result.skipped,
+ skipReasons: result.skipReasons,
total: progress.total,
}),
},
@@ -365,11 +456,20 @@ async function processNextChunk(
const touchedDays = created.map((event) =>
dayKeyForScheduledFor(event.scheduledFor, row.user.timezone),
);
+ // Two different facts, counted apart. The Map collapse above is entries
+ // of this submission that resolve to the same instant; `skipDuplicates`
+ // then drops whatever the ledger already holds for that instant, from an
+ // earlier import or any other intake surface. Reporting both as one
+ // "duplicates" number is what let a whole month of distinct doses read
+ // as duplicates of each other.
const nextProgress = advanceMedicationImportProgress(progress, {
from: progress.processed,
processed: entries.length,
imported: created.length,
- skippedDuplicates: entries.length - created.length,
+ skippedByReason: {
+ duplicate_in_file: entries.length - uniqueEntries.length,
+ already_recorded: uniqueEntries.length - created.length,
+ },
touchedDays,
});
const heartbeatAt = new Date();
diff --git a/src/lib/medications/__tests__/intake-import-poll.test.ts b/src/lib/medications/__tests__/intake-import-poll.test.ts
index 82f412486..4826c29ce 100644
--- a/src/lib/medications/__tests__/intake-import-poll.test.ts
+++ b/src/lib/medications/__tests__/intake-import-poll.test.ts
@@ -12,8 +12,8 @@ describe("waitForMedicationIntakeImport", () => {
status: "done",
result: {
imported: 3,
- skippedDuplicates: 1,
- skippedInvalid: 0,
+ skipped: 1,
+ skipReasons: [{ reason: "already_recorded", count: 1 }],
},
});
const wait = vi.fn().mockResolvedValue(undefined);
@@ -25,8 +25,8 @@ describe("waitForMedicationIntakeImport", () => {
}),
).resolves.toEqual({
imported: 3,
- skippedDuplicates: 1,
- skippedInvalid: 0,
+ skipped: 1,
+ skipReasons: [{ reason: "already_recorded", count: 1 }],
});
expect(readStatus).toHaveBeenCalledTimes(3);
expect(wait).toHaveBeenCalledTimes(2);
diff --git a/src/lib/medications/intake-import-payload.ts b/src/lib/medications/intake-import-payload.ts
new file mode 100644
index 000000000..27d085df5
--- /dev/null
+++ b/src/lib/medications/intake-import-payload.ts
@@ -0,0 +1,42 @@
+/**
+ * The one derivation from a submitted intake-import row to the queued entry.
+ *
+ * It lives here rather than inline in the route so the test that proves a
+ * reported export lands 28 rows can drive the real derivation instead of
+ * restating it. A test that mirrors the production formula proves the mirror.
+ */
+
+/** A validated row of the import body: a local date and a local wall time. */
+export interface MedicationImportRow {
+ datum: string;
+ uhrzeit: string;
+}
+
+export interface MedicationImportQueueEntry {
+ takenAt: string;
+ idempotencyKey: string;
+}
+
+/**
+ * An imported dose is identified by when it was taken, and by nothing else.
+ *
+ * The key used to be built from the row's optional `zaehler` field whenever it
+ * was present. That reads as a per-row counter, but nothing required it to be
+ * one, and an export that put the dose quantity there — 1 tablet, on every row
+ * — collapsed a month of distinct doses onto a single key. Deriving from the
+ * instant makes the key a function of the fact it identifies, and matches the
+ * live-row unique on `(user_id, medication_id, scheduled_for, source)` that the
+ * database enforces regardless.
+ */
+export function buildMedicationImportEntries(
+ medicationId: string,
+ rows: readonly MedicationImportRow[],
+): MedicationImportQueueEntry[] {
+ return rows.map((row) => {
+ const takenAt = new Date(`${row.datum}T${row.uhrzeit}`);
+ return {
+ takenAt: takenAt.toISOString(),
+ idempotencyKey: `import-${medicationId}-${takenAt.getTime()}`,
+ };
+ });
+}
diff --git a/src/lib/medications/intake-import-poll.ts b/src/lib/medications/intake-import-poll.ts
index 8e28fcfa1..6e52f3e67 100644
--- a/src/lib/medications/intake-import-poll.ts
+++ b/src/lib/medications/intake-import-poll.ts
@@ -2,8 +2,9 @@ import { apiGet } from "@/lib/api/api-fetch";
export interface MedicationIntakeImportResult {
imported: number;
- skippedDuplicates: number;
- skippedInvalid: number;
+ skipped: number;
+ /** One entry per reason with its count — never the same line per row. */
+ skipReasons: Array<{ reason: string; count: number }>;
}
interface MedicationIntakeImportStatus {
diff --git a/tests/integration/job-failures.test.ts b/tests/integration/job-failures.test.ts
new file mode 100644
index 000000000..18a6f6812
--- /dev/null
+++ b/tests/integration/job-failures.test.ts
@@ -0,0 +1,151 @@
+/**
+ * #646 — a broken background job says its own name.
+ *
+ * The environment fetch threw on every run for the whole life of the module.
+ * It was logged and counted, and neither reached a screen: `recordError()`
+ * increments one unnamed integer, and the worker log only exists where someone
+ * is tailing the container. The queue held the answer the entire time.
+ *
+ * These readers query `pgboss.job` directly, so the only test worth having is
+ * one against a schema pg-boss itself created. A hand-written `CREATE TABLE`
+ * would prove the query matches the table the test wrote, which is exactly the
+ * mistake being fixed. So pg-boss provisions its own schema here and the jobs
+ * are failed through its own API.
+ */
+import { PgBoss } from "pg-boss";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+import {
+ readFailingQueues,
+ readQueueFailureForUser,
+} from "@/lib/jobs/job-failures";
+
+import { getPrismaClient } from "./setup";
+
+const QUEUE = "environment-fetch";
+const OTHER_QUEUE = "reminder-check";
+
+let boss: PgBoss;
+
+/** Send a job, take it, and fail it terminally so it lands in `state='failed'`. */
+async function failOneJob(queue: string, data: object, error: string) {
+ const jobId = await boss.send(queue, data, { retryLimit: 0 });
+ if (!jobId) throw new Error("queue rejected the job");
+ const [job] = await boss.fetch(queue);
+ if (!job) throw new Error("nothing to fetch");
+ await boss.fail(queue, job.id, new Error(error));
+ return jobId;
+}
+
+beforeAll(async () => {
+ boss = new PgBoss({
+ connectionString: process.env.DATABASE_URL,
+ // No maintenance or monitoring timers — the test drives every transition.
+ supervise: false,
+ schedule: false,
+ });
+ await boss.start();
+ await boss.createQueue(QUEUE);
+ await boss.createQueue(OTHER_QUEUE);
+}, 60_000);
+
+afterAll(async () => {
+ await boss?.stop({ graceful: false, close: true });
+ await getPrismaClient().$executeRawUnsafe(
+ `DROP SCHEMA IF EXISTS pgboss CASCADE`,
+ );
+});
+
+describe("readFailingQueues", () => {
+ it("names the queue, counts the failures, and carries the last error", async () => {
+ await failOneJob(
+ QUEUE,
+ { userId: "user-a" },
+ 'type "public.EnvironmentLocationSource" does not exist',
+ );
+ await failOneJob(QUEUE, { userId: "user-b" }, "upstream feed unavailable");
+ await failOneJob(OTHER_QUEUE, {}, "reminder dispatch failed");
+
+ const failing = await readFailingQueues();
+ expect(failing).not.toBeNull();
+
+ const environment = failing?.find((entry) => entry.queue === QUEUE);
+ expect(environment?.failures).toBe(2);
+ expect(environment?.lastError).toBe("upstream feed unavailable");
+ expect(Number.isFinite(Date.parse(environment?.lastFailedAt ?? ""))).toBe(
+ true,
+ );
+
+ const other = failing?.find((entry) => entry.queue === OTHER_QUEUE);
+ expect(other?.failures).toBe(1);
+ expect(other?.lastError).toBe("reminder dispatch failed");
+ });
+
+ it("reports an empty list — not null — when nothing is failing", async () => {
+ await getPrismaClient().$executeRawUnsafe(
+ `DELETE FROM pgboss.job WHERE state = 'failed'`,
+ );
+ await expect(readFailingQueues()).resolves.toEqual([]);
+ });
+
+ it("ignores a failure older than the window", async () => {
+ await failOneJob(QUEUE, { userId: "user-a" }, "old failure");
+ await getPrismaClient().$executeRawUnsafe(
+ `UPDATE pgboss.job SET completed_on = now() - interval '10 days' WHERE state = 'failed'`,
+ );
+ await expect(readFailingQueues(72)).resolves.toEqual([]);
+ });
+});
+
+describe("readQueueFailureForUser", () => {
+ it("matches on the userId the job payload carries", async () => {
+ await getPrismaClient().$executeRawUnsafe(
+ `DELETE FROM pgboss.job WHERE state = 'failed'`,
+ );
+ await failOneJob(QUEUE, { userId: "user-a" }, "first");
+ await failOneJob(QUEUE, { userId: "user-a" }, "second");
+ await failOneJob(QUEUE, { userId: "user-b" }, "someone else");
+
+ const mine = await readQueueFailureForUser(QUEUE, "user-a");
+ expect(mine?.failures).toBe(2);
+ expect(Number.isFinite(Date.parse(mine?.lastFailedAt ?? ""))).toBe(true);
+
+ // No error text on this side — the message is written for an operator.
+ expect(Object.keys(mine ?? {}).sort()).toEqual([
+ "failures",
+ "lastFailedAt",
+ ]);
+ });
+
+ it("answers null for an account whose jobs did not fail", async () => {
+ await expect(
+ readQueueFailureForUser(QUEUE, "user-with-no-failures"),
+ ).resolves.toBeNull();
+ });
+
+ it("does not attribute another queue's failure to this one", async () => {
+ await getPrismaClient().$executeRawUnsafe(
+ `DELETE FROM pgboss.job WHERE state = 'failed'`,
+ );
+ await failOneJob(OTHER_QUEUE, { userId: "user-a" }, "reminder failed");
+ await expect(readQueueFailureForUser(QUEUE, "user-a")).resolves.toBeNull();
+ });
+});
+
+describe("no queue schema at all", () => {
+ it("answers null rather than throwing, so the status page still renders", async () => {
+ const prisma = getPrismaClient();
+ await boss.stop({ graceful: false, close: true });
+ await prisma.$executeRawUnsafe(`ALTER SCHEMA pgboss RENAME TO pgboss_gone`);
+ try {
+ await expect(readFailingQueues()).resolves.toBeNull();
+ await expect(
+ readQueueFailureForUser(QUEUE, "user-a"),
+ ).resolves.toBeNull();
+ } finally {
+ await prisma.$executeRawUnsafe(
+ `ALTER SCHEMA pgboss_gone RENAME TO pgboss`,
+ );
+ }
+ });
+});
diff --git a/tests/integration/medication-intake-import-job.test.ts b/tests/integration/medication-intake-import-job.test.ts
index 0ab134115..645975b07 100644
--- a/tests/integration/medication-intake-import-job.test.ts
+++ b/tests/integration/medication-intake-import-job.test.ts
@@ -82,7 +82,7 @@ describe("medication intake import job — concurrent retry", () => {
processed: 0,
total: payload.entries.length,
imported: 0,
- skippedDuplicates: 0,
+ skippedByReason: {},
touchedDays: [],
rollupProcessed: 0,
};
@@ -150,16 +150,19 @@ describe("medication intake import job — concurrent retry", () => {
{ day: "2026-07-21", scheduled: 1, taken: 1 },
]);
expect(refreshedJob.status).toBe("done");
+ // The two entries sharing an instant collapse inside the submission; that
+ // is `duplicate_in_file`, and it is reported under its own name rather
+ // than as an undifferentiated "duplicate".
expect(refreshedJob.result).toEqual({
imported: 3,
- skippedDuplicates: 1,
- skippedInvalid: 0,
+ skipped: 1,
+ skipReasons: [{ reason: "duplicate_in_file", count: 1 }],
});
expect(refreshedJob.progress).toEqual({
processed: 4,
total: 4,
imported: 3,
- skippedDuplicates: 1,
+ skippedByReason: { duplicate_in_file: 1 },
touchedDays: ["2026-07-20", "2026-07-21"],
rollupProcessed: 2,
});
@@ -198,7 +201,7 @@ describe("medication intake import job — concurrent retry", () => {
processed: 0,
total: 1,
imported: 0,
- skippedDuplicates: 0,
+ skippedByReason: {},
touchedDays: [],
rollupProcessed: 0,
};
diff --git a/tests/integration/medication-intake-import-reported-export.test.ts b/tests/integration/medication-intake-import-reported-export.test.ts
new file mode 100644
index 000000000..67ccb39a6
--- /dev/null
+++ b/tests/integration/medication-intake-import-reported-export.test.ts
@@ -0,0 +1,239 @@
+/**
+ * #650 — the reported export, from the request body to the rows on the ledger.
+ *
+ * A self-hoster attached a 28-dose file: one intake per day for four weeks, all
+ * at 08:30, with `"zaehler": 1.0` on every row. The route accepted it, answered
+ * 202, and one intake landed. The other 27 were reported back as duplicates —
+ * of each other, because the replay key was built from `zaehler` and every row
+ * carried the same value.
+ *
+ * A mocked Prisma cannot show this: the collapse is half in the key derivation
+ * and half in two database uniques (`(user_id, idempotency_key)` and the
+ * live-row slot unique). So the real file goes through the real route into a
+ * real Postgres here, and the assertion is the count of rows that exist
+ * afterwards.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { afterAll, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { getPrismaClient, truncateAllTables } from "./setup";
+import {
+ _setMedicationIntakeImportPrismaForTests,
+ processMedicationIntakeImportJob,
+} from "@/lib/jobs/medication-intake-import";
+import { buildMedicationImportEntries } from "@/lib/medications/intake-import-payload";
+import { toJson } from "@/lib/db";
+
+vi.mock("@/lib/cache/invalidate", () => ({
+ invalidateUserMedications: vi.fn(),
+}));
+vi.mock("@/lib/notifications/medication-intake-sync", () => ({
+ queueMedicationIntakeSync: vi.fn(),
+}));
+
+/** The file attached to the report, byte for byte. */
+const REPORTED_EXPORT = JSON.parse(
+ readFileSync(
+ join(
+ __dirname,
+ "..",
+ "..",
+ "src/app/api/medications/[id]/intake/import/__tests__/fixtures/reported-intake-export.json",
+ ),
+ "utf8",
+ ),
+) as Array<{ datum: string; uhrzeit: string; zaehler: number }>;
+
+beforeEach(async () => {
+ const prisma = getPrismaClient();
+ await truncateAllTables(prisma);
+ _setMedicationIntakeImportPrismaForTests(prisma);
+ vi.clearAllMocks();
+});
+
+afterAll(() => {
+ _setMedicationIntakeImportPrismaForTests(null);
+});
+
+async function seedMedication() {
+ const prisma = getPrismaClient();
+ const user = await prisma.user.create({
+ data: {
+ username: "reported-export",
+ email: "reported-export@example.test",
+ role: "USER",
+ timezone: "Europe/Berlin",
+ },
+ });
+ const medication = await prisma.medication.create({
+ data: {
+ userId: user.id,
+ name: "Reported medication",
+ dose: "1 tablet",
+ unitsPerDose: 1,
+ },
+ });
+ return { user, medication };
+}
+
+/** The route's own derivation, so the fix is what is under test — not a mirror. */
+function normalise(medicationId: string) {
+ return {
+ entries: buildMedicationImportEntries(medicationId, REPORTED_EXPORT),
+ };
+}
+
+describe("medication intake import — the reported 28-dose export", () => {
+ it("writes one row per dose instead of one row for the whole file", async () => {
+ const prisma = getPrismaClient();
+ const { user, medication } = await seedMedication();
+ const payload = normalise(medication.id);
+
+ const job = await prisma.medicationIntakeImportJob.create({
+ data: {
+ userId: user.id,
+ medicationId: medication.id,
+ payload: toJson(payload),
+ progress: toJson({
+ processed: 0,
+ total: payload.entries.length,
+ imported: 0,
+ skippedByReason: {},
+ touchedDays: [],
+ rollupProcessed: 0,
+ }),
+ },
+ });
+
+ const result = await processMedicationIntakeImportJob(job.id);
+
+ expect(result).toEqual({ imported: 28, skipped: 0, skipReasons: [] });
+
+ const events = await prisma.medicationIntakeEvent.findMany({
+ where: { userId: user.id, medicationId: medication.id },
+ orderBy: { takenAt: "asc" },
+ select: { takenAt: true, source: true, idempotencyKey: true },
+ });
+ expect(events).toHaveLength(28);
+ expect(new Set(events.map((event) => event.idempotencyKey)).size).toBe(28);
+ expect(events.every((event) => event.source === "IMPORT")).toBe(true);
+ // Every submitted day is on the ledger — the point of the whole import.
+ expect(
+ events.map((event) => event.takenAt?.toISOString().slice(0, 10)),
+ ).toEqual(REPORTED_EXPORT.map((row) => row.datum));
+ });
+
+ it("re-importing the same file adds nothing and says why", async () => {
+ const prisma = getPrismaClient();
+ const { user, medication } = await seedMedication();
+ const payload = normalise(medication.id);
+ const progress = {
+ processed: 0,
+ total: payload.entries.length,
+ imported: 0,
+ skippedByReason: {},
+ touchedDays: [],
+ rollupProcessed: 0,
+ };
+
+ const first = await prisma.medicationIntakeImportJob.create({
+ data: {
+ userId: user.id,
+ medicationId: medication.id,
+ payload: toJson(payload),
+ progress: toJson(progress),
+ },
+ });
+ await processMedicationIntakeImportJob(first.id);
+
+ const second = await prisma.medicationIntakeImportJob.create({
+ data: {
+ userId: user.id,
+ medicationId: medication.id,
+ payload: toJson(payload),
+ progress: toJson(progress),
+ },
+ });
+ const result = await processMedicationIntakeImportJob(second.id);
+
+ expect(result).toEqual({
+ imported: 0,
+ skipped: 28,
+ skipReasons: [{ reason: "already_recorded", count: 28 }],
+ });
+ await expect(
+ prisma.medicationIntakeEvent.count({
+ where: { userId: user.id, medicationId: medication.id },
+ }),
+ ).resolves.toBe(28);
+ });
+
+ it("counts a within-file collision apart from an already-recorded dose", async () => {
+ const prisma = getPrismaClient();
+ const { user, medication } = await seedMedication();
+
+ // One dose already on the ledger, from any surface at all.
+ const existing = new Date("2026-05-31T08:30:00");
+ await prisma.medicationIntakeEvent.create({
+ data: {
+ userId: user.id,
+ medicationId: medication.id,
+ scheduledFor: existing,
+ takenAt: existing,
+ source: "IMPORT",
+ idempotencyKey: `import-${medication.id}-${existing.getTime()}`,
+ },
+ });
+
+ // A submission that repeats one of its own rows AND repeats that dose.
+ const duplicated = new Date("2026-06-05T08:30:00");
+ const entries = [
+ {
+ takenAt: existing.toISOString(),
+ idempotencyKey: `import-${medication.id}-${existing.getTime()}`,
+ },
+ {
+ takenAt: duplicated.toISOString(),
+ idempotencyKey: `import-${medication.id}-${duplicated.getTime()}`,
+ },
+ {
+ takenAt: duplicated.toISOString(),
+ idempotencyKey: `import-${medication.id}-${duplicated.getTime()}`,
+ },
+ ];
+
+ const job = await prisma.medicationIntakeImportJob.create({
+ data: {
+ userId: user.id,
+ medicationId: medication.id,
+ payload: toJson({ entries }),
+ progress: toJson({
+ processed: 0,
+ total: entries.length,
+ imported: 0,
+ skippedByReason: {},
+ touchedDays: [],
+ rollupProcessed: 0,
+ }),
+ },
+ });
+
+ const result = await processMedicationIntakeImportJob(job.id);
+
+ expect(result).toEqual({
+ imported: 1,
+ skipped: 2,
+ skipReasons: [
+ { reason: "already_recorded", count: 1 },
+ { reason: "duplicate_in_file", count: 1 },
+ ],
+ });
+ await expect(
+ prisma.medicationIntakeEvent.count({
+ where: { userId: user.id, medicationId: medication.id },
+ }),
+ ).resolves.toBe(2);
+ });
+});