@checkstack/healthcheck-backend 1.17.0 → 1.19.0

package/src/service-batching.test.ts

@@ -0,0 +1,106 @@
+import { describe, it, expect, mock } from "bun:test";
+import { withTransactionMock } from "@checkstack/test-utils-backend";
+import { HealthCheckService } from "./service";
+
+/**
+ * Regression: `getSystemHealthStatus` batches its 1 (associations) + N
+ * (per-check run window) reads into ONE scoped transaction (see
+ * `withScopedTransaction`), so the whole read fan-out pays a single
+ * BEGIN/SET LOCAL/COMMIT and holds one connection instead of 1+N standalone
+ * scoped queries. This pins that the reads run inside `db.transaction(...)`
+ * (exactly once per call), independent of how many checks a system has.
+ */
+describe("HealthCheckService.getSystemHealthStatus - read batching", () => {
+  function createMockDb(configCount: number) {
+    const associations = Array.from({ length: configCount }, (_, i) => ({
+      configurationId: `config-${i}`,
+      configName: `Check ${i}`,
+      enabled: true,
+      paused: false,
+      stateThresholds: null,
+      // All-environments selector; each check has only the env-less slice below.
+      environmentIds: null,
+    }));
+    const assocWhere = mock(() => Promise.resolve(associations));
+    const assocInnerJoin = Object.assign(Promise.resolve([]), {
+      where: assocWhere,
+    });
+    const assocFrom = Object.assign(Promise.resolve([]), {
+      innerJoin: mock(() => assocInnerJoin),
+    });
+
+    // Each per-check run window returns one healthy run.
+    const healthyRun = [
+      { status: "healthy" as const, timestamp: new Date(), environmentId: null },
+    ];
+    const runsLimit = mock(() => Promise.resolve(healthyRun));
+    const runsOrderBy = mock(() => ({ limit: runsLimit }));
+    const runsWhere = mock(() => ({ orderBy: runsOrderBy, limit: runsLimit }));
+    const runsFrom = Object.assign(Promise.resolve(healthyRun), {
+      where: runsWhere,
+      orderBy: runsOrderBy,
+    });
+
+    // Distinct env keys query per check: a single env-less (null) slice.
+    const distinctFrom = Object.assign(Promise.resolve([]), {
+      where: mock(() => Promise.resolve([{ environmentId: null }])),
+    });
+
+    let selectCallCount = 0;
+    const db = withTransactionMock({
+      select: mock(() => {
+        selectCallCount += 1;
+        if (selectCallCount === 1) return { from: mock(() => assocFrom) };
+        return { from: mock(() => runsFrom) };
+      }),
+      selectDistinct: mock(() => ({ from: mock(() => distinctFrom) })),
+      insert: mock(() => ({ values: mock(() => Promise.resolve()) })),
+      update: mock(() => ({
+        set: mock(() => ({ where: mock(() => Promise.resolve()) })),
+      })),
+      delete: mock(() => ({ where: mock(() => Promise.resolve()) })),
+      execute: mock(() => Promise.resolve()),
+    });
+    return db;
+  }
+
+  it("wraps the associations + per-check reads in exactly ONE transaction", async () => {
+    const mockDb = createMockDb(3);
+    const service = new HealthCheckService(
+      mockDb as never,
+      {} as never,
+      {} as never,
+    );
+
+    const result = await service.getSystemHealthStatus("system-1");
+
+    expect(result.status).toBe("healthy");
+    expect(result.checkStatuses).toHaveLength(3);
+    // One transaction covers all 1 + N reads (not one per query).
+    const transaction = (mockDb as unknown as { transaction: ReturnType<typeof mock> })
+      .transaction;
+    expect(transaction).toHaveBeenCalledTimes(1);
+    // 1 associations select + 3 per-check run selects = 4 selects, all inside
+    // the single transaction.
+    const select = (mockDb as unknown as { select: ReturnType<typeof mock> })
+      .select;
+    expect(select).toHaveBeenCalledTimes(4);
+  });
+
+  it("still opens exactly one transaction for a system with no checks", async () => {
+    const mockDb = createMockDb(0);
+    const service = new HealthCheckService(
+      mockDb as never,
+      {} as never,
+      {} as never,
+    );
+
+    const result = await service.getSystemHealthStatus("system-1");
+
+    expect(result.status).toBe("healthy");
+    expect(result.checkStatuses).toHaveLength(0);
+    const transaction = (mockDb as unknown as { transaction: ReturnType<typeof mock> })
+      .transaction;
+    expect(transaction).toHaveBeenCalledTimes(1);
+  });
+});

package/src/service-bulk-counts.it.test.ts

@@ -0,0 +1,144 @@
+/**
+ * Integration test for `HealthCheckService.getBulkAssignedHealthCheckCounts`
+ * against a REAL Postgres. The method's whole point is the GROUP BY / COUNT and
+ * the zero-fill for systems with no rows - behaviour a mocked db cannot prove
+ * (the database does the grouping). These tests pin: counts are grouped per
+ * system, systems with no assignments report 0, requested-but-absent systems
+ * report 0, and non-requested systems never leak in.
+ *
+ * Gated on CHECKSTACK_IT so it runs in CI (shared compose Postgres) and is
+ * skipped in the default `bun test` run, matching the other *.it.test.ts here.
+ */
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "bun:test";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { Pool } from "pg";
+import type {
+  SafeDatabase,
+  HealthCheckRegistry,
+  CollectorRegistry,
+} from "@checkstack/backend-api";
+import * as schema from "./schema";
+import { HealthCheckService } from "./service";
+
+const PG_URL =
+  process.env.CHECKSTACK_IT_PG_URL ??
+  "postgres://postgres:postgres@localhost:5432/postgres";
+const SCHEMA = "healthcheck_it_bulk_counts";
+
+let admin: Pool;
+let pool: Pool;
+let service: HealthCheckService;
+
+async function insertAssignment(row: {
+  systemId: string;
+  configurationId: string;
+}): Promise<void> {
+  await pool.query(
+    `INSERT INTO "${SCHEMA}".system_health_checks (system_id, configuration_id)
+     VALUES ($1, $2)`,
+    [row.systemId, row.configurationId],
+  );
+}
+
+describe.skipIf(!process.env.CHECKSTACK_IT)(
+  "HealthCheckService.getBulkAssignedHealthCheckCounts (shared Postgres)",
+  () => {
+    beforeAll(async () => {
+      admin = new Pool({ connectionString: PG_URL });
+      await admin.query(`DROP SCHEMA IF EXISTS "${SCHEMA}" CASCADE`);
+      await admin.query(`CREATE SCHEMA "${SCHEMA}"`);
+      // Only the columns the grouped COUNT touches; no FK to configurations so
+      // the DDL stays minimal and focused on the aggregation behaviour.
+      await admin.query(
+        `CREATE TABLE "${SCHEMA}".system_health_checks (
+          system_id text NOT NULL,
+          configuration_id uuid NOT NULL,
+          PRIMARY KEY (system_id, configuration_id)
+        )`,
+      );
+      pool = new Pool({
+        connectionString: PG_URL,
+        options: `-c search_path=${SCHEMA}`,
+      });
+      const db = drizzle(pool, {
+        schema,
+      }) as unknown as SafeDatabase<typeof schema>;
+      // registry / collectorRegistry are unused by the count method under test;
+      // stub them so the constructor is satisfied without wiring real registries.
+      const service_ = new HealthCheckService(
+        db,
+        {} as unknown as HealthCheckRegistry,
+        {} as unknown as CollectorRegistry,
+      );
+      service = service_;
+    });
+
+    afterAll(async () => {
+      await pool?.end();
+      await admin.query(`DROP SCHEMA IF EXISTS "${SCHEMA}" CASCADE`);
+      await admin.end();
+    });
+
+    beforeEach(async () => {
+      await pool.query(`TRUNCATE "${SCHEMA}".system_health_checks`);
+    });
+
+    it("groups counts per system and zero-fills systems with no assignments", async () => {
+      // sys-a: 2 assignments, sys-b: 1, sys-c: none.
+      await insertAssignment({
+        systemId: "sys-a",
+        configurationId: crypto.randomUUID(),
+      });
+      await insertAssignment({
+        systemId: "sys-a",
+        configurationId: crypto.randomUUID(),
+      });
+      await insertAssignment({
+        systemId: "sys-b",
+        configurationId: crypto.randomUUID(),
+      });
+
+      const counts = await service.getBulkAssignedHealthCheckCounts([
+        "sys-a",
+        "sys-b",
+        "sys-c",
+      ]);
+
+      expect(counts).toEqual({ "sys-a": 2, "sys-b": 1, "sys-c": 0 });
+    });
+
+    it("returns 0 for a requested system that has no rows at all", async () => {
+      await insertAssignment({
+        systemId: "sys-a",
+        configurationId: crypto.randomUUID(),
+      });
+
+      const counts = await service.getBulkAssignedHealthCheckCounts([
+        "sys-a",
+        "missing",
+      ]);
+
+      expect(counts).toEqual({ "sys-a": 1, missing: 0 });
+    });
+
+    it("never leaks counts for systems not in the requested set", async () => {
+      await insertAssignment({
+        systemId: "sys-a",
+        configurationId: crypto.randomUUID(),
+      });
+      await insertAssignment({
+        systemId: "sys-other",
+        configurationId: crypto.randomUUID(),
+      });
+
+      const counts = await service.getBulkAssignedHealthCheckCounts(["sys-a"]);
+
+      expect(counts).toEqual({ "sys-a": 1 });
+      expect(Object.keys(counts)).not.toContain("sys-other");
+    });
+
+    it("returns an empty map for an empty request without querying", async () => {
+      expect(await service.getBulkAssignedHealthCheckCounts([])).toEqual({});
+    });
+  },
+);

package/src/service-bulk-run-stats.it.test.ts

@@ -0,0 +1,197 @@
+/**
+ * Integration test for `HealthCheckService.getBulkRunStats` against a REAL
+ * Postgres. The method's whole point is the single grouped read over
+ * `health_check_runs` for MANY systems, then per-system summarization - so each
+ * entry MUST be byte-identical to what the single `getRunStats({ systemId })`
+ * would return for the same window. A mocked db cannot prove the `inArray`
+ * grouping / windowing, so this real-DB guard pins the equivalence, the
+ * per-system isolation, and the "systems with no runs are omitted" behaviour
+ * the status-page uptime column relies on.
+ *
+ * Gated on CHECKSTACK_IT so it runs in CI (shared compose Postgres) and is
+ * skipped in the default `bun test` run, matching the other *.it.test.ts here.
+ */
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "bun:test";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { Pool } from "pg";
+import type {
+  SafeDatabase,
+  HealthCheckRegistry,
+  CollectorRegistry,
+} from "@checkstack/backend-api";
+import * as schema from "./schema";
+import { HealthCheckService } from "./service";
+
+const PG_URL =
+  process.env.CHECKSTACK_IT_PG_URL ??
+  "postgres://postgres:postgres@localhost:5432/postgres";
+const SCHEMA = "healthcheck_it_bulk_run_stats";
+
+const START = new Date("2026-06-01T00:00:00.000Z");
+const END = new Date("2026-06-01T23:59:59.000Z");
+
+let admin: Pool;
+let pool: Pool;
+let service: HealthCheckService;
+
+async function insertRun(row: {
+  systemId: string;
+  status: string;
+  latencyMs?: number | null;
+  at: string;
+  environmentId?: string | null;
+}): Promise<void> {
+  await pool.query(
+    `INSERT INTO "${SCHEMA}".health_check_runs
+       (id, configuration_id, system_id, environment_id, status, latency_ms, timestamp)
+     VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+    [
+      crypto.randomUUID(),
+      crypto.randomUUID(),
+      row.systemId,
+      row.environmentId ?? null,
+      row.status,
+      row.latencyMs ?? null,
+      row.at,
+    ],
+  );
+}
+
+describe.skipIf(!process.env.CHECKSTACK_IT)(
+  "HealthCheckService.getBulkRunStats (shared Postgres)",
+  () => {
+    beforeAll(async () => {
+      admin = new Pool({ connectionString: PG_URL });
+      await admin.query(`DROP SCHEMA IF EXISTS "${SCHEMA}" CASCADE`);
+      await admin.query(`CREATE SCHEMA "${SCHEMA}"`);
+      // Minimal DDL: only the columns the grouped read touches; status is plain
+      // text and configuration_id carries no FK, keeping the schema
+      // self-contained like the sibling *.it.test.ts files.
+      await admin.query(
+        `CREATE TABLE "${SCHEMA}".health_check_runs (
+          id uuid PRIMARY KEY,
+          configuration_id uuid NOT NULL,
+          system_id text NOT NULL,
+          environment_id text,
+          status text NOT NULL,
+          latency_ms integer,
+          result jsonb,
+          source_id text,
+          source_label text,
+          timestamp timestamp NOT NULL DEFAULT now()
+        )`,
+      );
+      pool = new Pool({
+        connectionString: PG_URL,
+        options: `-c search_path=${SCHEMA}`,
+      });
+      const db = drizzle(pool, {
+        schema,
+      }) as unknown as SafeDatabase<typeof schema>;
+      // registry / collectorRegistry are unused by the stats read under test;
+      // stub them so the constructor is satisfied.
+      service = new HealthCheckService(
+        db,
+        {} as unknown as HealthCheckRegistry,
+        {} as unknown as CollectorRegistry,
+      );
+    });
+
+    afterAll(async () => {
+      await pool?.end();
+      await admin.query(`DROP SCHEMA IF EXISTS "${SCHEMA}" CASCADE`);
+      await admin.end();
+    });
+
+    beforeEach(async () => {
+      await pool.query(`TRUNCATE "${SCHEMA}".health_check_runs`);
+    });
+
+    it("returns per-system stats identical to getRunStats for the same window", async () => {
+      // sys-a: 3 healthy + 1 unhealthy; sys-b: 2 healthy; sys-c: no runs.
+      await insertRun({ systemId: "sys-a", status: "healthy", latencyMs: 10, at: "2026-06-01T01:00:00Z" });
+      await insertRun({ systemId: "sys-a", status: "healthy", latencyMs: 20, at: "2026-06-01T02:00:00Z" });
+      await insertRun({ systemId: "sys-a", status: "healthy", latencyMs: 30, at: "2026-06-01T03:00:00Z" });
+      await insertRun({ systemId: "sys-a", status: "unhealthy", latencyMs: 40, at: "2026-06-01T04:00:00Z" });
+      await insertRun({ systemId: "sys-b", status: "healthy", latencyMs: 5, at: "2026-06-01T05:00:00Z" });
+      await insertRun({ systemId: "sys-b", status: "healthy", latencyMs: 7, at: "2026-06-01T06:00:00Z" });
+      // A run OUTSIDE the window must be ignored by both endpoints.
+      await insertRun({ systemId: "sys-a", status: "unhealthy", at: "2026-05-01T00:00:00Z" });
+
+      const ids = ["sys-a", "sys-b", "sys-c"];
+      const stats = await service.getBulkRunStats({
+        systemIds: ids,
+        startDate: START,
+        endDate: END,
+        maxBuckets: 24,
+      });
+
+      for (const systemId of ids) {
+        const single = await service.getRunStats({ systemId, startDate: START, endDate: END, maxBuckets: 24 });
+        if (single.total.runCount === 0) {
+          // Zero-run systems are omitted from the bulk record.
+          expect(stats[systemId]).toBeUndefined();
+        } else {
+          expect(stats[systemId]).toEqual(single);
+        }
+      }
+
+      // sys-c had no runs => omitted; only populated systems are keys.
+      expect(Object.keys(stats).toSorted()).toEqual(["sys-a", "sys-b"]);
+      // Sanity: sys-a uptime = 3/4 healthy = 75%.
+      expect(stats["sys-a"]?.total.uptimePct).toBe(75);
+    });
+
+    it("scopes uptime to the selected environments (status-page env filter)", async () => {
+      // sys-a: prod 2 healthy; staging 1 healthy + 1 unhealthy; env-less 1
+      // unhealthy. A prod-only page must count ONLY the two prod runs (100%),
+      // never the staging or env-less runs.
+      await insertRun({ systemId: "sys-a", status: "healthy", environmentId: "env-prod", at: "2026-06-01T01:00:00Z" });
+      await insertRun({ systemId: "sys-a", status: "healthy", environmentId: "env-prod", at: "2026-06-01T02:00:00Z" });
+      await insertRun({ systemId: "sys-a", status: "healthy", environmentId: "env-stage", at: "2026-06-01T03:00:00Z" });
+      await insertRun({ systemId: "sys-a", status: "unhealthy", environmentId: "env-stage", at: "2026-06-01T04:00:00Z" });
+      await insertRun({ systemId: "sys-a", status: "unhealthy", environmentId: null, at: "2026-06-01T05:00:00Z" });
+
+      const prodOnly = await service.getBulkRunStats({
+        systemIds: ["sys-a"],
+        startDate: START,
+        endDate: END,
+        environmentIds: ["env-prod"],
+        maxBuckets: 24,
+      });
+      expect(prodOnly["sys-a"]?.total.runCount).toBe(2);
+      expect(prodOnly["sys-a"]?.total.uptimePct).toBe(100);
+
+      // No env filter counts every run (5 total, 3 healthy = 60%).
+      const all = await service.getBulkRunStats({
+        systemIds: ["sys-a"],
+        startDate: START,
+        endDate: END,
+        maxBuckets: 24,
+      });
+      expect(all["sys-a"]?.total.runCount).toBe(5);
+      expect(all["sys-a"]?.total.uptimePct).toBe(60);
+
+      // getRunStats honors the same set filter for the single-system uptime widget.
+      const single = await service.getRunStats({
+        systemId: "sys-a",
+        startDate: START,
+        endDate: END,
+        environmentIds: ["env-prod", "env-stage"],
+        maxBuckets: 24,
+      });
+      expect(single.total.runCount).toBe(4);
+    });
+
+    it("returns an empty record for an empty request without querying", async () => {
+      expect(
+        await service.getBulkRunStats({
+          systemIds: [],
+          startDate: START,
+          endDate: END,
+          maxBuckets: 1,
+        }),
+      ).toEqual({});
+    });
+  },
+);

package/src/service-ordering.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, mock, beforeEach } from "bun:test";
 import type { InferSelectModel } from "drizzle-orm";
+import { withTransactionMock } from "@checkstack/test-utils-backend";
 import { HealthCheckService } from "./service";
 import {
   healthCheckRuns,
@@ -64,6 +65,10 @@ describe("HealthCheckService data ordering", () => {
     const whereMock = mock(() => ({
       orderBy: orderByMock,
       limit: mock(createLimitResult),
+      // getSystemHealthOverview's "last successful run" query terminates in
+      // `.where(...).groupBy(environmentId)` (a max-per-env aggregate). These
+      // ordering tests don't assert last-success, so return no groups.
+      groupBy: mock(() => Promise.resolve([])),
     }));
     const innerJoinMock = mock(() => ({
       where: mock(() => Promise.resolve([...mockAssociations])),
@@ -74,10 +79,13 @@ describe("HealthCheckService data ordering", () => {
       orderBy: orderByMock,
     }));
 
-    return {
+    // getSystemHealthOverview batches its reads in ONE scoped transaction, so
+    // the mock must expose `.transaction(cb)` (runs `cb` against the same mock
+    // db). getHistory/getDetailedHistory run standalone and ignore it.
+    return withTransactionMock({
       select: mock(() => ({ from: fromMock })),
       $count: mock(() => Promise.resolve(mockRuns.length)),
-    };
+    });
   }
 
   beforeEach(() => {

package/src/service-paused-filter.test.ts

@@ -1,4 +1,5 @@
 import { describe, it, expect, mock, beforeEach } from "bun:test";
+import { withTransactionMock } from "@checkstack/test-utils-backend";
 import { HealthCheckService } from "./service";
 
 /**
@@ -92,6 +93,12 @@ describe("HealthCheckService - paused configuration filtering", () => {
       })),
     });
 
+    // Distinct env keys query (rollup): resolves to no env slices for these
+    // fixtures (runs are empty), so the rollup has nothing to evaluate.
+    const distinctFrom = Object.assign(Promise.resolve([]), {
+      where: mock(() => Promise.resolve([])),
+    });
+
     let selectCallCount = 0;
     return {
       select: mock(() => {
@@ -103,6 +110,7 @@ describe("HealthCheckService - paused configuration filtering", () => {
         }
         return { from: mock(() => runsFrom) };
       }),
+      selectDistinct: mock(() => ({ from: mock(() => distinctFrom) })),
       insert: mock(() => ({
         values: mock(() => ({
           onConflictDoUpdate: mock(() => Promise.resolve()),
@@ -143,7 +151,7 @@ describe("HealthCheckService - paused configuration filtering", () => {
 
       const mockDb = createMockDb();
       const service = new HealthCheckService(
-        mockDb as never,
+        withTransactionMock(mockDb) as never,
         {} as never,
         {} as never,
       );
@@ -198,6 +206,11 @@ describe("HealthCheckService - paused configuration filtering", () => {
         orderBy: runsOrderBy,
       });
 
+      // Distinct env keys: a single env-less (null) slice for this env-less check.
+      const distinctFrom = Object.assign(Promise.resolve([]), {
+        where: mock(() => Promise.resolve([{ environmentId: null }])),
+      });
+
       let selectCallCount = 0;
       const mockDb = {
         select: mock(() => {
@@ -207,6 +220,7 @@ describe("HealthCheckService - paused configuration filtering", () => {
           }
           return { from: mock(() => runsFrom) };
         }),
+        selectDistinct: mock(() => ({ from: mock(() => distinctFrom) })),
         insert: mock(() => ({
           values: mock(() => ({
             onConflictDoUpdate: mock(() => Promise.resolve()),
@@ -222,7 +236,7 @@ describe("HealthCheckService - paused configuration filtering", () => {
       };
 
       const service = new HealthCheckService(
-        mockDb as never,
+        withTransactionMock(mockDb) as never,
         {} as never,
         {} as never,
       );
@@ -239,7 +253,7 @@ describe("HealthCheckService - paused configuration filtering", () => {
 
       const mockDb = createMockDb();
       const service = new HealthCheckService(
-        mockDb as never,
+        withTransactionMock(mockDb) as never,
         {} as never,
         {} as never,
       );
@@ -265,7 +279,7 @@ describe("HealthCheckService - paused configuration filtering", () => {
       };
 
       const service = new HealthCheckService(
-        mockDb as never,
+        withTransactionMock(mockDb) as never,
         {} as never,
         {} as never,
       );
@@ -285,7 +299,7 @@ describe("HealthCheckService - paused configuration filtering", () => {
       };
 
       const service = new HealthCheckService(
-        mockDb as never,
+        withTransactionMock(mockDb) as never,
         {} as never,
         {} as never,
       );
@@ -340,7 +354,13 @@ describe("HealthCheckService - paused configuration filtering", () => {
 
       const runsLimit = mock(() => Promise.resolve(emptyRuns));
       const runsOrderBy = mock(() => ({ limit: runsLimit }));
-      const runsWhere = mock(() => ({ orderBy: runsOrderBy, limit: runsLimit }));
+      // getSystemHealthOverview also runs a `.where(...).groupBy(env)` aggregate
+      // for the last-successful-run stamp; return no groups here.
+      const runsWhere = mock(() => ({
+        orderBy: runsOrderBy,
+        limit: runsLimit,
+        groupBy: mock(() => Promise.resolve([])),
+      }));
       const runsFrom = Object.assign(Promise.resolve(emptyRuns), {
         where: runsWhere,
         orderBy: runsOrderBy,
@@ -370,7 +390,7 @@ describe("HealthCheckService - paused configuration filtering", () => {
       };
 
       const service = new HealthCheckService(
-        mockDb as never,
+        withTransactionMock(mockDb) as never,
         {} as never,
         {} as never,
       );