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,96 @@
/**
* `DELETE /api/withings/credentials` — disconnect honesty.
*
* The handler deletes the connection row (holding the encrypted OAuth access +
* refresh tokens) before nulling the credential columns. That delete used to be
* `.catch(() => {})`: on a real failure the handler carried on, nulled the
* client id/secret, and returned `{ deleted: true }` while the token-bearing
* row survived — the user is told they are disconnected and they are not.
*
* It now narrows to P2025 ("already gone", a genuine no-op) and rethrows
* everything else. Withings had no test file at all, which is why this one
* exists; the WHOOP and Fitbit twins carry the same shape.
*/
import { describe, it, expect, vi, beforeEach } from "vitest";
vi.mock("@/lib/db", () => ({
prisma: {
withingsConnection: { delete: vi.fn() },
user: { update: vi.fn() },
},
}));
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("next/headers", () => ({
headers: vi.fn(async () => ({ get: () => null })),
cookies: vi.fn(async () => ({
get: () => undefined,
set: () => {},
delete: () => {},
})),
}));
import { DELETE } from "../route";
import { prisma } from "@/lib/db";
import { getSession } from "@/lib/auth/session";
const SESSION_OK = {
session: { id: "sess-1", expiresAt: new Date(Date.now() + 3_600_000) },
user: { id: "user-1", username: "tester", role: "USER" as const },
};
/** Shape of a Prisma "record to delete does not exist" rejection. */
function p2025() {
return Object.assign(new Error("Record to delete does not exist."), {
code: "P2025",
name: "PrismaClientKnownRequestError",
});
}
beforeEach(() => {
vi.resetAllMocks();
vi.mocked(getSession).mockResolvedValue(SESSION_OK as never);
vi.mocked(prisma.user.update).mockResolvedValue({} as never);
});
describe("DELETE /api/withings/credentials", () => {
it("disconnects and nulls the credential columns on the happy path", async () => {
vi.mocked(prisma.withingsConnection.delete).mockResolvedValue({} as never);
const res = await DELETE();
expect(res.status).toBe(200);
expect(prisma.user.update).toHaveBeenCalledWith(
expect.objectContaining({
data: {
withingsClientIdEncrypted: null,
withingsClientSecretEncrypted: null,
},
}),
);
});
it("treats an already-missing connection row (P2025) as a benign no-op", async () => {
vi.mocked(prisma.withingsConnection.delete).mockRejectedValue(p2025());
const res = await DELETE();
expect(res.status).toBe(200);
// Idempotent disconnect still clears the credentials.
expect(prisma.user.update).toHaveBeenCalled();
});
it("does NOT report success when the token-bearing row fails to delete", async () => {
vi.mocked(prisma.withingsConnection.delete).mockRejectedValue(
new Error("connection terminated unexpectedly"),
);
const res = await DELETE();
expect(res.status).toBe(500);
// Critically: the credentials must NOT be nulled, because doing so while
// the encrypted OAuth tokens survive is the worst of both states.
expect(prisma.user.update).not.toHaveBeenCalled();
});
});