chore(release): v1.4.45 — analytics 9 s perf fix + audit-marathon closure + v1.4.44 hotfix merged

Audit-marathon close: 14 waves + W10 QA + reconcile. Perf fix (analytics 9 s -> 2-3 s), Zod multi-issue rollout (41 routes), Withings parked-state automation, mobile-UI WCAG 2.5.5 close, QoL i18n + offline banner + account delete, security PII drop + replay-injection scan. Migration 0075 required. Tests 4815 -> 5076.
This commit is contained in:
Marc-André Bombeck authored and GitHub committed 2026-05-21 23:13:21 +02:00
1 parent 324d4bb411
commit 6c7fc7dc84
167 files changed
+11233 -371

No files matched your search

+308 -1
View File
@@ -46,6 +46,7 @@ import {
markReconnected,
isReauthRequired,
getPersistentFailureThreshold,
resumeIntegrationFromPark,
} from "../status";
import { prisma } from "@/lib/db";
import { auditLog } from "@/lib/auth/audit";
@@ -95,6 +96,14 @@ describe("recordSyncSuccess", () => {
lastAttemptAt: expect.any(Date),
lastError: null,
consecutiveFailures: 0,
// v1.4.43 W14 — success clears every per-kind bucket too so
// the next failure starts from zero in its own bucket.
consecutiveFailuresByKind: {
transient: 0,
reauth_required: 0,
persistent: 0,
},
persistentFailureStartedAt: null,
alertedAt: null,
});
});
@@ -359,12 +368,24 @@ describe("recordSyncFailure — admin Telegram skipped silently when no admins",
});
describe("isReauthRequired", () => {
it("returns true only when state === error_reauth", async () => {
it("returns true when state === error_reauth", async () => {
vi.mocked(prisma.integrationStatus.findUnique).mockResolvedValueOnce({
state: "error_reauth",
} as never);
expect(await isReauthRequired("u1", "withings")).toBe(true);
});
it("returns true when state === parked (v1.4.43 W14)", async () => {
// A parked integration must short-circuit the sync entry-point
// the same way a reauth-required one does — neither will succeed
// without user / operator action.
vi.mocked(prisma.integrationStatus.findUnique).mockResolvedValueOnce({
state: "parked",
} as never);
expect(await isReauthRequired("u1", "withings")).toBe(true);
});
it("returns false for transient errors and absent rows", async () => {
vi.mocked(prisma.integrationStatus.findUnique).mockResolvedValueOnce({
state: "error_transient",
} as never);
@@ -398,6 +419,13 @@ describe("markReauthRequired / markDisconnected / markReconnected", () => {
state: "disconnected",
lastError: null,
consecutiveFailures: 0,
// v1.4.43 W14 — disconnect must clear the per-kind buckets too.
consecutiveFailuresByKind: {
transient: 0,
reauth_required: 0,
persistent: 0,
},
persistentFailureStartedAt: null,
alertedAt: null,
});
});
@@ -412,7 +440,286 @@ describe("markReauthRequired / markDisconnected / markReconnected", () => {
state: "connected",
lastError: null,
consecutiveFailures: 0,
// v1.4.43 W14 — reconnect clears the per-kind buckets so the
// next sync starts on a clean slate.
consecutiveFailuresByKind: {
transient: 0,
reauth_required: 0,
persistent: 0,
},
persistentFailureStartedAt: null,
alertedAt: null,
});
});
});
// ── v1.4.43 W14 — per-kind buckets + 24h park behaviour ────────────────
//
// The four pins below lock in the B4 + B7 contract:
//
// 1. A persistent failure increments ONLY the persistent bucket;
// an intervening transient failure does NOT reset the persistent
// streak.
// 2. The persistent-streak start timestamp is stamped on the FIRST
// persistent failure of a streak and preserved across subsequent
// persistent failures.
// 3. Once the persistent streak has been running for >24h, the state
// flips to `parked` and an `integrations.parked` audit row is
// written.
// 4. `resumeIntegrationFromPark` clears state back to `connected`,
// zeroes every bucket, and writes an `integrations.resumed` audit
// row (only when the row was actually parked — idempotent for
// non-parked inputs).
describe("recordSyncFailure — v1.4.43 W14 per-kind buckets", () => {
it("increments ONLY the matching bucket on each failure", async () => {
// Existing row: transient bucket already at 2 from earlier hiccups.
vi.mocked(prisma.integrationStatus.findUnique).mockResolvedValueOnce({
consecutiveFailures: 2,
consecutiveFailuresByKind: {
transient: 2,
reauth_required: 0,
persistent: 0,
},
persistentFailureStartedAt: null,
alertedAt: null,
} as never);
vi.mocked(prisma.integrationStatus.upsert).mockResolvedValueOnce({
consecutiveFailures: 3,
alertedAt: null,
} as never);
await recordSyncFailure({
userId: "u1",
integration: "withings",
kind: "persistent",
message: "Withings measure error: 293 - invalid params",
errorCode: "293",
});
const upsertArgs = vi.mocked(prisma.integrationStatus.upsert).mock
.calls[0][0];
// transient stays at 2 (unchanged), persistent ticks to 1,
// reauth_required stays at 0.
expect(upsertArgs.update.consecutiveFailuresByKind).toEqual({
transient: 2,
reauth_required: 0,
persistent: 1,
});
// First-ever persistent failure stamps the streak anchor.
expect(upsertArgs.update.persistentFailureStartedAt).toBeInstanceOf(Date);
});
it("preserves persistentFailureStartedAt across multiple persistent failures", async () => {
const streakStart = new Date(Date.now() - 60 * 60 * 1000); // 1h ago
vi.mocked(prisma.integrationStatus.findUnique).mockResolvedValueOnce({
consecutiveFailures: 5,
consecutiveFailuresByKind: {
transient: 0,
reauth_required: 0,
persistent: 5,
},
persistentFailureStartedAt: streakStart,
alertedAt: new Date(Date.now() - 30 * 60 * 1000), // already alerted
} as never);
vi.mocked(prisma.integrationStatus.upsert).mockResolvedValueOnce({
consecutiveFailures: 6,
alertedAt: new Date(Date.now() - 30 * 60 * 1000),
} as never);
await recordSyncFailure({
userId: "u1",
integration: "withings",
kind: "persistent",
message: "Withings measure error: 293",
errorCode: "293",
});
const upsertArgs = vi.mocked(prisma.integrationStatus.upsert).mock
.calls[0][0];
// The anchor is preserved exactly — that's the whole point of
// tracking the streak start instead of recomputing it from
// updated_at.
expect(upsertArgs.update.persistentFailureStartedAt).toBe(streakStart);
expect(upsertArgs.update.state).toBe("error_transient"); // < 24h still
expect(upsertArgs.update.consecutiveFailuresByKind).toEqual({
transient: 0,
reauth_required: 0,
persistent: 6,
});
});
it("a transient failure does NOT reset the persistent bucket nor the streak anchor", async () => {
const streakStart = new Date(Date.now() - 6 * 60 * 60 * 1000); // 6h ago
vi.mocked(prisma.integrationStatus.findUnique).mockResolvedValueOnce({
consecutiveFailures: 4,
consecutiveFailuresByKind: {
transient: 0,
reauth_required: 0,
persistent: 4,
},
persistentFailureStartedAt: streakStart,
alertedAt: null,
} as never);
vi.mocked(prisma.integrationStatus.upsert).mockResolvedValueOnce({
consecutiveFailures: 5,
alertedAt: null,
} as never);
await recordSyncFailure({
userId: "u1",
integration: "withings",
kind: "transient",
message: "Withings refresh error: 503",
errorCode: "503",
});
const upsertArgs = vi.mocked(prisma.integrationStatus.upsert).mock
.calls[0][0];
// Persistent bucket UNCHANGED — this is the v1.4.43 W14 fix.
// Under the legacy single-counter behaviour the burst above would
// have shown as "5 consecutive failures, state=error_transient"
// and the persistent streak's age would have been masked.
expect(upsertArgs.update.consecutiveFailuresByKind).toEqual({
transient: 1,
reauth_required: 0,
persistent: 4,
});
expect(upsertArgs.update.persistentFailureStartedAt).toBe(streakStart);
});
it("flips state to `parked` and writes an audit row once persistent streak > 24h", async () => {
const streakStart = new Date(Date.now() - 25 * 60 * 60 * 1000); // 25h ago
vi.mocked(prisma.integrationStatus.findUnique).mockResolvedValueOnce({
consecutiveFailures: 30,
consecutiveFailuresByKind: {
transient: 0,
reauth_required: 0,
persistent: 30,
},
persistentFailureStartedAt: streakStart,
alertedAt: new Date(Date.now() - 23 * 60 * 60 * 1000),
} as never);
vi.mocked(prisma.integrationStatus.upsert).mockResolvedValueOnce({
consecutiveFailures: 31,
alertedAt: new Date(Date.now() - 23 * 60 * 60 * 1000),
} as never);
await recordSyncFailure({
userId: "u1",
integration: "withings",
kind: "persistent",
message: "Withings measure error: 293",
errorCode: "293",
});
const upsertArgs = vi.mocked(prisma.integrationStatus.upsert).mock
.calls[0][0];
expect(upsertArgs.update.state).toBe("parked");
expect(auditLog).toHaveBeenCalledWith(
"integrations.parked",
expect.objectContaining({
userId: "u1",
details: expect.objectContaining({
integration: "withings",
reason: "persistent_24h",
persistentFailureStartedAt: streakStart.toISOString(),
}),
}),
);
});
it("back-fills the bucket from the legacy single counter on a pre-migration row", async () => {
// Legacy row: counter is 3, no bucket JSON yet (predates 0075).
vi.mocked(prisma.integrationStatus.findUnique).mockResolvedValueOnce({
consecutiveFailures: 3,
consecutiveFailuresByKind: null,
persistentFailureStartedAt: null,
alertedAt: null,
} as never);
vi.mocked(prisma.integrationStatus.upsert).mockResolvedValueOnce({
consecutiveFailures: 4,
alertedAt: null,
} as never);
vi.mocked(prisma.user.findUnique).mockResolvedValueOnce({
email: "u@example.com",
} as never);
vi.mocked(prisma.user.findMany).mockResolvedValueOnce([] as never);
vi.mocked(prisma.integrationStatus.update).mockResolvedValueOnce(
{} as never,
);
await recordSyncFailure({
userId: "u1",
integration: "withings",
kind: "reauth_required",
message: "Withings refresh error: 100 - invalid_grant",
errorCode: "100",
});
const upsertArgs = vi.mocked(prisma.integrationStatus.upsert).mock
.calls[0][0];
// The 3 legacy failures get bucketed into the CURRENT failure's
// kind (reauth_required) — that's the kind the row was last
// tagged with, and back-filling into a different kind would
// under-count the existing streak. v1.4.43 W10 senior-dev M-1 —
// the back-fill branch additionally increments the bucket so the
// post-write bucket count matches the legacy column's post-write
// value (legacy: 3 → 4, bucket: 0 → 3 → 4).
expect(upsertArgs.update.consecutiveFailuresByKind).toEqual({
transient: 0,
reauth_required: 4,
persistent: 0,
});
});
});
describe("resumeIntegrationFromPark", () => {
it("clears a parked row back to connected with all buckets zeroed", async () => {
vi.mocked(prisma.integrationStatus.findUnique).mockResolvedValueOnce({
state: "parked",
} as never);
vi.mocked(prisma.integrationStatus.upsert).mockResolvedValueOnce(
{} as never,
);
const result = await resumeIntegrationFromPark("u1", "withings");
expect(result.wasParked).toBe(true);
const upsertArgs = vi.mocked(prisma.integrationStatus.upsert).mock
.calls[0][0];
expect(upsertArgs.update).toEqual({
state: "connected",
lastError: null,
consecutiveFailures: 0,
consecutiveFailuresByKind: {
transient: 0,
reauth_required: 0,
persistent: 0,
},
persistentFailureStartedAt: null,
alertedAt: null,
});
expect(auditLog).toHaveBeenCalledWith(
"integrations.resumed",
expect.objectContaining({
userId: "u1",
details: expect.objectContaining({ integration: "withings" }),
}),
);
});
it("is idempotent — calling against a non-parked row does NOT write an audit row", async () => {
vi.mocked(prisma.integrationStatus.findUnique).mockResolvedValueOnce({
state: "connected",
} as never);
vi.mocked(prisma.integrationStatus.upsert).mockResolvedValueOnce(
{} as never,
);
const result = await resumeIntegrationFromPark("u1", "withings");
expect(result.wasParked).toBe(false);
expect(auditLog).not.toHaveBeenCalled();
});
});