mirror of
https://github.com/MBombeck/HealthLog.git
synced 2026-11-16 07:13:29 +00:00
feat(rollups): collapse overlapping sources across all read paths
Complete the source-aware rollup read path: the slim summaries slice (rollup + live), the comprehensive aggregator (both paths, including the dailyByType correlation feed), and the /api/measurements route (rollup read + the live date_trunc fallback) now resolve overlapping sources to the source-priority ladder's canonical reading per (type, day) before aggregating. A dual-source vital (e.g. WHOOP + Apple Watch resting heart rate) surfaces one canonical series instead of a blend or a doubled count; cumulative metrics keep summing per canonical source. The collapse runs in SQL where the aggregate must stay a single round-trip (buildSourceRankCase emits a per-user ladder-rank CASE; canonicalMeasurementsFrom restricts a live read to canonical-source rows) and in application code (collapseRollupRowsBySource) for the row readers, both driven by the same resolved ladders so live and rollup agree. Also widens the enum-literal SQL whitelist to accept digits so VO2_MAX no longer throws on the typed write-hook recompute or the rank CASE. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
1 parent
d06eec6ace
commit
7c494b60cb
14 files changed
+1248
-352
No files matched your search
@@ -12,6 +12,9 @@ vi.mock("@/lib/db", () => ({
|
||||
prisma: {
|
||||
measurement: { findMany: vi.fn() },
|
||||
measurementRollup: { findMany: vi.fn() },
|
||||
// v1.11.1 — readRollupBuckets lazy-loads the source-priority blob; null
|
||||
// (default findUnique) falls back to the default ladders.
|
||||
user: { findUnique: vi.fn() },
|
||||
},
|
||||
}));
|
||||
|
||||
|
||||
@@ -13,6 +13,8 @@ vi.mock("@/lib/db", () => ({
|
||||
prisma: {
|
||||
measurement: { findMany: vi.fn() },
|
||||
measurementRollup: { findMany: vi.fn() },
|
||||
// v1.11.1 — readRollupBuckets lazy-loads the source-priority blob.
|
||||
user: { findUnique: vi.fn() },
|
||||
moodEntry: { findMany: vi.fn() },
|
||||
medicationIntakeEvent: { findMany: vi.fn() },
|
||||
},
|
||||
|
||||
@@ -12,6 +12,8 @@ vi.mock("@/lib/db", () => ({
|
||||
prisma: {
|
||||
measurement: { findMany: vi.fn() },
|
||||
measurementRollup: { findMany: vi.fn() },
|
||||
// v1.11.1 — readRollupBuckets lazy-loads the source-priority blob.
|
||||
user: { findUnique: vi.fn() },
|
||||
moodEntry: { findMany: vi.fn() },
|
||||
medication: { findMany: vi.fn() },
|
||||
medicationIntakeEvent: { findMany: vi.fn() },
|
||||
|
||||
@@ -10,6 +10,16 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
||||
vi.mock("@/lib/db", () => ({
|
||||
prisma: {
|
||||
$queryRaw: vi.fn(),
|
||||
// v1.11.1 — the data-aggregate queries inside `computeFromRollups`
|
||||
// and `computeFromLiveAggregate` now splice a whitelisted
|
||||
// source-rank CASE and bind `userId` as `$1`, so they run via
|
||||
// `$queryRawUnsafe(sql, userId)` rather than the tagged-template
|
||||
// `$queryRaw`. The coverage probe stays on `$queryRaw`.
|
||||
$queryRawUnsafe: vi.fn(),
|
||||
// v1.11.1 — `loadUserSourcePriority` reads the user's
|
||||
// `sourcePriorityJson` to build the rank ladders. `null` here →
|
||||
// default ladders.
|
||||
user: { findUnique: vi.fn() },
|
||||
measurement: { findFirst: vi.fn() },
|
||||
// v1.4.36 — slim slice reads DAY buckets from `measurement_rollups`
|
||||
// on the happy path. The freshness watermark inside
|
||||
@@ -26,22 +36,63 @@ vi.mock("@/lib/logging/context", () => ({
|
||||
annotate: vi.fn(),
|
||||
}));
|
||||
|
||||
// v1.11.1 — `computeFromRollups` / `computeFromLiveAggregate` build a
|
||||
// source-rank CASE via `@/lib/analytics/source-rank-sql` and splice it
|
||||
// into the data-aggregate SQL. The builder's own correctness is pinned
|
||||
// in its dedicated suite (and the integration suite runs the real SQL);
|
||||
// here we stub it to deterministic, side-effect-free fragments so the
|
||||
// slice's plumbing — path selection, slope/round/empty contracts, the
|
||||
// 90-day FILTER caps the slice itself writes — is exercised without
|
||||
// coupling the slice unit test to the rank builder's enum-whitelist
|
||||
// internals.
|
||||
vi.mock("@/lib/analytics/source-rank-sql", () => ({
|
||||
buildSourceRankCase: vi.fn(() => "90"),
|
||||
canonicalMeasurementsFrom: vi.fn(
|
||||
(_rank: string, sinceInterval?: string) =>
|
||||
`(
|
||||
SELECT mm.*
|
||||
FROM measurements mm
|
||||
WHERE mm."user_id" = $1
|
||||
AND mm."deleted_at" IS NULL
|
||||
${
|
||||
sinceInterval
|
||||
? `AND mm."measured_at" >= NOW() - INTERVAL '${sinceInterval}'`
|
||||
: ""
|
||||
}
|
||||
) m`,
|
||||
),
|
||||
}));
|
||||
|
||||
import { prisma } from "@/lib/db";
|
||||
import { canonicalMeasurementsFrom } from "@/lib/analytics/source-rank-sql";
|
||||
import { computeSummariesSlice } from "../summaries-slice";
|
||||
|
||||
const RAW = prisma.$queryRaw as unknown as ReturnType<typeof vi.fn>;
|
||||
const UNSAFE = prisma.$queryRawUnsafe as unknown as ReturnType<typeof vi.fn>;
|
||||
const USER_FIND_UNIQUE =
|
||||
prisma.user.findUnique as unknown as ReturnType<typeof vi.fn>;
|
||||
const MEASUREMENT_FIND_FIRST =
|
||||
prisma.measurement.findFirst as unknown as ReturnType<typeof vi.fn>;
|
||||
const ROLLUP_FIND_MANY =
|
||||
prisma.measurementRollup.findMany as unknown as ReturnType<typeof vi.fn>;
|
||||
const ROLLUP_FIND_FIRST =
|
||||
prisma.measurementRollup.findFirst as unknown as ReturnType<typeof vi.fn>;
|
||||
const CANONICAL_FROM =
|
||||
canonicalMeasurementsFrom as unknown as ReturnType<typeof vi.fn>;
|
||||
|
||||
beforeEach(() => {
|
||||
RAW.mockReset();
|
||||
UNSAFE.mockReset();
|
||||
USER_FIND_UNIQUE.mockReset();
|
||||
MEASUREMENT_FIND_FIRST.mockReset();
|
||||
ROLLUP_FIND_MANY.mockReset();
|
||||
ROLLUP_FIND_FIRST.mockReset();
|
||||
// clear (not reset) — preserve the FROM-clause stub implementation,
|
||||
// drop cross-test call history so the cap assertion only sees this
|
||||
// test's calls.
|
||||
CANONICAL_FROM.mockClear();
|
||||
// null → loadUserSourcePriority returns null → default rank ladders.
|
||||
USER_FIND_UNIQUE.mockResolvedValue(null);
|
||||
ROLLUP_FIND_MANY.mockResolvedValue([]);
|
||||
ROLLUP_FIND_FIRST.mockResolvedValue(null);
|
||||
MEASUREMENT_FIND_FIRST.mockResolvedValue(null);
|
||||
@@ -54,15 +105,14 @@ afterEach(() => {
|
||||
describe("computeSummariesSlice", () => {
|
||||
describe("cold fallback — empty rollup table", () => {
|
||||
it("returns the empty-summary skeleton when the user has no rows", async () => {
|
||||
// v1.4.48 M0 — cold path now issues two aggregate queries
|
||||
// (`allTime` + `windowed`) instead of one fat aggregate, so the
|
||||
// $queryRaw call count is 4 instead of 3:
|
||||
// 1. per-type coverage probe — empty ⇒ cold path.
|
||||
// 2. all-time aggregate ($queryRaw) — empty.
|
||||
// 3. windowed aggregate ($queryRaw, 90-day cap) — empty.
|
||||
// 4. latests ($queryRaw) — empty.
|
||||
RAW.mockResolvedValueOnce([])
|
||||
.mockResolvedValueOnce([])
|
||||
// v1.11.1 — the coverage probe stays on `$queryRaw` (1 RAW call);
|
||||
// the three data-aggregate queries moved to `$queryRawUnsafe`:
|
||||
// 1. per-type coverage probe ($queryRaw) — empty ⇒ cold path.
|
||||
// 2. all-time aggregate ($queryRawUnsafe) — empty.
|
||||
// 3. windowed aggregate ($queryRawUnsafe, 90-day cap) — empty.
|
||||
// 4. latests ($queryRawUnsafe) — empty.
|
||||
RAW.mockResolvedValueOnce([]);
|
||||
UNSAFE.mockResolvedValueOnce([])
|
||||
.mockResolvedValueOnce([])
|
||||
.mockResolvedValueOnce([]);
|
||||
|
||||
@@ -85,7 +135,9 @@ describe("computeSummariesSlice", () => {
|
||||
avg30LastYear: null,
|
||||
});
|
||||
expect(result.bmi).toBeNull();
|
||||
expect(RAW).toHaveBeenCalledTimes(4);
|
||||
// 1 RAW coverage probe + 3 UNSAFE data queries.
|
||||
expect(RAW).toHaveBeenCalledTimes(1);
|
||||
expect(UNSAFE).toHaveBeenCalledTimes(3);
|
||||
});
|
||||
|
||||
it("maps a populated heavy aggregate row into the DataSummary shape on cold path", async () => {
|
||||
@@ -95,16 +147,16 @@ describe("computeSummariesSlice", () => {
|
||||
// 2. all-time aggregate (count / min / max / mean)
|
||||
// 3. windowed aggregate (avg7/30 + slope/r²)
|
||||
// 4. latests
|
||||
RAW.mockResolvedValueOnce([{ type: "WEIGHT", has_buckets: false }])
|
||||
.mockResolvedValueOnce([
|
||||
{
|
||||
type: "WEIGHT",
|
||||
count: BigInt(42),
|
||||
min_value: 79.2,
|
||||
max_value: 84.1,
|
||||
mean_value: 82.05,
|
||||
},
|
||||
])
|
||||
RAW.mockResolvedValueOnce([{ type: "WEIGHT", has_buckets: false }]);
|
||||
UNSAFE.mockResolvedValueOnce([
|
||||
{
|
||||
type: "WEIGHT",
|
||||
count: BigInt(42),
|
||||
min_value: 79.2,
|
||||
max_value: 84.1,
|
||||
mean_value: 82.05,
|
||||
},
|
||||
])
|
||||
.mockResolvedValueOnce([
|
||||
{
|
||||
type: "WEIGHT",
|
||||
@@ -153,16 +205,16 @@ describe("computeSummariesSlice", () => {
|
||||
});
|
||||
|
||||
it("returns a null slope tuple when the SQL slope is null (insufficient rows)", async () => {
|
||||
RAW.mockResolvedValueOnce([{ type: "PULSE", has_buckets: false }])
|
||||
.mockResolvedValueOnce([
|
||||
{
|
||||
type: "PULSE",
|
||||
count: BigInt(1),
|
||||
min_value: 72,
|
||||
max_value: 72,
|
||||
mean_value: 72,
|
||||
},
|
||||
])
|
||||
RAW.mockResolvedValueOnce([{ type: "PULSE", has_buckets: false }]);
|
||||
UNSAFE.mockResolvedValueOnce([
|
||||
{
|
||||
type: "PULSE",
|
||||
count: BigInt(1),
|
||||
min_value: 72,
|
||||
max_value: 72,
|
||||
mean_value: 72,
|
||||
},
|
||||
])
|
||||
.mockResolvedValueOnce([
|
||||
{
|
||||
type: "PULSE",
|
||||
@@ -188,16 +240,16 @@ describe("computeSummariesSlice", () => {
|
||||
|
||||
it("surfaces lastSeenByType from the DISTINCT ON pass's measured_at", async () => {
|
||||
const tenDaysAgo = new Date(Date.now() - 10 * 24 * 60 * 60 * 1000);
|
||||
RAW.mockResolvedValueOnce([{ type: "WEIGHT", has_buckets: false }])
|
||||
.mockResolvedValueOnce([
|
||||
{
|
||||
type: "WEIGHT",
|
||||
count: BigInt(5),
|
||||
min_value: 80,
|
||||
max_value: 84,
|
||||
mean_value: 82,
|
||||
},
|
||||
])
|
||||
RAW.mockResolvedValueOnce([{ type: "WEIGHT", has_buckets: false }]);
|
||||
UNSAFE.mockResolvedValueOnce([
|
||||
{
|
||||
type: "WEIGHT",
|
||||
count: BigInt(5),
|
||||
min_value: 80,
|
||||
max_value: 84,
|
||||
mean_value: 82,
|
||||
},
|
||||
])
|
||||
.mockResolvedValueOnce([
|
||||
{
|
||||
type: "WEIGHT",
|
||||
@@ -225,16 +277,16 @@ describe("computeSummariesSlice", () => {
|
||||
});
|
||||
|
||||
it("seeds the latest value from the DISTINCT ON pass per type", async () => {
|
||||
RAW.mockResolvedValueOnce([{ type: "PULSE", has_buckets: false }])
|
||||
.mockResolvedValueOnce([
|
||||
{
|
||||
type: "PULSE",
|
||||
count: BigInt(3),
|
||||
min_value: 60,
|
||||
max_value: 95,
|
||||
mean_value: 77,
|
||||
},
|
||||
])
|
||||
RAW.mockResolvedValueOnce([{ type: "PULSE", has_buckets: false }]);
|
||||
UNSAFE.mockResolvedValueOnce([
|
||||
{
|
||||
type: "PULSE",
|
||||
count: BigInt(3),
|
||||
min_value: 60,
|
||||
max_value: 95,
|
||||
mean_value: 77,
|
||||
},
|
||||
])
|
||||
.mockResolvedValueOnce([
|
||||
{
|
||||
type: "PULSE",
|
||||
@@ -260,29 +312,29 @@ describe("computeSummariesSlice", () => {
|
||||
|
||||
describe("rollup-fresh happy path", () => {
|
||||
it("composes count/min/max/mean from the per-type rollup GROUP BY without running the heavy aggregate", async () => {
|
||||
// v1.4.37.2 — the slim slice's rollup read is now a per-type
|
||||
// GROUP BY ($queryRaw) instead of a row-per-bucket findMany,
|
||||
// so the mock sequence is:
|
||||
// 1. per-type coverage probe — WEIGHT fully covered ⇒ happy path.
|
||||
// 2. narrow aggregate — windowed/regression only.
|
||||
// 3. latests.
|
||||
// 4. rollup GROUP BY — one row per type with count/min/max/mean
|
||||
// already composed server-side.
|
||||
RAW.mockResolvedValueOnce([{ type: "WEIGHT", has_buckets: true }])
|
||||
.mockResolvedValueOnce([
|
||||
{
|
||||
type: "WEIGHT",
|
||||
avg7: 82,
|
||||
avg30: 82.5,
|
||||
median: 82.1,
|
||||
slope7: 0.02,
|
||||
r2_7: 0.5,
|
||||
slope30: 0.01,
|
||||
r2_30: 0.4,
|
||||
slope90: 0.005,
|
||||
r2_90: 0.2,
|
||||
},
|
||||
])
|
||||
// v1.11.1 — the per-type coverage probe stays on `$queryRaw`; the
|
||||
// three rollup-path data queries moved to `$queryRawUnsafe`:
|
||||
// 1. per-type coverage probe ($queryRaw) — WEIGHT fully covered
|
||||
// ⇒ happy path.
|
||||
// 2. narrow aggregate ($queryRawUnsafe) — windowed/regression only.
|
||||
// 3. latests ($queryRawUnsafe).
|
||||
// 4. rollup GROUP BY ($queryRawUnsafe) — one row per type with
|
||||
// count/min/max/mean already composed server-side.
|
||||
RAW.mockResolvedValueOnce([{ type: "WEIGHT", has_buckets: true }]);
|
||||
UNSAFE.mockResolvedValueOnce([
|
||||
{
|
||||
type: "WEIGHT",
|
||||
avg7: 82,
|
||||
avg30: 82.5,
|
||||
median: 82.1,
|
||||
slope7: 0.02,
|
||||
r2_7: 0.5,
|
||||
slope30: 0.01,
|
||||
r2_30: 0.4,
|
||||
slope90: 0.005,
|
||||
r2_90: 0.2,
|
||||
},
|
||||
])
|
||||
.mockResolvedValueOnce([
|
||||
{ type: "WEIGHT", value: 82.7, measured_at: new Date() },
|
||||
])
|
||||
@@ -320,9 +372,11 @@ describe("computeSummariesSlice", () => {
|
||||
confidence: 0.5,
|
||||
});
|
||||
|
||||
// probe + narrow aggregate + latests + rollup GROUP BY
|
||||
// (v1.4.37.2 — the prior `findMany` is gone). No heavy aggregate.
|
||||
expect(RAW).toHaveBeenCalledTimes(4);
|
||||
// 1 RAW coverage probe + 3 UNSAFE data queries (narrow aggregate
|
||||
// + latests + rollup GROUP BY; v1.4.37.2 — the prior `findMany`
|
||||
// is gone). No heavy aggregate.
|
||||
expect(RAW).toHaveBeenCalledTimes(1);
|
||||
expect(UNSAFE).toHaveBeenCalledTimes(3);
|
||||
// v1.4.40 W-WMY-WIRE — the year-ago baseline probe runs
|
||||
// `readBestGranularityRollups(userId, type, 395)` per
|
||||
// type-with-data via `prisma.measurementRollup.findMany`. The
|
||||
@@ -343,20 +397,20 @@ describe("computeSummariesSlice", () => {
|
||||
describe("year-over-year wiring (avg30LastYear)", () => {
|
||||
it("populates avg30LastYear from MONTH buckets that overlap the year-ago slice", async () => {
|
||||
// Coverage probe shows WEIGHT covered → rollup happy path.
|
||||
RAW.mockResolvedValueOnce([{ type: "WEIGHT", has_buckets: true }])
|
||||
.mockResolvedValueOnce([
|
||||
{
|
||||
type: "WEIGHT",
|
||||
avg7: 82,
|
||||
avg30: 82.5,
|
||||
slope7: 0,
|
||||
r2_7: 0,
|
||||
slope30: 0,
|
||||
r2_30: 0,
|
||||
slope90: 0,
|
||||
r2_90: 0,
|
||||
},
|
||||
])
|
||||
RAW.mockResolvedValueOnce([{ type: "WEIGHT", has_buckets: true }]);
|
||||
UNSAFE.mockResolvedValueOnce([
|
||||
{
|
||||
type: "WEIGHT",
|
||||
avg7: 82,
|
||||
avg30: 82.5,
|
||||
slope7: 0,
|
||||
r2_7: 0,
|
||||
slope30: 0,
|
||||
r2_30: 0,
|
||||
slope90: 0,
|
||||
r2_90: 0,
|
||||
},
|
||||
])
|
||||
.mockResolvedValueOnce([
|
||||
{ type: "WEIGHT", value: 82.7, measured_at: new Date() },
|
||||
])
|
||||
@@ -392,20 +446,20 @@ describe("computeSummariesSlice", () => {
|
||||
});
|
||||
|
||||
it("leaves avg30LastYear null when no bucket overlaps the year-ago slice", async () => {
|
||||
RAW.mockResolvedValueOnce([{ type: "WEIGHT", has_buckets: true }])
|
||||
.mockResolvedValueOnce([
|
||||
{
|
||||
type: "WEIGHT",
|
||||
avg7: 82,
|
||||
avg30: 82.5,
|
||||
slope7: 0,
|
||||
r2_7: 0,
|
||||
slope30: 0,
|
||||
r2_30: 0,
|
||||
slope90: 0,
|
||||
r2_90: 0,
|
||||
},
|
||||
])
|
||||
RAW.mockResolvedValueOnce([{ type: "WEIGHT", has_buckets: true }]);
|
||||
UNSAFE.mockResolvedValueOnce([
|
||||
{
|
||||
type: "WEIGHT",
|
||||
avg7: 82,
|
||||
avg30: 82.5,
|
||||
slope7: 0,
|
||||
r2_7: 0,
|
||||
slope30: 0,
|
||||
r2_30: 0,
|
||||
slope90: 0,
|
||||
r2_90: 0,
|
||||
},
|
||||
])
|
||||
.mockResolvedValueOnce([
|
||||
{ type: "WEIGHT", value: 82.7, measured_at: new Date() },
|
||||
])
|
||||
@@ -437,20 +491,20 @@ describe("computeSummariesSlice", () => {
|
||||
});
|
||||
|
||||
it("leaves avg30LastYear null when every granularity misses (no coverage)", async () => {
|
||||
RAW.mockResolvedValueOnce([{ type: "WEIGHT", has_buckets: true }])
|
||||
.mockResolvedValueOnce([
|
||||
{
|
||||
type: "WEIGHT",
|
||||
avg7: 82,
|
||||
avg30: 82.5,
|
||||
slope7: 0,
|
||||
r2_7: 0,
|
||||
slope30: 0,
|
||||
r2_30: 0,
|
||||
slope90: 0,
|
||||
r2_90: 0,
|
||||
},
|
||||
])
|
||||
RAW.mockResolvedValueOnce([{ type: "WEIGHT", has_buckets: true }]);
|
||||
UNSAFE.mockResolvedValueOnce([
|
||||
{
|
||||
type: "WEIGHT",
|
||||
avg7: 82,
|
||||
avg30: 82.5,
|
||||
slope7: 0,
|
||||
r2_7: 0,
|
||||
slope30: 0,
|
||||
r2_30: 0,
|
||||
slope90: 0,
|
||||
r2_90: 0,
|
||||
},
|
||||
])
|
||||
.mockResolvedValueOnce([
|
||||
{ type: "WEIGHT", value: 82.7, measured_at: new Date() },
|
||||
])
|
||||
@@ -472,12 +526,12 @@ describe("computeSummariesSlice", () => {
|
||||
|
||||
it("only probes types that actually have data in the current window", async () => {
|
||||
// v1.4.48 M0 — empty coverage map ⇒ `isFullyCovered` returns
|
||||
// false ⇒ cold-fallback path. Cold path now issues 4 raw
|
||||
// queries (coverage probe + all-time + windowed + latests),
|
||||
// all returning empty arrays here ⇒ no types-with-data ⇒ the
|
||||
// year-ago probe must NOT fan out.
|
||||
RAW.mockResolvedValueOnce([])
|
||||
.mockResolvedValueOnce([])
|
||||
// false ⇒ cold-fallback path. v1.11.1 — coverage probe stays on
|
||||
// `$queryRaw`; all-time + windowed + latests run via
|
||||
// `$queryRawUnsafe`. All return empty arrays here ⇒ no
|
||||
// types-with-data ⇒ the year-ago probe must NOT fan out.
|
||||
RAW.mockResolvedValueOnce([]);
|
||||
UNSAFE.mockResolvedValueOnce([])
|
||||
.mockResolvedValueOnce([])
|
||||
.mockResolvedValueOnce([]);
|
||||
|
||||
@@ -499,34 +553,53 @@ describe("computeSummariesSlice", () => {
|
||||
*/
|
||||
describe("90-day outer measured_at cap (v1.4.48 M0)", () => {
|
||||
it("applies the 90-day cap to narrows (rollup-fresh path) and windowed (cold-fallback path)", async () => {
|
||||
// v1.11.1 — the cap-bearing data queries (narrows / windowed)
|
||||
// now run via `$queryRawUnsafe(sql, userId)`, so the SQL is a
|
||||
// plain string arg[0] rather than a tagged-template
|
||||
// strings array. Capture from the UNSAFE mock. The coverage probe
|
||||
// (still `$queryRaw`) drives path selection per call.
|
||||
const queries: string[] = [];
|
||||
RAW.mockImplementation((strings: TemplateStringsArray) => {
|
||||
queries.push(strings.join("?"));
|
||||
UNSAFE.mockImplementation((sql: string) => {
|
||||
queries.push(sql);
|
||||
return Promise.resolve([]);
|
||||
});
|
||||
|
||||
// Trigger the rollup-fresh path so we capture the `narrows` SQL.
|
||||
// Coverage probe returns one covered type ⇒ `isFullyCovered`
|
||||
// is true ⇒ `computeFromRollups` runs.
|
||||
RAW.mockImplementationOnce((strings: TemplateStringsArray) => {
|
||||
queries.push(strings.join("?"));
|
||||
return Promise.resolve([{ type: "WEIGHT", has_buckets: true }]);
|
||||
});
|
||||
// Then the cold-fallback path (empty coverage) so we capture the
|
||||
// `windowed` SQL.
|
||||
RAW.mockResolvedValueOnce([{ type: "WEIGHT", has_buckets: true }]);
|
||||
await computeSummariesSlice("user-rollup-pin");
|
||||
|
||||
// Trigger the cold-fallback path so we capture the `windowed`
|
||||
// SQL. Empty coverage map ⇒ `isFullyCovered` is false ⇒
|
||||
// `computeFromLiveAggregate` runs.
|
||||
RAW.mockResolvedValueOnce([]);
|
||||
await computeSummariesSlice("user-cold-pin");
|
||||
|
||||
const joined = queries.join("\n---\n");
|
||||
// Both windowed scans must carry the outer 90-day cap.
|
||||
const capMatches = joined.match(
|
||||
/AND m\."measured_at" >= NOW\(\) - INTERVAL '90 days'/g,
|
||||
// v1.11.1 — the rollup-fresh `narrows` query still writes its
|
||||
// outer 90-day cap inline, now on the canonical-source subquery's
|
||||
// raw alias (`mm.`) rather than the outer `m.`. Pin that the cap
|
||||
// survives the source-rank refactor.
|
||||
const narrowsCap = joined.match(
|
||||
/AND mm\."measured_at" >= NOW\(\) - INTERVAL '90 days'/g,
|
||||
);
|
||||
expect(narrowsCap).not.toBeNull();
|
||||
expect(narrowsCap?.length).toBeGreaterThanOrEqual(1);
|
||||
|
||||
// v1.11.1 — the cold-fallback `windowed` scan delegates its outer
|
||||
// 90-day cap to `canonicalMeasurementsFrom(rank, "90 days")`. The
|
||||
// helper lives in `@/lib/analytics/source-rank-sql` (stubbed
|
||||
// above), so pin the contract at the call boundary: the slice
|
||||
// must ask for the 90-day window. The `allTime` aggregate
|
||||
// deliberately calls it WITHOUT an interval (no cap — all-time
|
||||
// count/min/max/mean must scan every row).
|
||||
expect(canonicalMeasurementsFrom).toHaveBeenCalledWith(
|
||||
expect.any(String),
|
||||
"90 days",
|
||||
);
|
||||
expect(canonicalMeasurementsFrom).toHaveBeenCalledWith(
|
||||
expect.any(String),
|
||||
);
|
||||
expect(capMatches).not.toBeNull();
|
||||
// narrows (rollup-fresh) + windowed (cold-fallback) = 2 caps.
|
||||
expect(capMatches?.length).toBeGreaterThanOrEqual(2);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
@@ -0,0 +1,149 @@
|
||||
/**
|
||||
* v1.11.1 — source-aware SQL collapse helpers.
|
||||
*
|
||||
* The rollup writer mints one row per (type, day, source); the live
|
||||
* measurement reads see one raw row per reading. For overlapping standard
|
||||
* vitals (e.g. WHOOP + Apple Watch resting heart rate) both the rollup
|
||||
* all-time aggregate and the live 90-day aggregates must resolve to the
|
||||
* source-priority ladder's canonical source per (type, day) before composing,
|
||||
* or a dual-source user double-counts / blends two devices.
|
||||
*
|
||||
* `collapseRollupRowsBySource` does this in application code for the row-by-row
|
||||
* readers. These helpers do the equivalent IN SQL so the slim slice + the
|
||||
* comprehensive aggregator + the live `/api/measurements` fallback keep their
|
||||
* single-round-trip `GROUP BY type` shape (no six-figure row transfer).
|
||||
*
|
||||
* Every spliced literal is a closed-enum value (`MeasurementType` /
|
||||
* `MeasurementSource`) asserted against `/^[A-Z_]+$/`, the same whitelist
|
||||
* convention the rollup writer uses for its date-trunc + type-list splices.
|
||||
* The user id is always passed as a bound parameter, never spliced.
|
||||
*/
|
||||
import type { MeasurementType } from "@/generated/prisma/client";
|
||||
import { metricKeyForType } from "@/lib/measurements/cumulative-day-sum";
|
||||
import {
|
||||
getSourceLadder,
|
||||
parseSourcePriority,
|
||||
} from "@/lib/validations/source-priority";
|
||||
|
||||
/**
|
||||
* Measurement types that carry a source-priority ladder — the overlapping
|
||||
* vitals plus the cumulative metrics. Single-source types are intentionally
|
||||
* absent: they only ever have one source per (type, day), so the collapse is
|
||||
* a no-op for them and they fall into the CASE's ELSE branch.
|
||||
*/
|
||||
const RANKED_TYPES: readonly MeasurementType[] = [
|
||||
"RESTING_HEART_RATE",
|
||||
"HEART_RATE_VARIABILITY",
|
||||
"RESPIRATORY_RATE",
|
||||
"OXYGEN_SATURATION",
|
||||
"BODY_TEMPERATURE",
|
||||
"SKIN_TEMPERATURE",
|
||||
"WEIGHT",
|
||||
"BODY_FAT",
|
||||
"BLOOD_PRESSURE_SYS",
|
||||
"BLOOD_PRESSURE_DIA",
|
||||
"PULSE",
|
||||
"VO2_MAX",
|
||||
"RECOVERY_SCORE",
|
||||
"SLEEP_DURATION",
|
||||
"ACTIVITY_STEPS",
|
||||
"ACTIVE_ENERGY_BURNED",
|
||||
"WALKING_RUNNING_DISTANCE",
|
||||
"FLIGHTS_CLIMBED",
|
||||
];
|
||||
|
||||
// Enum members can carry digits (e.g. VO2_MAX, BLOOD_PRESSURE_SYS) — allow
|
||||
// 0-9 so the whitelist doesn't reject a legitimate closed-enum value.
|
||||
const ENUM_RE = /^[A-Z0-9_]+$/;
|
||||
function assertEnumLiteral(value: string): string {
|
||||
if (!ENUM_RE.test(value)) {
|
||||
throw new Error(`unsafe enum literal for SQL splice: ${value}`);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Build a SQL CASE expression mapping `(typeCol, sourceCol)` to an integer
|
||||
* rank where 0 = the highest-priority source on that type's ladder. A source
|
||||
* absent from a type's ladder — and every row of a type without a ladder —
|
||||
* gets rank 90 so a deterministic tiebreak (`source` name, or `count DESC`
|
||||
* where available) decides. Resolves the user's `sourcePriorityJson` ladders;
|
||||
* `null` yields the default ladders.
|
||||
*/
|
||||
export function buildSourceRankCase(
|
||||
priorityJson: unknown,
|
||||
typeCol: string,
|
||||
sourceCol: string,
|
||||
): string {
|
||||
const resolved = parseSourcePriority(priorityJson);
|
||||
const branches: string[] = [];
|
||||
for (const type of RANKED_TYPES) {
|
||||
const metricKey = metricKeyForType(type);
|
||||
if (!metricKey) continue;
|
||||
const ladder = getSourceLadder(resolved, metricKey);
|
||||
if (ladder.length === 0) continue;
|
||||
const whens = ladder
|
||||
.map((source, i) => `WHEN '${assertEnumLiteral(source)}' THEN ${i}`)
|
||||
.join(" ");
|
||||
branches.push(
|
||||
`WHEN ${typeCol} = '${assertEnumLiteral(type)}' THEN ` +
|
||||
`(CASE ${sourceCol} ${whens} ELSE 90 END)`,
|
||||
);
|
||||
}
|
||||
if (branches.length === 0) return "90";
|
||||
return `CASE ${branches.join(" ")} ELSE 90 END`;
|
||||
}
|
||||
|
||||
const INTERVAL_RE = /^\d+ (day|days|month|months|year|years)$/;
|
||||
function assertInterval(value: string): string {
|
||||
if (!INTERVAL_RE.test(value)) {
|
||||
throw new Error(`unsafe interval literal for SQL splice: ${value}`);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Build a FROM-clause subquery (aliased `m`) that restricts raw `measurements`
|
||||
* to the canonical-source rows per (type, day): the inner `DISTINCT ON` picks
|
||||
* the ladder-winning source for each day, and the join keeps only that source's
|
||||
* readings. Use it in place of `FROM measurements m` so a live aggregate over
|
||||
* an overlapping vital never blends two devices — the same collapse the rollup
|
||||
* readers apply, kept in lockstep for live/rollup parity.
|
||||
*
|
||||
* The user id is bound as `$1`. `rankUnqualified` must be a CASE built with
|
||||
* unqualified `"type"`/`"source"` columns. `sinceInterval` (e.g. `"90 days"`)
|
||||
* is whitelisted and, when given, scopes both the inner pick and the outer
|
||||
* filter to a trailing window.
|
||||
*/
|
||||
export function canonicalMeasurementsFrom(
|
||||
rankUnqualified: string,
|
||||
sinceInterval?: string,
|
||||
): string {
|
||||
const sinceInner = sinceInterval
|
||||
? `AND "measured_at" >= NOW() - INTERVAL '${assertInterval(sinceInterval)}'`
|
||||
: "";
|
||||
const sinceOuter = sinceInterval
|
||||
? `AND mm."measured_at" >= NOW() - INTERVAL '${assertInterval(sinceInterval)}'`
|
||||
: "";
|
||||
return `(
|
||||
SELECT mm.*
|
||||
FROM measurements mm
|
||||
JOIN (
|
||||
SELECT DISTINCT ON ("type", date_trunc('day', "measured_at"))
|
||||
"type" AS t,
|
||||
date_trunc('day', "measured_at") AS d,
|
||||
"source" AS canon
|
||||
FROM measurements
|
||||
WHERE "user_id" = $1
|
||||
AND "deleted_at" IS NULL
|
||||
${sinceInner}
|
||||
ORDER BY "type", date_trunc('day', "measured_at"), (${rankUnqualified}), "source"
|
||||
) c
|
||||
ON c.t = mm."type"
|
||||
AND c.d = date_trunc('day', mm."measured_at")
|
||||
AND c.canon = mm."source"
|
||||
WHERE mm."user_id" = $1
|
||||
AND mm."deleted_at" IS NULL
|
||||
${sinceOuter}
|
||||
) m`;
|
||||
}
|
||||
@@ -62,6 +62,11 @@ import type { DataSummary } from "@/lib/analytics/trends";
|
||||
import { measurementTypeEnum } from "@/lib/validations/measurement";
|
||||
import { annotate } from "@/lib/logging/context";
|
||||
import { ensureUserRollupsFresh } from "@/lib/rollups/measurement-rollups";
|
||||
import { loadUserSourcePriority } from "@/lib/rollups/measurement-read";
|
||||
import {
|
||||
buildSourceRankCase,
|
||||
canonicalMeasurementsFrom,
|
||||
} from "@/lib/analytics/source-rank-sql";
|
||||
import {
|
||||
isFullyCovered,
|
||||
probeRollupCoverage,
|
||||
@@ -274,8 +279,22 @@ export async function computeSummariesSlice(
|
||||
* multi-second cold to sub-second; output is bit-identical.
|
||||
*/
|
||||
async function computeFromRollups(userId: string): Promise<SummariesSlice> {
|
||||
// v1.11.1 — resolve the user's source-priority ladders once, then build the
|
||||
// rank CASE expressions used to collapse overlapping sources to the canonical
|
||||
// reading per (type, day) inside each query. `"type"`/`"source"` variants for
|
||||
// the unqualified rollup + inner-subquery columns, `m."…"` for the latest
|
||||
// read's outer alias.
|
||||
const priorityJson = await loadUserSourcePriority(userId);
|
||||
const rankUnqualified = buildSourceRankCase(priorityJson, '"type"', '"source"');
|
||||
const rankM = buildSourceRankCase(priorityJson, 'm."type"', 'm."source"');
|
||||
|
||||
const [narrows, latests, dayBuckets] = await Promise.all([
|
||||
prisma.$queryRaw<NarrowAggregateRow[]>`
|
||||
// The FROM is restricted to the canonical-source rows per (type, day): the
|
||||
// inner DISTINCT ON picks the ladder-winning source for each day, and the
|
||||
// join keeps only that source's readings so the 90-day AVG / median / slope
|
||||
// never blend two devices that both reported the same vital.
|
||||
prisma.$queryRawUnsafe<NarrowAggregateRow[]>(
|
||||
`
|
||||
SELECT
|
||||
m."type"::text AS type,
|
||||
AVG(m."value") FILTER (
|
||||
@@ -329,22 +348,47 @@ async function computeFromRollups(userId: string): Promise<SummariesSlice> {
|
||||
) FILTER (
|
||||
WHERE m."measured_at" >= NOW() - INTERVAL '90 days'
|
||||
)::double precision AS r2_90
|
||||
FROM measurements m
|
||||
WHERE m."user_id" = ${userId}
|
||||
AND m."deleted_at" IS NULL
|
||||
AND m."measured_at" >= NOW() - INTERVAL '90 days'
|
||||
FROM (
|
||||
SELECT mm.*
|
||||
FROM measurements mm
|
||||
JOIN (
|
||||
SELECT DISTINCT ON ("type", date_trunc('day', "measured_at"))
|
||||
"type" AS t,
|
||||
date_trunc('day', "measured_at") AS d,
|
||||
"source" AS canon
|
||||
FROM measurements
|
||||
WHERE "user_id" = $1
|
||||
AND "deleted_at" IS NULL
|
||||
AND "measured_at" >= NOW() - INTERVAL '90 days'
|
||||
ORDER BY "type", date_trunc('day', "measured_at"), (${rankUnqualified}), "source"
|
||||
) c
|
||||
ON c.t = mm."type"
|
||||
AND c.d = date_trunc('day', mm."measured_at")
|
||||
AND c.canon = mm."source"
|
||||
WHERE mm."user_id" = $1
|
||||
AND mm."deleted_at" IS NULL
|
||||
AND mm."measured_at" >= NOW() - INTERVAL '90 days'
|
||||
) m
|
||||
GROUP BY m."type"
|
||||
`,
|
||||
prisma.$queryRaw<LatestRow[]>`
|
||||
userId,
|
||||
),
|
||||
// v1.11.1 — the latest tile reflects the canonical source for the latest
|
||||
// day, matching the chart: order by latest day first, then the ladder rank
|
||||
// (canonical source wins), then the latest reading of that source.
|
||||
prisma.$queryRawUnsafe<LatestRow[]>(
|
||||
`
|
||||
SELECT DISTINCT ON (m."type")
|
||||
m."type"::text AS type,
|
||||
m."value"::double precision AS value,
|
||||
m."measured_at" AS measured_at
|
||||
FROM measurements m
|
||||
WHERE m."user_id" = ${userId}
|
||||
WHERE m."user_id" = $1
|
||||
AND m."deleted_at" IS NULL
|
||||
ORDER BY m."type", m."measured_at" DESC
|
||||
ORDER BY m."type", date_trunc('day', m."measured_at") DESC, (${rankM}), m."measured_at" DESC
|
||||
`,
|
||||
userId,
|
||||
),
|
||||
// v1.4.37.2 hotfix — the v1.4.35 implementation read EVERY DAY
|
||||
// rollup bucket for the user (`findMany` without a `bucketStart`
|
||||
// window) and then composed `count / min / max / mean` in JS.
|
||||
@@ -353,11 +397,26 @@ async function computeFromRollups(userId: string): Promise<SummariesSlice> {
|
||||
// cache miss, even with the rollup table hot. The slim slice's
|
||||
// contract is the all-time count / min / max / mean per type —
|
||||
// exactly what a SQL `GROUP BY type` returns in a single
|
||||
// round-trip. Returns 8 rows
|
||||
// instead of 306k, brings the cache-miss cost into the < 100 ms
|
||||
// budget. The downstream `aggregateBuckets` call is bypassed
|
||||
// because the per-type aggregate is already shaped server-side.
|
||||
prisma.$queryRaw<RollupAggregateRow[]>`
|
||||
// round-trip.
|
||||
//
|
||||
// v1.11.1 — rows are now per source. Collapse each (type, day) to the
|
||||
// ladder-canonical source via DISTINCT ON before the all-time aggregate,
|
||||
// so a dual-source vital is counted once. Still one server-side pass —
|
||||
// the DISTINCT ON + GROUP BY runs in Postgres and returns one row/type.
|
||||
prisma.$queryRawUnsafe<RollupAggregateRow[]>(
|
||||
`
|
||||
WITH collapsed AS (
|
||||
SELECT DISTINCT ON ("type", "bucket_start")
|
||||
"type" AS type,
|
||||
"count" AS count,
|
||||
"min_value" AS min_value,
|
||||
"max_value" AS max_value,
|
||||
"mean" AS mean
|
||||
FROM "measurement_rollups"
|
||||
WHERE "user_id" = $1
|
||||
AND "granularity" = 'DAY'
|
||||
ORDER BY "type", "bucket_start", (${rankUnqualified}), "count" DESC, "source"
|
||||
)
|
||||
SELECT
|
||||
"type"::text AS type,
|
||||
SUM("count")::int AS count,
|
||||
@@ -367,11 +426,11 @@ async function computeFromRollups(userId: string): Promise<SummariesSlice> {
|
||||
SUM("count" * "mean")::double precision
|
||||
/ NULLIF(SUM("count")::double precision, 0)
|
||||
) AS mean
|
||||
FROM "measurement_rollups"
|
||||
WHERE "user_id" = ${userId}
|
||||
AND "granularity" = 'DAY'
|
||||
FROM collapsed
|
||||
GROUP BY "type"
|
||||
`,
|
||||
userId,
|
||||
),
|
||||
]);
|
||||
|
||||
const latestByType = new Map<string, number>();
|
||||
@@ -506,20 +565,31 @@ async function computeFromRollups(userId: string): Promise<SummariesSlice> {
|
||||
async function computeFromLiveAggregate(
|
||||
userId: string,
|
||||
): Promise<SummariesSlice> {
|
||||
// v1.11.1 — collapse overlapping sources to the ladder-canonical reading per
|
||||
// (type, day) BEFORE aggregating, exactly as the rollup path does, so a
|
||||
// coverage-miss tenant gets the same numbers as a warm one (live/rollup
|
||||
// parity). `canonicalMeasurementsFrom` swaps `FROM measurements m` for a
|
||||
// canonical-source-filtered subquery; the latest read uses the ladder rank.
|
||||
const priorityJson = await loadUserSourcePriority(userId);
|
||||
const rankUnqualified = buildSourceRankCase(priorityJson, '"type"', '"source"');
|
||||
const rankM = buildSourceRankCase(priorityJson, 'm."type"', 'm."source"');
|
||||
|
||||
const [allTime, windowed, latests] = await Promise.all([
|
||||
prisma.$queryRaw<AllTimeAggregateRow[]>`
|
||||
prisma.$queryRawUnsafe<AllTimeAggregateRow[]>(
|
||||
`
|
||||
SELECT
|
||||
m."type"::text AS type,
|
||||
COUNT(*) AS count,
|
||||
MIN(m."value")::double precision AS min_value,
|
||||
MAX(m."value")::double precision AS max_value,
|
||||
AVG(m."value")::double precision AS mean_value
|
||||
FROM measurements m
|
||||
WHERE m."user_id" = ${userId}
|
||||
AND m."deleted_at" IS NULL
|
||||
FROM ${canonicalMeasurementsFrom(rankUnqualified)}
|
||||
GROUP BY m."type"
|
||||
`,
|
||||
prisma.$queryRaw<NarrowAggregateRow[]>`
|
||||
userId,
|
||||
),
|
||||
prisma.$queryRawUnsafe<NarrowAggregateRow[]>(
|
||||
`
|
||||
SELECT
|
||||
m."type"::text AS type,
|
||||
AVG(m."value") FILTER (
|
||||
@@ -573,22 +643,24 @@ async function computeFromLiveAggregate(
|
||||
) FILTER (
|
||||
WHERE m."measured_at" >= NOW() - INTERVAL '90 days'
|
||||
)::double precision AS r2_90
|
||||
FROM measurements m
|
||||
WHERE m."user_id" = ${userId}
|
||||
AND m."deleted_at" IS NULL
|
||||
AND m."measured_at" >= NOW() - INTERVAL '90 days'
|
||||
FROM ${canonicalMeasurementsFrom(rankUnqualified, "90 days")}
|
||||
GROUP BY m."type"
|
||||
`,
|
||||
prisma.$queryRaw<LatestRow[]>`
|
||||
userId,
|
||||
),
|
||||
prisma.$queryRawUnsafe<LatestRow[]>(
|
||||
`
|
||||
SELECT DISTINCT ON (m."type")
|
||||
m."type"::text AS type,
|
||||
m."value"::double precision AS value,
|
||||
m."measured_at" AS measured_at
|
||||
FROM measurements m
|
||||
WHERE m."user_id" = ${userId}
|
||||
WHERE m."user_id" = $1
|
||||
AND m."deleted_at" IS NULL
|
||||
ORDER BY m."type", m."measured_at" DESC
|
||||
ORDER BY m."type", date_trunc('day', m."measured_at") DESC, (${rankM}), m."measured_at" DESC
|
||||
`,
|
||||
userId,
|
||||
),
|
||||
]);
|
||||
|
||||
const latestByType = new Map<string, number>();
|
||||
|
||||
Reference in new issue
Block a user