mirror of
https://github.com/MBombeck/HealthLog.git
synced 2026-11-16 07:13:29 +00:00
Merge branch 'fix/coldstart-perf' into release/v1.27.32
This commit is contained in:
commit
57c7972755
27 files changed
+1040
-179
No files matched your search
@@ -1,6 +1,13 @@
|
||||
import { describe, it, expect, afterEach, vi } from "vitest";
|
||||
|
||||
import { shouldEmitSecureCookie } from "../secure-cookie";
|
||||
import {
|
||||
shouldEmitSecureCookie,
|
||||
detectInsecureCookieTransport,
|
||||
} from "../secure-cookie";
|
||||
|
||||
function req(headers: Record<string, string>, url = "http://10.0.0.5:3000/x") {
|
||||
return { headers: new Headers(headers), url };
|
||||
}
|
||||
|
||||
describe("shouldEmitSecureCookie", () => {
|
||||
afterEach(() => {
|
||||
@@ -47,3 +54,56 @@ describe("shouldEmitSecureCookie", () => {
|
||||
expect(shouldEmitSecureCookie()).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe("detectInsecureCookieTransport", () => {
|
||||
afterEach(() => {
|
||||
vi.unstubAllEnvs();
|
||||
});
|
||||
|
||||
it("returns null when the Secure flag is off (SESSION_COOKIE_SECURE=false)", () => {
|
||||
vi.stubEnv("NODE_ENV", "production");
|
||||
vi.stubEnv("SESSION_COOKIE_SECURE", "false");
|
||||
expect(detectInsecureCookieTransport(req({}))).toBeNull();
|
||||
});
|
||||
|
||||
it("warns when a Secure cookie will be set on a plain-HTTP request (no proxy)", () => {
|
||||
vi.stubEnv("NODE_ENV", "production");
|
||||
vi.stubEnv("SESSION_COOKIE_SECURE", "");
|
||||
const msg = detectInsecureCookieTransport(req({}));
|
||||
expect(msg).toContain("SESSION_COOKIE_SECURE=false");
|
||||
});
|
||||
|
||||
it("returns null behind a TLS proxy that forwards X-Forwarded-Proto: https", () => {
|
||||
vi.stubEnv("NODE_ENV", "production");
|
||||
vi.stubEnv("SESSION_COOKIE_SECURE", "");
|
||||
expect(
|
||||
detectInsecureCookieTransport(req({ "x-forwarded-proto": "https" })),
|
||||
).toBeNull();
|
||||
});
|
||||
|
||||
it("reads the left-most entry of a comma-separated proto chain", () => {
|
||||
vi.stubEnv("NODE_ENV", "production");
|
||||
vi.stubEnv("SESSION_COOKIE_SECURE", "");
|
||||
expect(
|
||||
detectInsecureCookieTransport(
|
||||
req({ "x-forwarded-proto": "https, http" }),
|
||||
),
|
||||
).toBeNull();
|
||||
});
|
||||
|
||||
it("warns when the proxy forwards X-Forwarded-Proto: http explicitly", () => {
|
||||
vi.stubEnv("NODE_ENV", "production");
|
||||
vi.stubEnv("SESSION_COOKIE_SECURE", "");
|
||||
expect(
|
||||
detectInsecureCookieTransport(req({ "x-forwarded-proto": "http" })),
|
||||
).not.toBeNull();
|
||||
});
|
||||
|
||||
it("returns null when the request URL is already https", () => {
|
||||
vi.stubEnv("NODE_ENV", "production");
|
||||
vi.stubEnv("SESSION_COOKIE_SECURE", "");
|
||||
expect(
|
||||
detectInsecureCookieTransport(req({}, "https://healthlog.example.com/x")),
|
||||
).toBeNull();
|
||||
});
|
||||
});
|
||||
@@ -27,6 +27,8 @@ import {
|
||||
} from "@/lib/auth/native-client";
|
||||
import { issueAccessAndRefresh } from "@/lib/auth/refresh-token";
|
||||
import { recordSignInDevice } from "@/lib/auth/login-alert";
|
||||
import { detectInsecureCookieTransport } from "@/lib/auth/secure-cookie";
|
||||
import { annotate } from "@/lib/logging/context";
|
||||
import type { User } from "@/generated/prisma/client";
|
||||
|
||||
export interface FinishLoginParams {
|
||||
@@ -116,8 +118,20 @@ export async function finishLogin(
|
||||
});
|
||||
}
|
||||
|
||||
// Browser path — session cookie. `createSession` anchors the onboarding
|
||||
// cookie itself; thread the user's onboarding state through.
|
||||
// Browser path — session cookie. Before minting it, surface the single
|
||||
// most common self-host snag: a Secure cookie about to be set on a plain-HTTP
|
||||
// request drops silently and loops the login. Warn-log + wide-event so an
|
||||
// operator sees the cause; the login still completes.
|
||||
const transportWarning = detectInsecureCookieTransport(request);
|
||||
if (transportWarning) {
|
||||
console.warn(
|
||||
`[auth] session-cookie transport mismatch: ${transportWarning}`,
|
||||
);
|
||||
annotate({ meta: { session_cookie_secure_transport_mismatch: true } });
|
||||
}
|
||||
|
||||
// `createSession` anchors the onboarding cookie itself; thread the user's
|
||||
// onboarding state through.
|
||||
await createSession(
|
||||
user.id,
|
||||
user.onboardingCompletedAt == null,
|
||||
|
||||
@@ -28,3 +28,57 @@ export function shouldEmitSecureCookie(): boolean {
|
||||
if (override === "true") return true;
|
||||
return process.env.NODE_ENV === "production";
|
||||
}
|
||||
|
||||
/**
|
||||
* One-line diagnostic for the single most common self-host login-loop cause:
|
||||
* the app is about to set a `Secure` session cookie
|
||||
* (`shouldEmitSecureCookie() === true`) while the request itself arrived over
|
||||
* plain HTTP. The browser silently drops a `Secure` cookie on an `http://`
|
||||
* origin, so the next request is unauthenticated and the user bounces back to
|
||||
* the login page with no error at all — it reads like a wrong password forever.
|
||||
*
|
||||
* Returns a human-readable message when the mismatch is detected, else `null`.
|
||||
* The caller logs it at login time (`console.warn` survives the prod
|
||||
* `console.*` strip) so an operator sees WHY login loops without having to find
|
||||
* the note buried in three docs. Non-fatal: the login still completes; the
|
||||
* cookie just won't stick until `SESSION_COOKIE_SECURE=false` is set (or TLS is
|
||||
* fronted).
|
||||
*
|
||||
* A request counts as HTTPS when `x-forwarded-proto` names https (the shape
|
||||
* every documented TLS reverse proxy sets) OR the request URL is already
|
||||
* https. A proxy that terminates TLS but omits `x-forwarded-proto` can produce
|
||||
* a benign false positive — the message names that case so it stays actionable
|
||||
* either way.
|
||||
*/
|
||||
export function detectInsecureCookieTransport(req: {
|
||||
headers: Headers;
|
||||
url: string;
|
||||
}): string | null {
|
||||
if (!shouldEmitSecureCookie()) return null;
|
||||
|
||||
// `x-forwarded-proto` can be a comma-separated proto chain; the left-most
|
||||
// entry is the client-facing scheme the browser actually spoke.
|
||||
const clientProto = req.headers
|
||||
.get("x-forwarded-proto")
|
||||
?.split(",")[0]
|
||||
?.trim()
|
||||
.toLowerCase();
|
||||
if (clientProto === "https") return null;
|
||||
|
||||
let urlIsHttps = false;
|
||||
try {
|
||||
urlIsHttps = new URL(req.url).protocol === "https:";
|
||||
} catch {
|
||||
urlIsHttps = false;
|
||||
}
|
||||
if (urlIsHttps) return null;
|
||||
|
||||
return (
|
||||
"This request arrived over plain HTTP but the session cookie is being " +
|
||||
"issued with the `Secure` flag — the browser will drop it and login will " +
|
||||
"loop back to the sign-in page with no error message. If you serve HTTP " +
|
||||
"directly (LAN / NAS / Tailscale, no TLS reverse proxy), set " +
|
||||
"SESSION_COOKIE_SECURE=false. If a reverse proxy terminates TLS in front " +
|
||||
"of this container, make sure it forwards `X-Forwarded-Proto: https`."
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,131 @@
|
||||
import { describe, it, expect } from "vitest";
|
||||
|
||||
import {
|
||||
collectReadiness,
|
||||
formatReadiness,
|
||||
logReadinessSummary,
|
||||
} from "../readiness-summary";
|
||||
|
||||
const HEX32 =
|
||||
"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
|
||||
|
||||
function baseEnv(): Record<string, string | undefined> {
|
||||
return {
|
||||
ENCRYPTION_KEY: HEX32,
|
||||
API_TOKEN_HMAC_KEY: HEX32,
|
||||
DATABASE_URL: "postgresql://healthlog:pw@db:5432/healthlog",
|
||||
NODE_ENV: "production",
|
||||
};
|
||||
}
|
||||
|
||||
function lineFor(env: Record<string, string | undefined>, label: string) {
|
||||
return collectReadiness(env).lines.find((l) => l.label === label);
|
||||
}
|
||||
|
||||
describe("collectReadiness — core secrets", () => {
|
||||
it("reports no blocker when the three core secrets are valid", () => {
|
||||
const report = collectReadiness(baseEnv());
|
||||
expect(report.hasBlocker).toBe(false);
|
||||
expect(lineFor(baseEnv(), "ENCRYPTION_KEY")?.status).toBe("ok");
|
||||
expect(lineFor(baseEnv(), "API_TOKEN_HMAC_KEY")?.status).toBe("ok");
|
||||
expect(lineFor(baseEnv(), "DATABASE_URL")?.status).toBe("ok");
|
||||
});
|
||||
|
||||
it("flags a missing ENCRYPTION_KEY as a blocker with the openssl fix", () => {
|
||||
const env = baseEnv();
|
||||
delete env.ENCRYPTION_KEY;
|
||||
const report = collectReadiness(env);
|
||||
expect(report.hasBlocker).toBe(true);
|
||||
const line = report.lines.find((l) => l.label === "ENCRYPTION_KEY");
|
||||
expect(line?.status).toBe("error");
|
||||
expect(line?.detail).toContain("openssl rand -hex 32");
|
||||
});
|
||||
|
||||
it("flags a too-short ENCRYPTION_KEY as a blocker", () => {
|
||||
const env = baseEnv();
|
||||
env.ENCRYPTION_KEY = "deadbeef";
|
||||
expect(collectReadiness(env).hasBlocker).toBe(true);
|
||||
});
|
||||
|
||||
it("accepts the ENCRYPTION_KEYS rotation map instead of the single key", () => {
|
||||
const env = baseEnv();
|
||||
delete env.ENCRYPTION_KEY;
|
||||
env.ENCRYPTION_KEYS = JSON.stringify({ v1: HEX32, v2: HEX32 });
|
||||
const report = collectReadiness(env);
|
||||
expect(report.hasBlocker).toBe(false);
|
||||
expect(
|
||||
report.lines.find((l) => l.label === "ENCRYPTION_KEYS")?.status,
|
||||
).toBe("ok");
|
||||
});
|
||||
|
||||
it("flags a malformed ENCRYPTION_KEYS map", () => {
|
||||
const env = baseEnv();
|
||||
delete env.ENCRYPTION_KEY;
|
||||
env.ENCRYPTION_KEYS = '{"v1":"nothex"}';
|
||||
expect(collectReadiness(env).hasBlocker).toBe(true);
|
||||
});
|
||||
|
||||
it("flags a missing DATABASE_URL", () => {
|
||||
const env = baseEnv();
|
||||
delete env.DATABASE_URL;
|
||||
expect(collectReadiness(env).hasBlocker).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe("collectReadiness — transport + optional", () => {
|
||||
it("warns Secure-on when NODE_ENV=production and no override", () => {
|
||||
const line = lineFor(baseEnv(), "SESSION_COOKIE_SECURE");
|
||||
expect(line?.detail).toContain("Secure cookie flag ON");
|
||||
});
|
||||
|
||||
it("notes Secure-off when SESSION_COOKIE_SECURE=false", () => {
|
||||
const env = { ...baseEnv(), SESSION_COOKIE_SECURE: "false" };
|
||||
expect(lineFor(env, "SESSION_COOKIE_SECURE")?.detail).toContain(
|
||||
"Secure cookie flag OFF",
|
||||
);
|
||||
});
|
||||
|
||||
it("marks optional subsystems as warn when unconfigured", () => {
|
||||
const smtp = lineFor(baseEnv(), "SMTP (email)");
|
||||
expect(smtp?.status).toBe("warn");
|
||||
});
|
||||
|
||||
it("marks off-host backup ok only when every required var is set", () => {
|
||||
const env = {
|
||||
...baseEnv(),
|
||||
BACKUP_S3_ENDPOINT: "https://r2",
|
||||
BACKUP_S3_BUCKET: "b",
|
||||
BACKUP_S3_ACCESS_KEY: "a",
|
||||
BACKUP_S3_SECRET_KEY: "s",
|
||||
BACKUP_ENCRYPTION_KEY: HEX32,
|
||||
};
|
||||
expect(lineFor(env, "Off-host backup")?.status).toBe("ok");
|
||||
});
|
||||
});
|
||||
|
||||
describe("formatReadiness + logReadinessSummary", () => {
|
||||
it("renders a header that flags a blocker", () => {
|
||||
const env = baseEnv();
|
||||
delete env.API_TOKEN_HMAC_KEY;
|
||||
const text = formatReadiness(collectReadiness(env));
|
||||
expect(text).toContain("CORE SECRET MISSING/INVALID");
|
||||
expect(text).toContain("✗ API_TOKEN_HMAC_KEY");
|
||||
});
|
||||
|
||||
it("logs blockers to error and healthy summaries to log; never throws", () => {
|
||||
const errors: string[] = [];
|
||||
const logs: string[] = [];
|
||||
const sink = {
|
||||
error: (m: string) => errors.push(m),
|
||||
log: (m: string) => logs.push(m),
|
||||
};
|
||||
logReadinessSummary(baseEnv(), sink);
|
||||
expect(logs).toHaveLength(1);
|
||||
expect(errors).toHaveLength(0);
|
||||
|
||||
const bad = baseEnv();
|
||||
delete bad.ENCRYPTION_KEY;
|
||||
logReadinessSummary(bad, sink);
|
||||
expect(errors).toHaveLength(1);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,197 @@
|
||||
/**
|
||||
* First-boot readiness summary.
|
||||
*
|
||||
* The bundled image promises "single `docker compose up`", but the reality is
|
||||
* three hand-generated secrets plus a handful of optional subsystems — and the
|
||||
* crypto loader is fail-closed, so a missing/short `ENCRYPTION_KEY` throws a
|
||||
* stack trace on first use rather than a sentence an operator can act on. This
|
||||
* module inspects the environment ONCE at boot and prints a compact,
|
||||
* human-readable readiness block: a clear line per core secret (with the exact
|
||||
* `openssl` fix on a bad one) before anything throws, plus a one-glance status
|
||||
* of the optional channels.
|
||||
*
|
||||
* It NEVER logs a secret value — only presence + shape validity. It never
|
||||
* throws: the fail-closed loaders remain the real gate; this is a friendlier
|
||||
* signpost in front of them.
|
||||
*/
|
||||
|
||||
export interface ReadinessLine {
|
||||
/** Short label, e.g. "ENCRYPTION_KEY". */
|
||||
label: string;
|
||||
/** ok = green, warn = optional-not-configured, error = missing/invalid core. */
|
||||
status: "ok" | "warn" | "error";
|
||||
/** One-line human detail (no secret material). */
|
||||
detail: string;
|
||||
}
|
||||
|
||||
export interface ReadinessReport {
|
||||
lines: ReadinessLine[];
|
||||
/** True when at least one core secret is missing or malformed. */
|
||||
hasBlocker: boolean;
|
||||
}
|
||||
|
||||
type Env = Record<string, string | undefined>;
|
||||
|
||||
/** A 64-char hex string (= 32 bytes) or a base64 string that decodes to 32 bytes. */
|
||||
function isValid32ByteKey(raw: string | undefined): boolean {
|
||||
if (!raw) return false;
|
||||
const v = raw.trim();
|
||||
if (/^[0-9a-fA-F]{64}$/.test(v)) return true;
|
||||
if (/^[A-Za-z0-9+/=]+$/.test(v)) {
|
||||
try {
|
||||
return Buffer.from(v, "base64").length === 32;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
function allSet(env: Env, keys: string[]): boolean {
|
||||
return keys.every((k) => (env[k] ?? "").trim().length > 0);
|
||||
}
|
||||
|
||||
function anySet(env: Env, keys: string[]): boolean {
|
||||
return keys.some((k) => (env[k] ?? "").trim().length > 0);
|
||||
}
|
||||
|
||||
/** Inspect the environment and build the readiness report. Pure + side-effect free. */
|
||||
export function collectReadiness(env: Env = process.env): ReadinessReport {
|
||||
const lines: ReadinessLine[] = [];
|
||||
|
||||
// --- Core secrets (boot blockers) ---------------------------------------
|
||||
// Encryption: the map form (ENCRYPTION_KEYS) supersedes the single key.
|
||||
const keysMap = (env.ENCRYPTION_KEYS ?? "").trim();
|
||||
let encryptionOk = false;
|
||||
if (keysMap) {
|
||||
try {
|
||||
const parsed = JSON.parse(keysMap) as Record<string, string>;
|
||||
const entries = Object.values(parsed ?? {});
|
||||
encryptionOk =
|
||||
entries.length > 0 && entries.every((v) => isValid32ByteKey(v));
|
||||
} catch {
|
||||
encryptionOk = false;
|
||||
}
|
||||
lines.push({
|
||||
label: "ENCRYPTION_KEYS",
|
||||
status: encryptionOk ? "ok" : "error",
|
||||
detail: encryptionOk
|
||||
? "key-rotation map present and valid"
|
||||
: "ENCRYPTION_KEYS is not a JSON map of valid 32-byte keys",
|
||||
});
|
||||
} else {
|
||||
encryptionOk = isValid32ByteKey(env.ENCRYPTION_KEY);
|
||||
lines.push({
|
||||
label: "ENCRYPTION_KEY",
|
||||
status: encryptionOk ? "ok" : "error",
|
||||
detail: encryptionOk
|
||||
? "present (64 hex chars)"
|
||||
: "missing or not 64 hex chars — generate with: openssl rand -hex 32",
|
||||
});
|
||||
}
|
||||
|
||||
const hmacOk = isValid32ByteKey(env.API_TOKEN_HMAC_KEY);
|
||||
lines.push({
|
||||
label: "API_TOKEN_HMAC_KEY",
|
||||
status: hmacOk ? "ok" : "error",
|
||||
detail: hmacOk
|
||||
? "present (64 hex chars)"
|
||||
: "missing or not 64 hex chars — generate with: openssl rand -hex 32",
|
||||
});
|
||||
|
||||
const dbOk = (env.DATABASE_URL ?? "").trim().length > 0;
|
||||
lines.push({
|
||||
label: "DATABASE_URL",
|
||||
status: dbOk ? "ok" : "error",
|
||||
detail: dbOk
|
||||
? "present"
|
||||
: "missing — the bundled compose derives it from POSTGRES_PASSWORD",
|
||||
});
|
||||
|
||||
// --- Transport hint (a warning, never a blocker) ------------------------
|
||||
const secureOverride = (env.SESSION_COOKIE_SECURE ?? "").trim().toLowerCase();
|
||||
const secureFlagOn =
|
||||
secureOverride === "true" ||
|
||||
(secureOverride !== "false" && env.NODE_ENV === "production");
|
||||
lines.push({
|
||||
label: "SESSION_COOKIE_SECURE",
|
||||
status: "ok",
|
||||
detail: secureFlagOn
|
||||
? "Secure cookie flag ON — serve HTTPS, or set SESSION_COOKIE_SECURE=false for a plain-HTTP LAN host"
|
||||
: "Secure cookie flag OFF — fine for plain-HTTP LAN; do NOT expose plain HTTP to the internet",
|
||||
});
|
||||
|
||||
// --- Optional subsystems (informational) --------------------------------
|
||||
const optional: Array<[string, boolean]> = [
|
||||
["SMTP (email)", allSet(env, ["SMTP_HOST", "SMTP_PORT", "SMTP_FROM"])],
|
||||
[
|
||||
"Off-host backup",
|
||||
allSet(env, [
|
||||
"BACKUP_S3_ENDPOINT",
|
||||
"BACKUP_S3_BUCKET",
|
||||
"BACKUP_S3_ACCESS_KEY",
|
||||
"BACKUP_S3_SECRET_KEY",
|
||||
"BACKUP_ENCRYPTION_KEY",
|
||||
]),
|
||||
],
|
||||
[
|
||||
"APNs (native iOS push)",
|
||||
allSet(env, ["APNS_KEY_ID", "APNS_TEAM_ID", "APNS_BUNDLE_ID"]) &&
|
||||
anySet(env, ["APNS_KEY_B64", "APNS_KEY", "APNS_KEY_FILE"]),
|
||||
],
|
||||
[
|
||||
"Web Push (VAPID env)",
|
||||
allSet(env, ["VAPID_PUBLIC_KEY", "VAPID_PRIVATE_KEY", "VAPID_SUBJECT"]),
|
||||
],
|
||||
];
|
||||
for (const [label, configured] of optional) {
|
||||
lines.push({
|
||||
label,
|
||||
status: configured ? "ok" : "warn",
|
||||
detail: configured ? "configured" : "not configured (optional)",
|
||||
});
|
||||
}
|
||||
|
||||
const hasBlocker = lines.some((l) => l.status === "error");
|
||||
return { lines, hasBlocker };
|
||||
}
|
||||
|
||||
const GLYPH: Record<ReadinessLine["status"], string> = {
|
||||
ok: "✓",
|
||||
warn: "·",
|
||||
error: "✗",
|
||||
};
|
||||
|
||||
/** Render the report as a compact multi-line block. */
|
||||
export function formatReadiness(report: ReadinessReport): string {
|
||||
const body = report.lines
|
||||
.map((l) => ` ${GLYPH[l.status]} ${l.label}: ${l.detail}`)
|
||||
.join("\n");
|
||||
const header = report.hasBlocker
|
||||
? "HealthLog boot readiness — CORE SECRET MISSING/INVALID (see ✗ below):"
|
||||
: "HealthLog boot readiness:";
|
||||
return `${header}\n${body}`;
|
||||
}
|
||||
|
||||
/**
|
||||
* Collect + print the readiness summary. Blockers go to stderr (they precede a
|
||||
* fail-closed throw), the healthy summary to stdout. Never throws.
|
||||
*/
|
||||
export function logReadinessSummary(
|
||||
env: Env = process.env,
|
||||
log: Pick<Console, "log" | "error"> = console,
|
||||
): ReadinessReport {
|
||||
try {
|
||||
const report = collectReadiness(env);
|
||||
const text = formatReadiness(report);
|
||||
if (report.hasBlocker) {
|
||||
log.error(text);
|
||||
} else {
|
||||
log.log(text);
|
||||
}
|
||||
return report;
|
||||
} catch {
|
||||
// A readiness summary must never be the thing that breaks boot.
|
||||
return { lines: [], hasBlocker: false };
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
import { describe, it, expect } from "vitest";
|
||||
|
||||
import { getNumberFormat, getDateTimeFormat } from "../formatter-cache";
|
||||
|
||||
describe("formatter-cache", () => {
|
||||
it("returns the same NumberFormat instance for identical (locale, options)", () => {
|
||||
const a = getNumberFormat("en", { maximumFractionDigits: 2 });
|
||||
const b = getNumberFormat("en", { maximumFractionDigits: 2 });
|
||||
expect(a).toBe(b);
|
||||
});
|
||||
|
||||
it("returns distinct NumberFormat instances for different options", () => {
|
||||
const a = getNumberFormat("en", { maximumFractionDigits: 2 });
|
||||
const b = getNumberFormat("en", { maximumFractionDigits: 0 });
|
||||
expect(a).not.toBe(b);
|
||||
});
|
||||
|
||||
it("returns distinct instances per locale", () => {
|
||||
const a = getNumberFormat("en", { maximumFractionDigits: 1 });
|
||||
const b = getNumberFormat("de", { maximumFractionDigits: 1 });
|
||||
expect(a).not.toBe(b);
|
||||
});
|
||||
|
||||
it("caches DateTimeFormat and still formats correctly", () => {
|
||||
const a = getDateTimeFormat("en-CA", {
|
||||
timeZone: "UTC",
|
||||
year: "numeric",
|
||||
month: "2-digit",
|
||||
day: "2-digit",
|
||||
});
|
||||
const b = getDateTimeFormat("en-CA", {
|
||||
timeZone: "UTC",
|
||||
year: "numeric",
|
||||
month: "2-digit",
|
||||
day: "2-digit",
|
||||
});
|
||||
expect(a).toBe(b);
|
||||
expect(a.format(new Date("2026-05-08T12:00:00Z"))).toBe("2026-05-08");
|
||||
});
|
||||
});
|
||||
Binary file not shown.
@@ -6,6 +6,7 @@ import {
|
||||
runOffhostBackup,
|
||||
runOffhostRoundtripTest,
|
||||
} from "../offhost-backup";
|
||||
import { MEASUREMENT_BACKUP_PAGE_SIZE } from "../backup/measurement-page";
|
||||
|
||||
const ENC_KEY =
|
||||
"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
|
||||
@@ -138,6 +139,56 @@ describe("runOffhostBackup", () => {
|
||||
expect(parsed.userId).toBe("u1");
|
||||
});
|
||||
|
||||
it("keyset-pages the intake/mood/cycle tables across multiple pages", async () => {
|
||||
const s3 = makeS3Mock();
|
||||
// A full first page (=== page size) followed by a short page proves the
|
||||
// reader walks the id cursor instead of one unbounded findMany.
|
||||
const fullPage = Array.from(
|
||||
{ length: MEASUREMENT_BACKUP_PAGE_SIZE },
|
||||
(_, i) => ({
|
||||
id: `e${String(i).padStart(5, "0")}`,
|
||||
userId: "u1",
|
||||
takenAt: new Date("2026-05-01T00:00:00Z"),
|
||||
}),
|
||||
);
|
||||
const tailPage = [
|
||||
{ id: "z9999", userId: "u1", takenAt: new Date("2026-05-02T00:00:00Z") },
|
||||
];
|
||||
const intakeFindMany = vi.fn(
|
||||
async (args: { where?: { id?: { gt?: string } } }) =>
|
||||
args?.where?.id?.gt ? tailPage : fullPage,
|
||||
);
|
||||
|
||||
const prisma = {
|
||||
user: { findMany: vi.fn().mockResolvedValue([{ id: "u1" }]) },
|
||||
measurement: { findMany: vi.fn().mockResolvedValue([]) },
|
||||
medication: { findMany: vi.fn().mockResolvedValue([]) },
|
||||
medicationIntakeEvent: { findMany: intakeFindMany },
|
||||
moodEntry: { findMany: vi.fn().mockResolvedValue([]) },
|
||||
cycleProfile: { findUnique: vi.fn().mockResolvedValue(null) },
|
||||
menstrualCycle: { findMany: vi.fn().mockResolvedValue([]) },
|
||||
cycleDayLog: { findMany: vi.fn().mockResolvedValue([]) },
|
||||
};
|
||||
|
||||
const report = await runOffhostBackup(
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
prisma as any,
|
||||
s3,
|
||||
new Date("2026-05-08T00:00:00Z"),
|
||||
);
|
||||
expect(report.uploaded).toBe(1);
|
||||
// Two round-trips: the full page, then the short tail that ends the walk.
|
||||
expect(intakeFindMany).toHaveBeenCalledTimes(2);
|
||||
expect(intakeFindMany.mock.calls[0][0]).toMatchObject({
|
||||
orderBy: { id: "asc" },
|
||||
take: MEASUREMENT_BACKUP_PAGE_SIZE,
|
||||
});
|
||||
// Every paged row lands in the decrypted payload — no rows dropped.
|
||||
const ct = s3.store.get("2026-05-08/user-u1.json.enc")!;
|
||||
const parsed = JSON.parse(decryptBackup(ct, Buffer.from(ENC_KEY, "hex")));
|
||||
expect(parsed.intakeEvents).toHaveLength(MEASUREMENT_BACKUP_PAGE_SIZE + 1);
|
||||
});
|
||||
|
||||
it("counts per-user failures without aborting the whole run", async () => {
|
||||
const s3 = makeS3Mock();
|
||||
const prisma = {
|
||||
|
||||
@@ -279,16 +279,70 @@ export async function runOffhostBackup(
|
||||
where: { userId: user.id },
|
||||
include: { schedules: true },
|
||||
}),
|
||||
prisma.medicationIntakeEvent.findMany({ where: { userId: user.id } }),
|
||||
prisma.moodEntry.findMany({ where: { userId: user.id } }),
|
||||
// The intake / mood / cycle tables scale with history depth the same
|
||||
// way measurements do (multiple intakes + a mood + a cycle-day-log per
|
||||
// day over years), so they get the same keyset-paged read: at most one
|
||||
// page is resident per round-trip instead of the entire table landing
|
||||
// in one array alongside the giant JSON.stringify below. The projection
|
||||
// keeps the full row (no select), so payload bytes are identical to the
|
||||
// prior default findMany — only peak heap during the read is bounded.
|
||||
collectPagedMeasurements({
|
||||
fetchPage: (afterId, take) =>
|
||||
prisma.medicationIntakeEvent.findMany({
|
||||
where: {
|
||||
userId: user.id,
|
||||
...(afterId ? { id: { gt: afterId } } : {}),
|
||||
},
|
||||
orderBy: { id: "asc" },
|
||||
take,
|
||||
}),
|
||||
project: (row) => row,
|
||||
pageSize: MEASUREMENT_BACKUP_PAGE_SIZE,
|
||||
}),
|
||||
collectPagedMeasurements({
|
||||
fetchPage: (afterId, take) =>
|
||||
prisma.moodEntry.findMany({
|
||||
where: {
|
||||
userId: user.id,
|
||||
...(afterId ? { id: { gt: afterId } } : {}),
|
||||
},
|
||||
orderBy: { id: "asc" },
|
||||
take,
|
||||
}),
|
||||
project: (row) => row,
|
||||
pageSize: MEASUREMENT_BACKUP_PAGE_SIZE,
|
||||
}),
|
||||
// v1.15.0 — cycle tables in the DR snapshot. Raw rows (this is a
|
||||
// disaster-recovery dump, not the canonical user-facing backup);
|
||||
// `notesEncrypted` stays ciphertext.
|
||||
// `notesEncrypted` stays ciphertext. The profile is a single row, so it
|
||||
// stays a direct read; the cycle + day-log tables are paged.
|
||||
prisma.cycleProfile.findUnique({ where: { userId: user.id } }),
|
||||
prisma.menstrualCycle.findMany({ where: { userId: user.id } }),
|
||||
prisma.cycleDayLog.findMany({
|
||||
where: { userId: user.id },
|
||||
include: { symptomLinks: true },
|
||||
collectPagedMeasurements({
|
||||
fetchPage: (afterId, take) =>
|
||||
prisma.menstrualCycle.findMany({
|
||||
where: {
|
||||
userId: user.id,
|
||||
...(afterId ? { id: { gt: afterId } } : {}),
|
||||
},
|
||||
orderBy: { id: "asc" },
|
||||
take,
|
||||
}),
|
||||
project: (row) => row,
|
||||
pageSize: MEASUREMENT_BACKUP_PAGE_SIZE,
|
||||
}),
|
||||
collectPagedMeasurements({
|
||||
fetchPage: (afterId, take) =>
|
||||
prisma.cycleDayLog.findMany({
|
||||
where: {
|
||||
userId: user.id,
|
||||
...(afterId ? { id: { gt: afterId } } : {}),
|
||||
},
|
||||
include: { symptomLinks: true },
|
||||
orderBy: { id: "asc" },
|
||||
take,
|
||||
}),
|
||||
project: (row) => row,
|
||||
pageSize: MEASUREMENT_BACKUP_PAGE_SIZE,
|
||||
}),
|
||||
]);
|
||||
|
||||
|
||||
Reference in new issue
Block a user