@checkstack/healthcheck-backend 0.11.0 → 0.12.1

package/CHANGELOG.md

@@ -1,5 +1,76 @@
 # @checkstack/healthcheck-backend
 
+## 0.12.1
+
+### Patch Changes
+
+- d1a2796: Enforce stricter code quality standards and eliminate AI slop anti-patterns.
+
+  **New utility**
+
+  - `extractErrorMessage(error, fallback?)` in `@checkstack/common` for consistent error extraction
+
+  **ESLint rules**
+
+  - `react-hooks/rules-of-hooks` and `exhaustive-deps` for hook correctness
+  - `no-console` in frontend packages — forces `toast` over silent `console.error`
+  - `no-restricted-syntax` banning `instanceof Error` — forces `extractErrorMessage`
+  - Custom `no-eslint-disable-any` rule preventing `@typescript-eslint/no-explicit-any` circumvention
+
+  **Refactoring**
+
+  - Replace 141 `instanceof Error` boilerplate patterns across the codebase
+  - Replace swallowed `console.error` with user-visible `toast.error()` feedback
+  - Remove 15 redundant `as` type casts in IntegrationsPage and ProviderConnectionsPage
+  - Consolidate 3 identical callback handlers into `handleDialogClose`
+  - Fix conditional React hook call in `FormField.tsx`
+  - Fix unstable useMemo deps in `Dashboard.tsx`
+  - Replace `useEffect`→`setState` with derived `useMemo` in `RegisterPage.tsx`
+  - Rewrite `keystore.test.ts` with typed `DrizzleMockChain` (eliminating 7 `any` suppressions)
+  - Delete obvious comments in `encryption.ts` and Teams `provider.ts`
+
+- Updated dependencies [d1a2796]
+- Updated dependencies [3c34b07]
+  - @checkstack/common@0.6.5
+  - @checkstack/backend-api@0.11.1
+  - @checkstack/catalog-backend@0.2.23
+  - @checkstack/integration-backend@0.1.18
+  - @checkstack/catalog-common@1.3.1
+  - @checkstack/healthcheck-common@0.10.1
+  - @checkstack/command-backend@0.1.18
+  - @checkstack/incident-common@0.4.7
+  - @checkstack/maintenance-common@0.4.9
+  - @checkstack/signal-common@0.1.9
+  - @checkstack/queue-api@0.2.12
+
+## 0.12.0
+
+### Minor Changes
+
+- 54a5f80: ### Health Check Editor Redesign — IDE-Style Experience
+
+  Replaces the modal-based health check editor with a full-page, IDE-style experience:
+
+  - **Strategy Picker Page**: New `/config/create` page with categorized strategy discovery, search filtering, and grouped card grid layout
+  - **IDE Editor Page**: New `/config/:configId/edit` page with a split-view layout — explorer tree on the left, editor panel on the right
+  - **Strategy Categories**: Introduces `StrategyCategory` enum with 16 categories (Networking, Database, Infrastructure, etc.) — all 13 strategy plugins now declare their category
+  - **New RPC Endpoint**: Added `getConfiguration` (singular by ID) for efficient single-resource fetching on the edit page
+  - **Explorer Tree**: Left-hand navigation with General, Check Items (collectors), and Access Control sections, with real-time validation indicators
+  - **Validation Status Bar**: Bottom bar showing aggregated validation issues with clickable navigation
+  - **Unsaved Changes Guard**: Browser `beforeunload` protection when the form is dirty
+  - **Responsive Design**: Split-view on desktop, stacked layout on mobile
+  - **Deleted**: Legacy `HealthCheckEditor.tsx` modal component
+
+### Patch Changes
+
+- Updated dependencies [54a5f80]
+  - @checkstack/healthcheck-common@0.10.0
+  - @checkstack/backend-api@0.11.0
+  - @checkstack/catalog-backend@0.2.22
+  - @checkstack/command-backend@0.1.17
+  - @checkstack/integration-backend@0.1.17
+  - @checkstack/queue-api@0.2.11
+
 ## 0.11.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/healthcheck-backend",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "type": "module",
   "main": "src/index.ts",
   "checkstack": {
@@ -13,16 +13,16 @@
     "lint:code": "eslint . --max-warnings 0"
   },
   "dependencies": {
-    "@checkstack/backend-api": "0.10.0",
-    "@checkstack/catalog-backend": "0.2.20",
-    "@checkstack/catalog-common": "1.2.11",
-    "@checkstack/command-backend": "0.1.15",
+    "@checkstack/backend-api": "0.11.0",
+    "@checkstack/catalog-backend": "0.2.22",
+    "@checkstack/catalog-common": "1.3.0",
+    "@checkstack/command-backend": "0.1.17",
     "@checkstack/common": "0.6.4",
-    "@checkstack/healthcheck-common": "0.8.4",
+    "@checkstack/healthcheck-common": "0.10.0",
     "@checkstack/incident-common": "0.4.6",
-    "@checkstack/integration-backend": "0.1.15",
+    "@checkstack/integration-backend": "0.1.17",
     "@checkstack/maintenance-common": "0.4.8",
-    "@checkstack/queue-api": "0.2.9",
+    "@checkstack/queue-api": "0.2.11",
     "@checkstack/signal-common": "0.1.8",
     "@hono/zod-validator": "^0.7.6",
     "drizzle-orm": "^0.45.0",
@@ -34,8 +34,8 @@
   "devDependencies": {
     "@checkstack/drizzle-helper": "0.0.4",
     "@checkstack/scripts": "0.1.2",
-    "@checkstack/test-utils-backend": "0.1.15",
-    "@checkstack/tsconfig": "0.0.4",
+    "@checkstack/test-utils-backend": "0.1.17",
+    "@checkstack/tsconfig": "0.0.5",
     "@types/bun": "^1.0.0",
     "@types/tdigest": "^0.1.5",
     "date-fns": "^4.1.0",

package/src/queue-executor.ts

@@ -27,7 +27,7 @@ import {
 import { CatalogApi, catalogRoutes } from "@checkstack/catalog-common";
 import { MaintenanceApi } from "@checkstack/maintenance-common";
 import { IncidentApi } from "@checkstack/incident-common";
-import { resolveRoute, type InferClient } from "@checkstack/common";
+import { resolveRoute, type InferClient, extractErrorMessage} from "@checkstack/common";
 import { HealthCheckService } from "./service";
 import { healthCheckHooks } from "./hooks";
 import { incrementHourlyAggregate } from "./realtime-aggregation";
@@ -400,7 +400,7 @@ async function executeHealthCheckJob(props: {
               };
             } catch (error) {
               const errorStr =
-                error instanceof Error ? error.message : String(error);
+                extractErrorMessage(error);
               logger.debug(`Collector ${storageKey} failed: ${errorStr}`);
               return {
                 storageKey,
@@ -465,7 +465,7 @@ async function executeHealthCheckJob(props: {
     } catch (error) {
       const latencyMs = Math.round(performance.now() - start);
       const caughtError =
-        error instanceof Error ? error.message : String(error);
+        extractErrorMessage(error);
 
       // Use a specific error message if available, otherwise use the caught error
       const finalError = errorMessage || caughtError;

package/src/router.test.ts

@@ -66,6 +66,7 @@ describe("HealthCheck Router", () => {
               id: "http",
               displayName: "HTTP",
               description: "Check HTTP",
+              category: "networking",
               config: {
                 version: 1,
                 schema: z.object({}),
@@ -97,6 +98,19 @@ describe("HealthCheck Router", () => {
     expect(Array.isArray(result.configurations)).toBe(true);
   });
 
+  it("getConfiguration returns undefined for non-existent config", async () => {
+    const context = createMockRpcContext({
+      user: mockUser,
+    });
+
+    const result = await call(
+      router.getConfiguration,
+      { id: "non-existent" },
+      { context },
+    );
+    expect(result).toBeUndefined();
+  });
+
   it("getCollectors returns collectors for strategy", async () => {
     const mockCollector = {
       qualifiedId: "collector-hardware.cpu",

package/src/router.ts

@@ -8,6 +8,7 @@ import {
   type CollectorRegistry,
 } from "@checkstack/backend-api";
 import { healthCheckContract } from "@checkstack/healthcheck-common";
+import type { StrategyCategory } from "@checkstack/healthcheck-common";
 import { HealthCheckService } from "./service";
 import * as schema from "./schema";
 import { toJsonSchemaWithChartMeta } from "./schema-utils";
@@ -37,6 +38,7 @@ export const createHealthCheckRouter = (
         id: r.qualifiedId, // Return fully qualified ID
         displayName: r.strategy.displayName,
         description: r.strategy.description,
+        category: (r.strategy.category ?? "other") as StrategyCategory,
         configSchema: toJsonSchema(r.strategy.config.schema),
         resultSchema: r.strategy.result
           ? toJsonSchemaWithChartMeta(r.strategy.result.schema)
@@ -87,6 +89,10 @@ export const createHealthCheckRouter = (
       return { configurations: await service.getConfigurations() };
     }),
 
+    getConfiguration: os.getConfiguration.handler(async ({ input }) => {
+      return service.getConfiguration(input.id);
+    }),
+
     createConfiguration: os.createConfiguration.handler(async ({ input }) => {
       return service.createConfiguration(input);
     }),
@@ -224,10 +230,6 @@ export const createHealthCheckRouter = (
         return service.getSystemHealthOverview(input.systemId);
       },
     ),
-
-    getAvailabilityStats: os.getAvailabilityStats.handler(async ({ input }) => {
-      return service.getAvailabilityStats(input);
-    }),
   });
 };
 

package/src/service.ts

@@ -12,10 +12,9 @@ import {
   healthCheckRuns,
   healthCheckAggregates,
   VersionedStateThresholds,
-  DEFAULT_RETENTION_CONFIG,
 } from "./schema";
 import * as schema from "./schema";
-import { eq, and, InferSelectModel, desc, gte, lte, lt } from "drizzle-orm";
+import { eq, and, InferSelectModel, desc, gte, lte } from "drizzle-orm";
 import { ORPCError } from "@orpc/server";
 import { evaluateHealthStatus } from "./state-evaluator";
 import { stateThresholds } from "./state-thresholds-migrations";
@@ -928,122 +927,6 @@ export class HealthCheckService {
    * Calculate bucket start time for dynamic interval sizing.
    * Aligns buckets to the query start time.
    */
-  /**
-   * Get availability statistics for a health check over 31-day and 365-day periods.
-   * Availability is calculated as (healthyCount / totalRunCount) * 100.
-   *
-   * With incremental real-time aggregation, hourly aggregates are always up-to-date
-   * (updated immediately on every run), so we don't need to query raw runs.
-   */
-  async getAvailabilityStats(props: {
-    systemId: string;
-    configurationId: string;
-  }): Promise<{
-    availability31Days: number | null;
-    availability365Days: number | null;
-    totalRuns31Days: number;
-    totalRuns365Days: number;
-  }> {
-    const { systemId, configurationId } = props;
-    const now = new Date();
-
-    // Get retention config to determine what data tiers are available
-    const { retentionConfig } = await this.getRetentionConfig(
-      systemId,
-      configurationId,
-    );
-    const config = retentionConfig ?? DEFAULT_RETENTION_CONFIG;
-
-    // Calculate cutoff dates
-    const cutoff31Days = new Date(now.getTime() - 31 * 24 * 60 * 60 * 1000);
-    const cutoff365Days = new Date(now.getTime() - 365 * 24 * 60 * 60 * 1000);
-
-    // Cutoff for hourly aggregates based on retention config
-    const hourlyCutoff = new Date(
-      now.getTime() - config.hourlyRetentionDays * 24 * 60 * 60 * 1000,
-    );
-
-    // Query hourly aggregates for the period they cover (up to hourlyRetentionDays)
-    // These are always up-to-date due to incremental real-time aggregation
-    const hourlyAggregates = await this.db
-      .select({
-        bucketStart: healthCheckAggregates.bucketStart,
-        runCount: healthCheckAggregates.runCount,
-        healthyCount: healthCheckAggregates.healthyCount,
-      })
-      .from(healthCheckAggregates)
-      .where(
-        and(
-          eq(healthCheckAggregates.systemId, systemId),
-          eq(healthCheckAggregates.configurationId, configurationId),
-          eq(healthCheckAggregates.bucketSize, "hourly"),
-          gte(healthCheckAggregates.bucketStart, hourlyCutoff),
-        ),
-      );
-
-    // Query daily aggregates for data beyond hourly retention
-    const dailyAggregates = await this.db
-      .select({
-        bucketStart: healthCheckAggregates.bucketStart,
-        runCount: healthCheckAggregates.runCount,
-        healthyCount: healthCheckAggregates.healthyCount,
-      })
-      .from(healthCheckAggregates)
-      .where(
-        and(
-          eq(healthCheckAggregates.systemId, systemId),
-          eq(healthCheckAggregates.configurationId, configurationId),
-          eq(healthCheckAggregates.bucketSize, "daily"),
-          gte(healthCheckAggregates.bucketStart, cutoff365Days),
-          lt(healthCheckAggregates.bucketStart, hourlyCutoff),
-        ),
-      );
-
-    // Aggregate counts
-    let totalRuns31Days = 0;
-    let healthyRuns31Days = 0;
-    let totalRuns365Days = 0;
-    let healthyRuns365Days = 0;
-
-    // Process hourly aggregates (fresh data within hourlyRetentionDays)
-    for (const agg of hourlyAggregates) {
-      totalRuns365Days += agg.runCount;
-      healthyRuns365Days += agg.healthyCount;
-
-      if (agg.bucketStart >= cutoff31Days) {
-        totalRuns31Days += agg.runCount;
-        healthyRuns31Days += agg.healthyCount;
-      }
-    }
-
-    // Process daily aggregates (older data beyond hourly retention)
-    for (const agg of dailyAggregates) {
-      totalRuns365Days += agg.runCount;
-      healthyRuns365Days += agg.healthyCount;
-
-      if (agg.bucketStart >= cutoff31Days) {
-        totalRuns31Days += agg.runCount;
-        healthyRuns31Days += agg.healthyCount;
-      }
-    }
-
-    // Calculate availability percentages
-    const availability31Days =
-      // eslint-disable-next-line unicorn/no-null -- RPC contract uses nullable()
-      totalRuns31Days > 0 ? (healthyRuns31Days / totalRuns31Days) * 100 : null;
-    const availability365Days =
-      totalRuns365Days > 0
-        ? (healthyRuns365Days / totalRuns365Days) * 100
-        : // eslint-disable-next-line unicorn/no-null -- RPC contract uses nullable()
-          null;
-
-    return {
-      availability31Days,
-      availability365Days,
-      totalRuns31Days,
-      totalRuns365Days,
-    };
-  }
 
   private getBucketStartDynamic(
     timestamp: Date,

package/src/availability.test.ts

@@ -1,236 +0,0 @@
-import { describe, it, expect, mock, beforeEach } from "bun:test";
-import { HealthCheckService } from "./service";
-import { subDays, subHours } from "date-fns";
-
-describe("HealthCheckService.getAvailabilityStats", () => {
-  // Mock database
-  let mockDb: ReturnType<typeof createMockDb>;
-  let service: HealthCheckService;
-
-  // Store mock data for different queries
-  let mockHourlyAggregates: Array<{
-    bucketStart: Date;
-    runCount: number;
-    healthyCount: number;
-  }> = [];
-  let mockDailyAggregates: Array<{
-    bucketStart: Date;
-    runCount: number;
-    healthyCount: number;
-  }> = [];
-  let mockRetentionConfig: { retentionConfig: unknown } | undefined = undefined;
-
-  function createMockDb() {
-    // Select call order for getAvailabilityStats:
-    // 1. getRetentionConfig (from systemHealthChecks) - uses .then() pattern
-    // 2. hourlyAggregates
-    // 3. dailyAggregates
-    let selectCallCount = 0;
-
-    const createSelectChain = () => {
-      const currentCall = selectCallCount++;
-
-      return {
-        from: mock(() => ({
-          where: mock(() => {
-            // Call 0: retentionConfig - uses .then() pattern
-            if (currentCall === 0) {
-              const result = mockRetentionConfig ? [mockRetentionConfig] : [];
-              // Return a promise-like object with .then()
-              return Promise.resolve(result);
-            }
-            // Call 1: hourly aggregates
-            if (currentCall === 1) return Promise.resolve(mockHourlyAggregates);
-            // Call 2: daily aggregates
-            return Promise.resolve(mockDailyAggregates);
-          }),
-        })),
-      };
-    };
-
-    return {
-      select: mock(createSelectChain),
-    };
-  }
-
-  beforeEach(() => {
-    // Reset mock data
-    mockHourlyAggregates = [];
-    mockDailyAggregates = [];
-    mockRetentionConfig = undefined;
-    mockDb = createMockDb();
-    service = new HealthCheckService(mockDb as never, {} as never, {} as never);
-  });
-
-  describe("with no data", () => {
-    it("returns null availability when no aggregates exist", async () => {
-      const result = await service.getAvailabilityStats({
-        systemId: "sys-1",
-        configurationId: "config-1",
-      });
-
-      expect(result.availability31Days).toBeNull();
-      expect(result.availability365Days).toBeNull();
-      expect(result.totalRuns31Days).toBe(0);
-      expect(result.totalRuns365Days).toBe(0);
-    });
-  });
-
-  describe("with hourly aggregates (real-time incremental)", () => {
-    it("calculates 100% availability when all runs are healthy", async () => {
-      mockHourlyAggregates = [
-        {
-          bucketStart: subHours(new Date(), 2),
-          runCount: 100,
-          healthyCount: 100,
-        },
-        {
-          bucketStart: subHours(new Date(), 5),
-          runCount: 100,
-          healthyCount: 100,
-        },
-      ];
-
-      const result = await service.getAvailabilityStats({
-        systemId: "sys-1",
-        configurationId: "config-1",
-      });
-
-      expect(result.availability31Days).toBe(100);
-      expect(result.availability365Days).toBe(100);
-      expect(result.totalRuns31Days).toBe(200);
-      expect(result.totalRuns365Days).toBe(200);
-    });
-
-    it("calculates correct availability with mixed results", async () => {
-      mockHourlyAggregates = [
-        {
-          bucketStart: subHours(new Date(), 2),
-          runCount: 100,
-          healthyCount: 90,
-        },
-        {
-          bucketStart: subHours(new Date(), 5),
-          runCount: 100,
-          healthyCount: 80,
-        },
-      ];
-
-      const result = await service.getAvailabilityStats({
-        systemId: "sys-1",
-        configurationId: "config-1",
-      });
-
-      // 170 healthy / 200 total = 85%
-      expect(result.availability31Days).toBe(85);
-      expect(result.availability365Days).toBe(85);
-    });
-
-    it("includes current hour data since aggregates are updated incrementally", async () => {
-      const currentHourStart = new Date();
-      currentHourStart.setMinutes(0, 0, 0);
-
-      mockHourlyAggregates = [
-        { bucketStart: currentHourStart, runCount: 10, healthyCount: 9 },
-      ];
-
-      const result = await service.getAvailabilityStats({
-        systemId: "sys-1",
-        configurationId: "config-1",
-      });
-
-      expect(result.totalRuns31Days).toBe(10);
-      expect(result.availability31Days).toBe(90);
-    });
-  });
-
-  describe("with combined hourly and daily aggregates", () => {
-    it("combines hourly and daily data correctly", async () => {
-      mockHourlyAggregates = [
-        {
-          bucketStart: subHours(new Date(), 2),
-          runCount: 100,
-          healthyCount: 99,
-        },
-      ];
-
-      mockDailyAggregates = [
-        {
-          bucketStart: subDays(new Date(), 60),
-          runCount: 100,
-          healthyCount: 50,
-        },
-      ];
-
-      const result = await service.getAvailabilityStats({
-        systemId: "sys-1",
-        configurationId: "config-1",
-      });
-
-      // 31 days: only hourly (99/100) = 99%
-      expect(result.availability31Days).toBe(99);
-      expect(result.totalRuns31Days).toBe(100);
-
-      // 365 days: (99+50)/200 = 74.5%
-      expect(result.availability365Days).toBe(74.5);
-      expect(result.totalRuns365Days).toBe(200);
-    });
-  });
-
-  describe("99.9% availability calculation", () => {
-    it("calculates precise availability for SLA tracking", async () => {
-      mockHourlyAggregates = [
-        {
-          bucketStart: subHours(new Date(), 5),
-          runCount: 1000,
-          healthyCount: 999,
-        },
-      ];
-
-      const result = await service.getAvailabilityStats({
-        systemId: "sys-1",
-        configurationId: "config-1",
-      });
-
-      expect(result.availability31Days).toBe(99.9);
-      expect(result.availability365Days).toBe(99.9);
-    });
-
-    it("calculates very high availability correctly", async () => {
-      mockHourlyAggregates = [
-        {
-          bucketStart: subHours(new Date(), 5),
-          runCount: 10_000,
-          healthyCount: 9999,
-        },
-      ];
-
-      const result = await service.getAvailabilityStats({
-        systemId: "sys-1",
-        configurationId: "config-1",
-      });
-
-      expect(result.availability31Days).toBe(99.99);
-    });
-  });
-
-  describe("real-time incremental aggregation behavior", () => {
-    it("uses hourly aggregates directly without raw run queries", async () => {
-      mockHourlyAggregates = [
-        {
-          bucketStart: subHours(new Date(), 1),
-          runCount: 50,
-          healthyCount: 48,
-        },
-      ];
-
-      const result = await service.getAvailabilityStats({
-        systemId: "sys-1",
-        configurationId: "config-1",
-      });
-
-      expect(result.availability31Days).toBe(96);
-      expect(result.totalRuns31Days).toBe(50);
-    });
-  });
-});