mirror of
https://github.com/MBombeck/HealthLog.git
synced 2026-11-17 23:52:24 +00:00
ensureDbCompatibility ran ALTER TABLE / CREATE TABLE IF NOT EXISTS on the login, register, token and session paths, mirroring columns every migration under prisma/migrations already creates. The entrypoint applies those migrations before the server listens and stops the boot when one fails, so the mirror never had work to do, and DDL on a request path needs the table's owner: a connection that may only read and write rows fails every login on it. Drop the module, its call sites and the mocks that stubbed it out.
255 lines
8.9 KiB
TypeScript
255 lines
8.9 KiB
TypeScript
/**
|
|
* #1195 — overlapping Google Health sleep segments, synced against Postgres.
|
|
*
|
|
* What went wrong. A measurement row has two unique identities: its
|
|
* externalId, and its natural key `(type, measuredAt, source, sleepStage)`.
|
|
* A sleep segment is stored at its END, so two segments of the same stage
|
|
* that end at the same instant share a natural key even though Google gives
|
|
* them different externalIds. Google reports such segments: two sessions over
|
|
* one stretch of a night, and segments it re-scores so that one ends where a
|
|
* sibling already ends. The sync updated rows by externalId one by one, the
|
|
* update that moved a row onto a slot another row held threw P2002, and the
|
|
* whole sync was marked failed, every hour, for a sync that had written
|
|
* everything else.
|
|
*
|
|
* What this pins:
|
|
* - a re-score that moves a segment onto a sibling's slot is a clean sync,
|
|
* with one row left on that slot carrying the longer segment;
|
|
* - two sessions reporting the same segments do not double the night, and
|
|
* re-syncing them leaves every row untouched (no tombstone churn, no
|
|
* `syncVersion` bump), so the slot does not change hands every hour;
|
|
* - the night's asleep total is the union of the overlapping segments,
|
|
* never their sum.
|
|
*/
|
|
import { afterAll, beforeEach, describe, expect, it, vi } from "vitest";
|
|
|
|
import { getPrismaClient, truncateAllTables } from "./setup";
|
|
|
|
const USER = "gh-sleep-overlap-owner";
|
|
const TZ = "Europe/Berlin";
|
|
|
|
const fake = vi.hoisted(() => ({
|
|
sessions: [] as unknown[],
|
|
}));
|
|
|
|
vi.mock("@/lib/safe-fetch", async (importOriginal) => {
|
|
const actual = await importOriginal<typeof import("@/lib/safe-fetch")>();
|
|
return {
|
|
...actual,
|
|
safeFetch: async (url: string) => {
|
|
const u = new URL(url);
|
|
const body = u.pathname.endsWith("/dataTypes/sleep/dataPoints")
|
|
? { dataPoints: fake.sessions }
|
|
: {};
|
|
return new Response(JSON.stringify(body), {
|
|
status: 200,
|
|
headers: { "content-type": "application/json" },
|
|
});
|
|
},
|
|
};
|
|
});
|
|
|
|
/** The night under test: 22:00 UTC two days ago to 06:00 UTC yesterday. */
|
|
const NIGHT_START = (() => {
|
|
const d = new Date();
|
|
d.setUTCHours(22, 0, 0, 0);
|
|
return d.getTime() - 2 * 24 * 60 * 60 * 1000;
|
|
})();
|
|
const at = (minutes: number): string =>
|
|
new Date(NIGHT_START + minutes * 60_000).toISOString();
|
|
|
|
function segment(type: string, from: number, to: number) {
|
|
return { type, startTime: at(from), endTime: at(to) };
|
|
}
|
|
|
|
function session(
|
|
id: string,
|
|
stages: Array<ReturnType<typeof segment>>,
|
|
): unknown {
|
|
const starts = stages.map((s) => s.startTime).sort();
|
|
const ends = stages.map((s) => s.endTime).sort();
|
|
return {
|
|
name: `users/me/dataTypes/sleep/dataPoints/${id}`,
|
|
sleep: {
|
|
interval: { startTime: starts[0], endTime: ends[ends.length - 1] },
|
|
stages,
|
|
},
|
|
};
|
|
}
|
|
|
|
beforeEach(async () => {
|
|
const prisma = getPrismaClient();
|
|
await truncateAllTables(prisma);
|
|
const { encrypt } = await import("@/lib/crypto");
|
|
await prisma.user.create({
|
|
data: { id: USER, username: USER, timezone: TZ },
|
|
});
|
|
await prisma.googleHealthConnection.create({
|
|
data: {
|
|
userId: USER,
|
|
googleUserId: `google-${USER}`,
|
|
accessToken: encrypt("access"),
|
|
refreshToken: encrypt("refresh"),
|
|
tokenExpiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000),
|
|
},
|
|
});
|
|
fake.sessions = [];
|
|
}, 120_000);
|
|
|
|
afterAll(async () => {
|
|
await truncateAllTables(getPrismaClient());
|
|
});
|
|
|
|
async function sync() {
|
|
const { syncUserGoogleHealth } = await import("@/lib/google-health/sync");
|
|
return syncUserGoogleHealth(USER);
|
|
}
|
|
|
|
async function sleepRows() {
|
|
return getPrismaClient().measurement.findMany({
|
|
where: { userId: USER, type: "SLEEP_DURATION" },
|
|
select: {
|
|
id: true,
|
|
value: true,
|
|
measuredAt: true,
|
|
sleepStage: true,
|
|
source: true,
|
|
externalId: true,
|
|
deletedAt: true,
|
|
syncVersion: true,
|
|
},
|
|
orderBy: [{ measuredAt: "asc" }, { id: "asc" }],
|
|
});
|
|
}
|
|
|
|
async function asleepMinutes(): Promise<number> {
|
|
const { reconstructSleepNights } =
|
|
await import("@/lib/analytics/sleep-night");
|
|
const live = (await sleepRows()).filter((r) => r.deletedAt === null);
|
|
const nights = reconstructSleepNights(live, TZ);
|
|
return nights.reduce((sum, n) => sum + n.asleepMinutes, 0);
|
|
}
|
|
|
|
describe("Google Health overlapping sleep segments (#1195)", () => {
|
|
it("lands a re-score that moves a segment onto a sibling's slot without failing the sync", async () => {
|
|
// First scoring: two LIGHT segments, the second starting inside the
|
|
// first, ending at different instants.
|
|
fake.sessions = [
|
|
session("night", [
|
|
segment("LIGHT", 0, 60),
|
|
segment("LIGHT", 30, 120),
|
|
segment("DEEP", 120, 180),
|
|
]),
|
|
];
|
|
const first = await sync();
|
|
expect(first.failed).toBe(false);
|
|
|
|
// Re-score: the first segment now runs to 120, onto the end the second
|
|
// segment already holds. Same stage, same end: one natural key.
|
|
fake.sessions = [
|
|
session("night", [
|
|
segment("LIGHT", 0, 120),
|
|
segment("LIGHT", 30, 120),
|
|
segment("DEEP", 120, 180),
|
|
]),
|
|
];
|
|
const second = await sync();
|
|
expect(second.failed).toBe(false);
|
|
|
|
const live = (await sleepRows()).filter((r) => r.deletedAt === null);
|
|
const lightAt120 = live.filter(
|
|
(r) => r.sleepStage === "CORE" && r.measuredAt.toISOString() === at(120),
|
|
);
|
|
expect(lightAt120).toHaveLength(1);
|
|
// The longer segment holds the slot.
|
|
expect(lightAt120[0]!.value).toBe(120);
|
|
expect(lightAt120[0]!.externalId).toContain(`:sleep:${at(0)}`);
|
|
// 120 minutes of light sleep (00:00-02:00) and 60 of deep: the overlap
|
|
// is counted once.
|
|
expect(await asleepMinutes()).toBe(180);
|
|
|
|
// The same answer again is a no-op: the slot keeps its row.
|
|
const before = await sleepRows();
|
|
const third = await sync();
|
|
expect(third.failed).toBe(false);
|
|
expect(await sleepRows()).toEqual(before);
|
|
});
|
|
|
|
it("keeps both readings when a segment moves off a slot a new segment takes", async () => {
|
|
fake.sessions = [
|
|
session("night", [segment("LIGHT", 0, 60), segment("DEEP", 90, 150)]),
|
|
];
|
|
expect((await sync()).failed).toBe(false);
|
|
|
|
// Re-score: the light segment now runs to 90, and a new light segment
|
|
// ends at 60, the slot the first one is leaving.
|
|
fake.sessions = [
|
|
session("night", [
|
|
segment("LIGHT", 0, 90),
|
|
segment("LIGHT", 30, 60),
|
|
segment("DEEP", 90, 150),
|
|
]),
|
|
];
|
|
expect((await sync()).failed).toBe(false);
|
|
|
|
const light = (await sleepRows())
|
|
.filter((r) => r.deletedAt === null && r.sleepStage === "CORE")
|
|
.map((r) => [r.measuredAt.toISOString(), r.value, r.externalId]);
|
|
expect(light).toEqual([
|
|
[at(60), 30, expect.stringContaining(`:sleep:${at(30)}`)],
|
|
[at(90), 90, expect.stringContaining(`:sleep:${at(0)}`)],
|
|
]);
|
|
});
|
|
|
|
it("keeps one row per segment when two sessions report the same night", async () => {
|
|
const stages = [
|
|
segment("DEEP", 60, 120),
|
|
segment("REM", 120, 150),
|
|
segment("LIGHT", 150, 240),
|
|
];
|
|
fake.sessions = [session("phone", stages), session("watch", stages)];
|
|
|
|
const first = await sync();
|
|
expect(first.failed).toBe(false);
|
|
const afterFirst = await sleepRows();
|
|
expect(afterFirst.filter((r) => r.deletedAt === null)).toHaveLength(3);
|
|
expect(await asleepMinutes()).toBe(180);
|
|
|
|
// Hour after hour the same two sessions come back. Nothing moves:
|
|
// neither session's window clears the other's rows, and the slot is not
|
|
// handed from one session's externalId to the other's.
|
|
for (let i = 0; i < 2; i++) {
|
|
const again = await sync();
|
|
expect(again.failed).toBe(false);
|
|
expect(await sleepRows()).toEqual(afterFirst);
|
|
}
|
|
expect(await asleepMinutes()).toBe(180);
|
|
});
|
|
|
|
it("settles overlapping sessions that disagree, without failing and without inflating the night", async () => {
|
|
// The watch's session ends its light segment later than the phone's.
|
|
fake.sessions = [
|
|
session("phone", [segment("LIGHT", 0, 90), segment("DEEP", 90, 150)]),
|
|
session("watch", [segment("LIGHT", 10, 90), segment("DEEP", 90, 160)]),
|
|
];
|
|
expect((await sync()).failed).toBe(false);
|
|
|
|
// Re-score on the phone: its deep segment now ends where the watch's
|
|
// does, so both sessions put a DEEP segment on one slot.
|
|
fake.sessions = [
|
|
session("phone", [segment("LIGHT", 0, 90), segment("DEEP", 90, 160)]),
|
|
session("watch", [segment("LIGHT", 10, 90), segment("DEEP", 90, 160)]),
|
|
];
|
|
expect((await sync()).failed).toBe(false);
|
|
expect((await sync()).failed).toBe(false);
|
|
|
|
const live = (await sleepRows()).filter((r) => r.deletedAt === null);
|
|
const keys = live.map(
|
|
(r) => `${r.sleepStage}|${r.measuredAt.toISOString()}`,
|
|
);
|
|
expect(new Set(keys).size).toBe(keys.length);
|
|
// Light 00:00-01:30 and deep 01:30-02:40: 160 minutes asleep.
|
|
expect(await asleepMinutes()).toBe(160);
|
|
});
|
|
});
|