@checkstack/healthcheck-backend 0.5.0 → 0.7.0

package/src/service-pause.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect, mock, beforeEach } from "bun:test";
+import { HealthCheckService } from "./service";
+import { createMockDb } from "@checkstack/test-utils-backend";
+
+describe("HealthCheckService - pause/resume", () => {
+  let mockDb: ReturnType<typeof createMockDb>;
+  let service: HealthCheckService;
+  let mockUpdate: ReturnType<typeof mock>;
+  let mockSet: ReturnType<typeof mock>;
+  let mockWhere: ReturnType<typeof mock>;
+
+  beforeEach(() => {
+    mockDb = createMockDb();
+    mockWhere = mock(() => Promise.resolve());
+    mockSet = mock(() => ({ where: mockWhere }));
+    mockUpdate = mock(() => ({ set: mockSet }));
+    (mockDb.update as any) = mockUpdate;
+    service = new HealthCheckService(mockDb as any);
+  });
+
+  describe("pauseConfiguration", () => {
+    it("should update paused to true and set updatedAt", async () => {
+      await service.pauseConfiguration("config-123");
+
+      expect(mockUpdate).toHaveBeenCalled();
+      expect(mockSet).toHaveBeenCalledWith(
+        expect.objectContaining({
+          paused: true,
+          updatedAt: expect.any(Date),
+        }),
+      );
+      expect(mockWhere).toHaveBeenCalled();
+    });
+  });
+
+  describe("resumeConfiguration", () => {
+    it("should update paused to false and set updatedAt", async () => {
+      await service.resumeConfiguration("config-456");
+
+      expect(mockUpdate).toHaveBeenCalled();
+      expect(mockSet).toHaveBeenCalledWith(
+        expect.objectContaining({
+          paused: false,
+          updatedAt: expect.any(Date),
+        }),
+      );
+      expect(mockWhere).toHaveBeenCalled();
+    });
+  });
+});

package/src/service.ts

@@ -105,6 +105,20 @@ export class HealthCheckService {
       .where(eq(healthCheckConfigurations.id, id));
   }
 
+  async pauseConfiguration(id: string): Promise<void> {
+    await this.db
+      .update(healthCheckConfigurations)
+      .set({ paused: true, updatedAt: new Date() })
+      .where(eq(healthCheckConfigurations.id, id));
+  }
+
+  async resumeConfiguration(id: string): Promise<void> {
+    await this.db
+      .update(healthCheckConfigurations)
+      .set({ paused: false, updatedAt: new Date() })
+      .where(eq(healthCheckConfigurations.id, id));
+  }
+
   async getConfigurations(): Promise<HealthCheckConfiguration[]> {
     const configs = await this.db.select().from(healthCheckConfigurations);
     return configs.map((c) => this.mapConfig(c));
@@ -400,7 +414,7 @@ export class HealthCheckService {
     const sparklineLimit = 25;
 
     for (const assoc of associations) {
-      // Get last 25 runs for sparkline
+      // Get last 25 runs for sparkline (newest first, then reverse for chronological display)
       const runs = await this.db
         .select({
           id: healthCheckRuns.id,
@@ -417,15 +431,18 @@ export class HealthCheckService {
         .orderBy(desc(healthCheckRuns.timestamp))
         .limit(sparklineLimit);
 
+      // Reverse to chronological order (oldest first) for sparkline display
+      const chronologicalRuns = runs.toReversed();
+
       // Migrate and extract thresholds
       let thresholds: StateThresholds | undefined;
       if (assoc.stateThresholds) {
         thresholds = await stateThresholds.parse(assoc.stateThresholds);
       }
 
-      // Evaluate current status
+      // Evaluate current status (runs are in DESC order - newest first - as evaluateHealthStatus expects)
       const status = evaluateHealthStatus({
-        runs: runs as Array<{ status: HealthCheckStatus; timestamp: Date }>,
+        runs,
         thresholds,
       });
 
@@ -437,7 +454,7 @@ export class HealthCheckService {
         enabled: assoc.enabled,
         status,
         stateThresholds: thresholds,
-        recentRuns: runs.map((r) => ({
+        recentRuns: chronologicalRuns.map((r) => ({
           id: r.id,
           status: r.status,
           timestamp: r.timestamp,
@@ -450,6 +467,7 @@ export class HealthCheckService {
 
   /**
    * Get paginated health check run history (public - no result data).
+   * @param sortOrder - 'asc' for chronological (oldest first), 'desc' for reverse (newest first)
    */
   async getHistory(props: {
     systemId?: string;
@@ -458,6 +476,7 @@ export class HealthCheckService {
     endDate?: Date;
     limit?: number;
     offset?: number;
+    sortOrder: "asc" | "desc";
   }) {
     const {
       systemId,
@@ -466,6 +485,7 @@ export class HealthCheckService {
       endDate,
       limit = 10,
       offset = 0,
+      sortOrder,
     } = props;
 
     const conditions = [];
@@ -481,16 +501,17 @@ export class HealthCheckService {
     // Get total count using drizzle $count
     const total = await this.db.$count(healthCheckRuns, whereClause);
 
-    // Get paginated runs
+    // Get paginated runs with requested sort order
     let query = this.db.select().from(healthCheckRuns);
     if (whereClause) {
       // @ts-expect-error drizzle-orm type mismatch
       query = query.where(whereClause);
     }
-    const runs = await query
-      .orderBy(desc(healthCheckRuns.timestamp))
-      .limit(limit)
-      .offset(offset);
+    const orderColumn =
+      sortOrder === "desc"
+        ? desc(healthCheckRuns.timestamp)
+        : healthCheckRuns.timestamp;
+    const runs = await query.orderBy(orderColumn).limit(limit).offset(offset);
 
     // Return without result field for public access (latencyMs is public data)
     return {
@@ -509,6 +530,7 @@ export class HealthCheckService {
   /**
    * Get detailed health check run history with full result data.
    * Restricted to users with manage access.
+   * @param sortOrder - 'asc' for chronological (oldest first), 'desc' for reverse (newest first)
    */
   async getDetailedHistory(props: {
     systemId?: string;
@@ -517,6 +539,7 @@ export class HealthCheckService {
     endDate?: Date;
     limit?: number;
     offset?: number;
+    sortOrder: "asc" | "desc";
   }) {
     const {
       systemId,
@@ -525,6 +548,7 @@ export class HealthCheckService {
       endDate,
       limit = 10,
       offset = 0,
+      sortOrder,
     } = props;
 
     const conditions = [];
@@ -542,10 +566,11 @@ export class HealthCheckService {
       // @ts-expect-error drizzle-orm type mismatch
       query = query.where(whereClause);
     }
-    const runs = await query
-      .orderBy(desc(healthCheckRuns.timestamp))
-      .limit(limit)
-      .offset(offset);
+    const orderColumn =
+      sortOrder === "desc"
+        ? desc(healthCheckRuns.timestamp)
+        : healthCheckRuns.timestamp;
+    const runs = await query.orderBy(orderColumn).limit(limit).offset(offset);
 
     // Return with full result data for manage access
     return {
@@ -562,6 +587,32 @@ export class HealthCheckService {
     };
   }
 
+  /**
+   * Get a single health check run by its ID.
+   */
+  async getRunById(props: { runId: string }) {
+    const run = await this.db
+      .select()
+      .from(healthCheckRuns)
+      .where(eq(healthCheckRuns.id, props.runId))
+      .limit(1);
+
+    if (run.length === 0) {
+      return;
+    }
+
+    const r = run[0];
+    return {
+      id: r.id,
+      configurationId: r.configurationId,
+      systemId: r.systemId,
+      status: r.status,
+      result: r.result ?? {},
+      timestamp: r.timestamp,
+      latencyMs: r.latencyMs ?? undefined,
+    };
+  }
+
   /**
    * Get aggregated health check history with dynamically-sized buckets.
    * Queries all three tiers (raw, hourly, daily) and merges with priority.
@@ -704,6 +755,7 @@ export class HealthCheckService {
       sourceBuckets: mergedBuckets,
       targetIntervalMs: bucketIntervalMs,
       rangeStart: startDate,
+      rangeEnd: endDate,
     });
 
     // Convert to output format
@@ -717,6 +769,7 @@ export class HealthCheckService {
 
       const baseBucket = {
         bucketStart: bucket.bucketStart,
+        bucketEnd: new Date(bucket.bucketEndMs),
         bucketIntervalSeconds,
         runCount: bucket.runCount,
         healthyCount: bucket.healthyCount,
@@ -884,6 +937,7 @@ export class HealthCheckService {
       config: row.config,
       collectors: row.collectors ?? undefined,
       intervalSeconds: row.intervalSeconds,
+      paused: row.paused,
       createdAt: row.createdAt,
       updatedAt: row.updatedAt,
     };