mirror of
https://github.com/MBombeck/HealthLog.git
synced 2026-11-16 07:13:29 +00:00
Platform-wide hardening: the failure classes found live this week hunted down across every integration. Fitbit carried the same tombstone wedge fixed for Google — probe now matches soft-deleted rows and the update resurrects them; the comment describing a partial unique index that never existed is corrected. Sleep segment ids are stable across re-scoring for Withings (session+segment-start), WHOOP/Polar (one segment per stage, no positional index) and Oura (run-start keyed), each with a session-scoped sweep that soft-deletes rows a re-score orphaned — so legacy and affected nights heal as they are re-read. One platform rule for deleted rows: source-owned readings resurrect on re-import (Withings, WHOOP, Oura, Polar, Nightscout, mood webhook, CSV re-imports, Apple stats day-totals); Apple sample-grain deletions stick per the paired-client contract, and the mood bulk route's tombstone match is now a true no-op reported as duplicate. Import counts reconcile against actual createMany counts. Google lifecycle: a dead token registers on the cycle's hard-fail ledger, so an expired connection parks instead of stamping success hourly; backfill and sleep-repair markers stamp only after a clean pass (pg-boss retries are now real); failed measurement writes hold the watermark; no-op updates are skipped; mapping.md tells the current truth. Scale: doctor-report reads only consumed columns and enabled sections; exports and backups keyset-paginate; achievements tally via SQL buckets; series charts day-bucket dense kinds beyond 90 days; BP pairing is a linear two-pointer; distinct-type scans run server-side; the graded-series cold fallback is bounded; the fitbit defer tracker loops instead of spreading.
124 lines
4.1 KiB
TypeScript
124 lines
4.1 KiB
TypeScript
/**
|
|
* Pins the tombstone-resurrect contract of `upsertFitbitMeasurements`.
|
|
*
|
|
* The measurements unique index on `(userId, type, source, externalId)` is
|
|
* FULL — it covers soft-deleted rows — so a tombstoned row permanently owns
|
|
* its key. The probe must therefore match tombstoned rows too and route them
|
|
* into the UPDATE branch with `deletedAt: null`: treating them as absent plans
|
|
* an insert that `skipDuplicates` drops SILENTLY against the tombstone's key,
|
|
* wedging the key forever (the same wedge shipped live on the Google
|
|
* transport).
|
|
*/
|
|
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
|
|
const { findManyMock, createManyMock, updateMock } = vi.hoisted(() => ({
|
|
findManyMock: vi.fn(async () => [] as unknown[]),
|
|
createManyMock: vi.fn(async () => ({ count: 0 })),
|
|
updateMock: vi.fn(async () => ({})),
|
|
}));
|
|
|
|
vi.mock("@/lib/db", () => ({
|
|
prisma: {
|
|
measurement: {
|
|
findMany: findManyMock,
|
|
createMany: createManyMock,
|
|
update: updateMock,
|
|
},
|
|
},
|
|
}));
|
|
vi.mock("@/lib/crypto", () => ({ encrypt: vi.fn(), decrypt: vi.fn() }));
|
|
vi.mock("@/lib/integrations/status", () => ({
|
|
isReauthRequired: vi.fn(async () => false),
|
|
recordSyncFailure: vi.fn(async () => {}),
|
|
recordSyncSuccess: vi.fn(async () => {}),
|
|
}));
|
|
vi.mock("@/lib/rollups/measurement-rollups", () => ({
|
|
collapseToTypeDayKeys: vi.fn(() => []),
|
|
recomputeBucketsForMeasurement: vi.fn(async () => {}),
|
|
recomputeUserRollups: vi.fn(async () => {}),
|
|
}));
|
|
vi.mock("@/lib/insights/comprehensive-generate", () => ({
|
|
invalidateStatusInsightsForTypes: vi.fn(async () => {}),
|
|
}));
|
|
vi.mock("@/lib/integrations/oauth-refresh", () => ({
|
|
persistRotatedToken: vi.fn(async () => {}),
|
|
}));
|
|
vi.mock("../credentials", () => ({
|
|
getUserFitbitCredentials: vi.fn(async () => null),
|
|
}));
|
|
vi.mock("../client", () => ({ refreshAccessToken: vi.fn() }));
|
|
|
|
import { upsertFitbitMeasurements } from "../sync";
|
|
|
|
const STEPS_READING = {
|
|
type: "ACTIVITY_STEPS",
|
|
value: 8123,
|
|
unit: "steps",
|
|
measuredAt: new Date("2026-07-08T00:00:00.000Z"),
|
|
externalId: "stats:steps:2026-07-08",
|
|
};
|
|
|
|
beforeEach(() => {
|
|
findManyMock.mockReset().mockResolvedValue([]);
|
|
createManyMock.mockReset().mockResolvedValue({ count: 0 });
|
|
updateMock.mockReset().mockResolvedValue({});
|
|
});
|
|
|
|
describe("upsertFitbitMeasurements — tombstones resurrect", () => {
|
|
it("probes WITHOUT a deletedAt filter (a tombstoned row must be matched)", async () => {
|
|
await upsertFitbitMeasurements("user-1", [STEPS_READING], {
|
|
deferRollup: true,
|
|
});
|
|
const arg = (findManyMock.mock.calls[0] as unknown[])[0] as {
|
|
where: Record<string, unknown>;
|
|
};
|
|
expect(arg.where).toEqual({
|
|
userId: "user-1",
|
|
source: "FITBIT",
|
|
externalId: { in: ["stats:steps:2026-07-08"] },
|
|
});
|
|
expect(arg.where).not.toHaveProperty("deletedAt");
|
|
});
|
|
|
|
it("routes a matched (tombstoned) row into an update that clears deletedAt", async () => {
|
|
findManyMock.mockResolvedValue([
|
|
{
|
|
id: "row-1",
|
|
type: "ACTIVITY_STEPS",
|
|
externalId: "stats:steps:2026-07-08",
|
|
},
|
|
]);
|
|
|
|
const { imported } = await upsertFitbitMeasurements(
|
|
"user-1",
|
|
[STEPS_READING],
|
|
{ deferRollup: true },
|
|
);
|
|
|
|
// No insert is planned for an owned key — the update resurrects in place.
|
|
expect(createManyMock).not.toHaveBeenCalled();
|
|
expect(updateMock).toHaveBeenCalledTimes(1);
|
|
const upd = (updateMock.mock.calls[0] as unknown[])[0] as {
|
|
where: { id: string };
|
|
data: Record<string, unknown>;
|
|
};
|
|
expect(upd.where).toEqual({ id: "row-1" });
|
|
expect(upd.data.deletedAt).toBeNull();
|
|
expect(upd.data.value).toBe(8123);
|
|
expect(upd.data.syncVersion).toEqual({ increment: 1 });
|
|
expect(imported).toBe(1);
|
|
});
|
|
|
|
it("still creates a genuinely fresh key", async () => {
|
|
createManyMock.mockResolvedValue({ count: 1 });
|
|
const { imported } = await upsertFitbitMeasurements(
|
|
"user-1",
|
|
[STEPS_READING],
|
|
{ deferRollup: true },
|
|
);
|
|
expect(updateMock).not.toHaveBeenCalled();
|
|
expect(createManyMock).toHaveBeenCalledTimes(1);
|
|
expect(imported).toBe(1);
|
|
});
|
|
});
|