reconcile: fold in the outstanding hardening and data-integrity fixes

Merge the eight reviewed audit fixes that were cut a week ago and never
landed. Main has moved on since, so each fix was re-checked against the
current tree and each of the five conflicts resolved by understanding
both sides.

Kept, still open on main:
- Proxy early exits now carry the transport security header subset via a
  shared helper. Reconciled with main's /api/health worker-only carve-out.
- Batch measurement ingest bounds the entry instant so a future-dated row
  can no longer win "latest reading" or poison the rollup buckets.
- Web Push dials through the pinned safeFetch dispatcher with
  requirePublicHost, closing the last user-controlled-host egress.
- Mood bulk upsert and its tag/factor links run in one transaction, so a
  rejected rating rolls the mood row back instead of leaving a tagless row.
- Full backup carries NutrientIntakeDay with its unit and source. Folded
  into main's portable-export / disaster-recovery split.
- Live daily-series fallback restores the min/max spread band the tiered
  read already emitted.
- Coach stream aborts its in-flight reader on unmount and resets send state
  on a conversation switch.
- Manual water writes share the day-bound helper, nutrient add clamps after
  the increment, and the thiamin cap drops to a real supplement ceiling.
- Compliance point window widens symmetrically instead of wrapping overnight.
- Oura, Polar and Fitbit token helpers classify an empty or non-JSON 2xx
  body as a handled transient error.
- WebAuthn relying-party fallback to localhost is gated to development.
- Chart-token strip list is derived from the allowlist and pinned by a test.
- Regression tests pin the snapshot-cache tenant key, the GlitchTip
  path-secret redaction and the Withings credentials delete.

Superseded by main, tests re-pointed at the current shape:
- The intake CSV import was rewritten on main to run through a background
  job with a single-active-job admission gate. The future-date bound is
  re-applied at request validation and the per-user limiter is kept for
  parity with the bulk twin; the old synchronous-write test is replaced.
This commit is contained in:
Marc-André Bombeck committed 2026-07-23 17:15:21 +02:00
commit b1e36d9fb0
51 files changed
+2066 -228

No files matched your search

@@ -0,0 +1,202 @@
/**
* `POST /api/measurements/batch` — entry-instant plausibility bound.
*
* The single-entry twin has applied `validateEntryInstant` to `measuredAt`
* since v1.17 W1b; the 500-entry batch path did not, so a future-dated row
* landed and permanently won "latest reading" on every dashboard while
* poisoning the rollup buckets and the canonical picker.
*
* The past floor deliberately stays at 1900: a historical Apple Health
* backfill is a legitimate shape on this route. Only the future side is a bug.
*/
import { describe, expect, it, vi, beforeEach } from "vitest";
import { NextRequest } from "next/server";
vi.mock("@/lib/db", () => ({
prisma: {
user: { update: vi.fn() },
measurement: {
findMany: vi.fn(),
createManyAndReturn: vi.fn(),
updateMany: vi.fn(),
},
$transaction: vi.fn(async (fn: unknown) => {
if (typeof fn === "function") {
return (fn as (tx: unknown) => unknown)(prisma);
}
}),
},
}));
// Main routes every ingested row through `reconcileExternalMeasurement`; the
// plausibility guard runs BEFORE that call, so a valid entry only needs the
// reconcile to report a non-skip status for the assertion to hold.
vi.mock("@/lib/measurements/reconcile-external-measurement", () => ({
reconcileExternalMeasurement: vi.fn(
async (_tx: unknown, input: Record<string, unknown>) => ({
status: "inserted",
row: { id: "row-1", ...input },
}),
),
}));
vi.mock("@/lib/auth/session", () => ({ getSession: vi.fn() }));
vi.mock("@/lib/auth/audit", () => ({
auditLog: vi.fn().mockResolvedValue(undefined),
}));
vi.mock("@/lib/logging/transports", () => ({ emitIfSampled: vi.fn() }));
vi.mock("@/lib/db-compat", () => ({
ensureDbCompatibility: vi.fn().mockResolvedValue(undefined),
}));
vi.mock("@/lib/rate-limit", () => ({
checkRateLimit: vi.fn(),
}));
vi.mock("@/lib/jobs/pr-detection", () => ({
enqueuePrDetection: vi.fn().mockResolvedValue(undefined),
}));
vi.mock("@/lib/jobs/reminder-satisfy", () => ({
enqueueReminderSatisfy: vi.fn().mockResolvedValue(undefined),
}));
vi.mock("@/lib/cache/invalidate", () => ({
invalidateUserMeasurements: vi.fn(),
}));
vi.mock("@/lib/insights/comprehensive-generate", () => ({
invalidateStatusInsightsForTypes: vi.fn().mockResolvedValue(undefined),
}));
vi.mock("@/lib/rollups/measurement-rollups", () => ({
recomputeBucketsForMeasurement: vi.fn().mockResolvedValue(undefined),
collapseToTypeDayKeys: vi.fn(() => []),
}));
vi.mock("@/lib/daily/morning-refresh-trigger", () => ({
maybeEnqueueMorningRefresh: vi.fn().mockResolvedValue(undefined),
}));
vi.mock("@/lib/arrivals/emit-shared", () => ({
emitDataArrival: vi.fn().mockResolvedValue(undefined),
}));
vi.mock("next/headers", () => ({
headers: vi.fn(async () => ({ get: () => null })),
cookies: vi.fn(async () => ({
get: () => undefined,
set: () => {},
delete: () => {},
})),
}));
import { POST } from "../route";
import { prisma } from "@/lib/db";
import { getSession } from "@/lib/auth/session";
import { checkRateLimit } from "@/lib/rate-limit";
const SESSION_OK = {
session: { id: "sess-1", expiresAt: new Date(Date.now() + 3_600_000) },
user: { id: "user-1", username: "testuser", role: "USER" as const },
};
function makeRequest(body: unknown): NextRequest {
return new NextRequest("http://localhost/api/measurements/batch", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify(body),
});
}
/** A step entry anchored on an offset from now, so the test never date-bombs. */
function stepEntryAt(externalId: string, startMs: number, endMs = startMs) {
return {
hkIdentifier: "HKQuantityTypeIdentifierStepCount",
value: 1200,
unit: "count",
startDate: new Date(startMs).toISOString(),
endDate: new Date(endMs).toISOString(),
externalId,
};
}
const DAY_MS = 24 * 60 * 60 * 1000;
async function statusesFor(entries: unknown[]) {
const res = await POST(makeRequest({ entries }));
expect(res.status).toBe(200);
const body = (await res.json()) as {
data: {
entries: Array<{ index: number; status: string; reason?: string }>;
};
};
return body.data.entries;
}
beforeEach(() => {
// clearAllMocks (not resetAllMocks): the fire-and-forget post-processing
// mocks above carry `.mockResolvedValue` implementations that the route
// chains `.catch` onto; resetAllMocks would wipe those to bare `undefined`.
vi.clearAllMocks();
vi.mocked(getSession).mockResolvedValue(SESSION_OK as never);
vi.mocked(checkRateLimit).mockResolvedValue({
allowed: true,
remaining: 60,
resetAt: Date.now() + 60_000,
});
vi.mocked(prisma.measurement.findMany).mockResolvedValue([]);
vi.mocked(prisma.measurement.createManyAndReturn).mockResolvedValue([
{ id: "row-1" },
] as never);
vi.mocked(prisma.measurement.updateMany).mockResolvedValue({ count: 0 });
});
describe("POST /api/measurements/batch — entry-instant plausibility", () => {
it("skips a far-future entry instead of persisting it", async () => {
const results = await statusesFor([
stepEntryAt("ext-future", Date.now() + 365 * DAY_MS),
]);
expect(results[0]).toMatchObject({
index: 0,
status: "skipped",
reason: "implausible_timestamp",
});
});
it("skips an entry predating the 1900 floor", async () => {
const results = await statusesFor([
stepEntryAt("ext-ancient", Date.UTC(1899, 11, 31)),
]);
expect(results[0]).toMatchObject({
status: "skipped",
reason: "implausible_timestamp",
});
});
it("accepts a historical backfill entry — the past floor stays at 1900", async () => {
const results = await statusesFor([
stepEntryAt("ext-old", Date.now() - 8 * 365 * DAY_MS),
]);
expect(results[0]!.status).not.toBe("skipped");
});
it("tolerates a client clock a couple of minutes fast", async () => {
const results = await statusesFor([
stepEntryAt("ext-skew", Date.now() + 2 * 60 * 1000),
]);
expect(results[0]!.status).not.toBe("skipped");
});
it("skips only the offending entry and keeps the rest of the batch", async () => {
const results = await statusesFor([
stepEntryAt("ext-ok", Date.now() - DAY_MS),
stepEntryAt("ext-bad", Date.now() + 365 * DAY_MS),
]);
expect(results[0]!.status).not.toBe("skipped");
expect(results[1]).toMatchObject({ reason: "implausible_timestamp" });
});
});
+17
View File
@@ -61,6 +61,7 @@ import {
type MergeCandidate,
} from "@/lib/measurements/cross-source-merge";
import { reconcileExternalMeasurement } from "@/lib/measurements/reconcile-external-measurement";
import { isPlausibleEntryInstant } from "@/lib/validations/entry-instant";
import { validateMeasurementRange } from "@/lib/validations/measurement";
import { deviceTypeEnum } from "@/lib/validations/source-priority";
import { checkRateLimit } from "@/lib/rate-limit";
@@ -294,6 +295,22 @@ async function postBatch(request: NextRequest): Promise<Response> {
continue;
}
// Time-plausibility guard, the bound the single-entry twin already applies
// through `validateEntryInstant` on `createMeasurementSchema.measuredAt`.
// Without it a future-dated row permanently won "latest reading" on every
// dashboard and poisoned the rollup buckets and the canonical picker. The
// past floor stays at 1900 (no `maxAgeMs`) because a historical Apple
// Health backfill is a legitimate, expected shape on this route; only the
// future side is a bug. Skipped per entry, like the range guard above.
if (!isPlausibleEntryInstant(mapped.takenAt)) {
results[index] = {
index,
status: "skipped",
reason: "implausible_timestamp",
};
continue;
}
// v1.30.7 (iOS #34) — go-forward aggregated heart-rate wire
// contract. A `stats:HKQuantityTypeIdentifierHeartRate:<10-min-ISO-Z>`
// row is the 10-minute-average PULSE bucket; it rides the generic