@checkstack/healthcheck-backend 1.1.4 → 1.3.0

package/src/service.ts

@@ -6,7 +6,18 @@ import {
   HealthCheckStatus,
   RetentionConfig,
   type HealthCheckRunResult,
+  type NotificationPolicy,
+  NotificationPolicySchema,
+  DEFAULT_NOTIFICATION_POLICY,
 } from "@checkstack/healthcheck-common";
+import type { ConfigService } from "@checkstack/backend-api";
+import type { InferClient } from "@checkstack/common";
+import type { CatalogApi } from "@checkstack/catalog-common";
+import {
+  notificationDefaultsConfigV1,
+  NOTIFICATION_DEFAULTS_CONFIG_ID,
+  NOTIFICATION_DEFAULTS_CONFIG_VERSION,
+} from "./notification-defaults-config";
 import {
   healthCheckConfigurations,
   systemHealthChecks,
@@ -15,7 +26,16 @@ import {
   VersionedStateThresholds,
 } from "./schema";
 import * as schema from "./schema";
-import { eq, and, InferSelectModel, desc, gte, lte, isNull } from "drizzle-orm";
+import {
+  eq,
+  and,
+  InferSelectModel,
+  desc,
+  gte,
+  lte,
+  isNull,
+  inArray,
+} from "drizzle-orm";
 import { ORPCError } from "@orpc/server";
 import { evaluateHealthStatus } from "./state-evaluator";
 import { stateThresholds } from "./state-thresholds-migrations";
@@ -38,6 +58,10 @@ import {
 // Drizzle type helper - uses SafeDatabase to prevent relational query API usage
 type Db = SafeDatabase<typeof schema>;
 
+// Catalog client type used to resolve human-readable system names for
+// satellite assignment run-context. Optional on the service.
+type CatalogClient = InferClient<typeof CatalogApi>;
+
 interface SystemCheckStatus {
   configurationId: string;
   configurationName: string;
@@ -57,8 +81,62 @@ export class HealthCheckService {
     private db: Db,
     private registry: HealthCheckRegistry,
     private collectorRegistry: CollectorRegistry,
+    /**
+     * Optional — only required by code paths that resolve platform
+     * defaults (notification policy fallback). When absent, callers
+     * fall back to the compile-time `DEFAULT_NOTIFICATION_POLICY`.
+     * Kept optional so existing GitOps-only / test constructions don't
+     * have to plumb it through.
+     */
+    private configService?: ConfigService,
+    /**
+     * Optional — used to resolve human-readable system names when building
+     * satellite assignment run-context. When absent (e.g. GitOps-only /
+     * test constructions), `systemName` falls back to the `systemId`.
+     */
+    private catalogClient?: CatalogClient,
   ) {}
 
+  /**
+   * Resolve the platform-wide notification policy defaults. Returns
+   * the compile-time defaults when no `configService` was provided or
+   * nothing has ever been persisted. Stored values are passed through
+   * the schema so missing fields default in.
+   */
+  async getPlatformNotificationDefaults(): Promise<NotificationPolicy> {
+    if (!this.configService) {
+      return DEFAULT_NOTIFICATION_POLICY;
+    }
+    const stored = await this.configService.get(
+      NOTIFICATION_DEFAULTS_CONFIG_ID,
+      notificationDefaultsConfigV1,
+      NOTIFICATION_DEFAULTS_CONFIG_VERSION,
+    );
+    return stored ?? DEFAULT_NOTIFICATION_POLICY;
+  }
+
+  /**
+   * Persist platform-wide notification policy defaults. Per-assignment
+   * rows with `notificationPolicy = null` will read the new defaults
+   * on their next evaluation. In-flight auto-incidents are unaffected
+   * (their cooldown is snapshotted per-row at open time).
+   */
+  async setPlatformNotificationDefaults(
+    policy: NotificationPolicy,
+  ): Promise<void> {
+    if (!this.configService) {
+      throw new Error(
+        "ConfigService not configured; cannot persist platform notification defaults",
+      );
+    }
+    await this.configService.set(
+      NOTIFICATION_DEFAULTS_CONFIG_ID,
+      notificationDefaultsConfigV1,
+      NOTIFICATION_DEFAULTS_CONFIG_VERSION,
+      policy,
+    );
+  }
+
   async createConfiguration(
     data: CreateHealthCheckConfiguration,
   ): Promise<HealthCheckConfiguration> {
@@ -133,6 +211,7 @@ export class HealthCheckService {
     stateThresholds?: StateThresholds;
     satelliteIds?: string[];
     includeLocal?: boolean;
+    notificationPolicy?: NotificationPolicy;
   }) {
     const {
       systemId,
@@ -141,6 +220,7 @@ export class HealthCheckService {
       stateThresholds: stateThresholds_,
       satelliteIds,
       includeLocal = true,
+      notificationPolicy,
     } = props;
 
     // Wrap thresholds in versioned config if provided
@@ -156,6 +236,7 @@ export class HealthCheckService {
         stateThresholds: versionedThresholds,
         satelliteIds: satelliteIds ?? undefined,
         includeLocal,
+        notificationPolicy: notificationPolicy ?? undefined,
       })
       .onConflictDoUpdate({
         target: [
@@ -167,11 +248,41 @@ export class HealthCheckService {
           stateThresholds: versionedThresholds,
           satelliteIds: satelliteIds ?? undefined,
           includeLocal,
+          notificationPolicy: notificationPolicy ?? undefined,
           updatedAt: new Date(),
         },
       });
   }
 
+  /**
+   * Flip the `enabled` flag on an existing `systemHealthChecks` row
+   * without touching any of the other configuration (thresholds,
+   * satellite assignment, notification policy). Returns `true` when a
+   * row was updated, `false` when the assignment doesn't exist.
+   *
+   * Carved out so the automation actions `enable_assignment` /
+   * `disable_assignment` don't have to round-trip through
+   * `associateSystem` (which would otherwise wipe operator-managed
+   * fields when invoked with a sparse partial).
+   */
+  async setAssignmentEnabled(
+    systemId: string,
+    configurationId: string,
+    enabled: boolean,
+  ): Promise<boolean> {
+    const result = await this.db
+      .update(systemHealthChecks)
+      .set({ enabled, updatedAt: new Date() })
+      .where(
+        and(
+          eq(systemHealthChecks.systemId, systemId),
+          eq(systemHealthChecks.configurationId, configurationId),
+        ),
+      )
+      .returning({ systemId: systemHealthChecks.systemId });
+    return result.length > 0;
+  }
+
   async disassociateSystem(systemId: string, configurationId: string) {
     await this.db
       .delete(systemHealthChecks)
@@ -282,6 +393,7 @@ export class HealthCheckService {
         stateThresholds: systemHealthChecks.stateThresholds,
         satelliteIds: systemHealthChecks.satelliteIds,
         includeLocal: systemHealthChecks.includeLocal,
+        notificationPolicy: systemHealthChecks.notificationPolicy,
       })
       .from(systemHealthChecks)
       .innerJoin(
@@ -304,11 +416,55 @@ export class HealthCheckService {
         stateThresholds: thresholds,
         satelliteIds: row.satelliteIds ?? undefined,
         includeLocal: row.includeLocal,
+        notificationPolicy: row.notificationPolicy ?? undefined,
       });
     }
     return results;
   }
 
+  /**
+   * Resolve the fully-defaulted notification policy for a single
+   * (system, configuration) association. Resolution order:
+   *
+   *   1. Per-assignment override (`systemHealthChecks.notificationPolicy`)
+   *      when non-null. Stored as a full policy; missing keys defaulted
+   *      via zod parse.
+   *   2. Platform-wide defaults via `ConfigService`.
+   *   3. Compile-time `DEFAULT_NOTIFICATION_POLICY`.
+   *
+   * The all-or-nothing semantic is intentional: assignment rows are
+   * either fully-overridden or fully-inherited from the platform.
+   * Operators can revert an override by setting the row's policy to
+   * `null`, which is the "Use platform defaults" action in the UI.
+   */
+  async getAssignmentNotificationPolicy({
+    systemId,
+    configurationId,
+  }: {
+    systemId: string;
+    configurationId: string;
+  }): Promise<NotificationPolicy> {
+    const [row] = await this.db
+      .select({
+        notificationPolicy: systemHealthChecks.notificationPolicy,
+      })
+      .from(systemHealthChecks)
+      .where(
+        and(
+          eq(systemHealthChecks.systemId, systemId),
+          eq(systemHealthChecks.configurationId, configurationId),
+        ),
+      )
+      .limit(1);
+
+    // No assignment row → use platform defaults (the only sensible
+    // value for a configuration nothing has explicitly touched).
+    if (!row || row.notificationPolicy === null) {
+      return this.getPlatformNotificationDefaults();
+    }
+    return NotificationPolicySchema.parse(row.notificationPolicy);
+  }
+
   /**
    * Get the evaluated health status for a system based on configured thresholds.
    * Aggregates status from all health check configurations for this system.
@@ -489,6 +645,7 @@ export class HealthCheckService {
     startDate?: Date;
     endDate?: Date;
     sourceFilter?: string;
+    statusFilter?: HealthCheckStatus[];
     limit?: number;
     offset?: number;
     sortOrder: "asc" | "desc";
@@ -499,6 +656,7 @@ export class HealthCheckService {
       startDate,
       endDate,
       sourceFilter,
+      statusFilter,
       limit = 10,
       offset = 0,
       sortOrder,
@@ -518,6 +676,11 @@ export class HealthCheckService {
       conditions.push(eq(healthCheckRuns.sourceId, sourceFilter));
     }
 
+    // Status filtering (e.g. only failing runs)
+    if (statusFilter && statusFilter.length > 0) {
+      conditions.push(inArray(healthCheckRuns.status, statusFilter));
+    }
+
     // Build where clause
     const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
 
@@ -563,6 +726,7 @@ export class HealthCheckService {
     startDate?: Date;
     endDate?: Date;
     sourceFilter?: string;
+    statusFilter?: HealthCheckStatus[];
     limit?: number;
     offset?: number;
     sortOrder: "asc" | "desc";
@@ -573,6 +737,7 @@ export class HealthCheckService {
       startDate,
       endDate,
       sourceFilter,
+      statusFilter,
       limit = 10,
       offset = 0,
       sortOrder,
@@ -592,6 +757,11 @@ export class HealthCheckService {
       conditions.push(eq(healthCheckRuns.sourceId, sourceFilter));
     }
 
+    // Status filtering (e.g. only failing runs)
+    if (statusFilter && statusFilter.length > 0) {
+      conditions.push(inArray(healthCheckRuns.status, statusFilter));
+    }
+
     const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
     const total = await this.db.$count(healthCheckRuns, whereClause);
 
@@ -1068,6 +1238,27 @@ export class HealthCheckService {
 
     if (matchingAssociations.length === 0) return [];
 
+    // Resolve human-readable system names once per distinct systemId.
+    // Falls back to the systemId when no catalog client is wired or the
+    // lookup fails, mirroring the queue-executor's resolution behaviour.
+    const systemNameCache = new Map<string, string>();
+    const resolveSystemName = async (systemId: string): Promise<string> => {
+      const cached = systemNameCache.get(systemId);
+      if (cached !== undefined) return cached;
+
+      let systemName = systemId;
+      if (this.catalogClient) {
+        try {
+          const system = await this.catalogClient.getSystem({ systemId });
+          if (system) systemName = system.name;
+        } catch {
+          // Fall back to systemId if catalog lookup fails.
+        }
+      }
+      systemNameCache.set(systemId, systemName);
+      return systemName;
+    };
+
     // Get configurations for each matching association
     const assignments = [];
     for (const assoc of matchingAssociations) {
@@ -1085,6 +1276,9 @@ export class HealthCheckService {
         config: config.config,
         collectors: config.collectors ?? undefined,
         intervalSeconds: config.intervalSeconds,
+        // Curated run-context metadata exposed to satellite collectors.
+        configName: config.name,
+        systemName: await resolveSystemName(assoc.systemId),
       });
     }
 

package/tsconfig.json

@@ -4,6 +4,9 @@
     "src"
   ],
   "references": [
+    {
+      "path": "../automation-backend"
+    },
     {
       "path": "../backend-api"
     },
@@ -38,10 +41,10 @@
       "path": "../healthcheck-common"
     },
     {
-      "path": "../incident-common"
+      "path": "../incident-backend"
     },
     {
-      "path": "../integration-backend"
+      "path": "../incident-common"
     },
     {
       "path": "../maintenance-common"