@checkstack/healthcheck-http-backend 0.0.3 → 0.1.0

package/CHANGELOG.md

@@ -1,5 +1,62 @@
 # @checkstack/healthcheck-http-backend
 
+## 0.1.0
+
+### Minor Changes
+
+- f5b1f49: Refactored health check strategies to use `createClient()` pattern with built-in collectors.
+
+  **Strategy Changes:**
+
+  - Replaced `execute()` with `createClient()` that returns a transport client
+  - Strategy configs now only contain connection parameters
+  - Collector configs handle what to do with the connection
+
+  **Built-in Collectors Added:**
+
+  - DNS: `LookupCollector` for hostname resolution
+  - gRPC: `HealthCollector` for gRPC health protocol
+  - HTTP: `RequestCollector` for HTTP requests
+  - MySQL: `QueryCollector` for database queries
+  - Ping: `PingCollector` for ICMP ping
+  - Postgres: `QueryCollector` for database queries
+  - Redis: `CommandCollector` for Redis commands
+  - Script: `ExecuteCollector` for script execution
+  - SSH: `CommandCollector` for SSH commands
+  - TCP: `BannerCollector` for TCP banner grabbing
+  - TLS: `CertificateCollector` for certificate inspection
+
+### Patch Changes
+
+- f5b1f49: Added JSONPath assertions for response body validation and fully qualified strategy IDs.
+
+  **JSONPath Assertions:**
+
+  - Added `healthResultJSONPath()` factory in healthcheck-common for fields supporting JSONPath queries
+  - Extended AssertionBuilder with jsonpath field type showing path input (e.g., `$.data.status`)
+  - Added `jsonPath` field to `CollectorAssertionSchema` for persistence
+  - HTTP Request collector body field now supports JSONPath assertions
+
+  **Fully Qualified Strategy IDs:**
+
+  - HealthCheckRegistry now uses scoped factories like CollectorRegistry
+  - Strategies are stored with `pluginId.strategyId` format
+  - Added `getStrategiesWithMeta()` method to HealthCheckRegistry interface
+  - Router returns qualified IDs so frontend can correctly fetch collectors
+
+  **UI Improvements:**
+
+  - Save button disabled when collector configs have invalid required fields
+  - Fixed nested button warning in CollectorList accordion
+
+- Updated dependencies [f5b1f49]
+- Updated dependencies [f5b1f49]
+- Updated dependencies [f5b1f49]
+- Updated dependencies [f5b1f49]
+  - @checkstack/backend-api@0.1.0
+  - @checkstack/healthcheck-common@0.1.0
+  - @checkstack/common@0.0.3
+
 ## 0.0.3
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/healthcheck-http-backend",
-  "version": "0.0.3",
+  "version": "0.1.0",
   "type": "module",
   "main": "src/index.ts",
   "scripts": {

package/src/index.ts

@@ -1,9 +1,7 @@
-import {
-  createBackendPlugin,
-  coreServices,
-} from "@checkstack/backend-api";
+import { createBackendPlugin, coreServices } from "@checkstack/backend-api";
 import { HttpHealthCheckStrategy } from "./strategy";
 import { pluginMetadata } from "./plugin-metadata";
+import { RequestCollector } from "./request-collector";
 
 export default createBackendPlugin({
   metadata: pluginMetadata,
@@ -11,13 +9,17 @@ export default createBackendPlugin({
     env.registerInit({
       deps: {
         healthCheckRegistry: coreServices.healthCheckRegistry,
+        collectorRegistry: coreServices.collectorRegistry,
         logger: coreServices.logger,
       },
-      init: async ({ healthCheckRegistry, logger }) => {
+      init: async ({ healthCheckRegistry, collectorRegistry, logger }) => {
         logger.debug("🔌 Registering HTTP Health Check Strategy...");
         const strategy = new HttpHealthCheckStrategy();
         healthCheckRegistry.register(strategy);
+        collectorRegistry.register(new RequestCollector());
       },
     });
   },
 });
+
+export { pluginMetadata } from "./plugin-metadata";

package/src/request-collector.test.ts

@@ -0,0 +1,212 @@
+import { describe, expect, it, mock } from "bun:test";
+import { RequestCollector, type RequestConfig } from "./request-collector";
+import type { HttpTransportClient } from "./transport-client";
+
+describe("RequestCollector", () => {
+  const createMockClient = (
+    response: {
+      statusCode?: number;
+      statusText?: string;
+      body?: string;
+    } = {}
+  ): HttpTransportClient => ({
+    exec: mock(() =>
+      Promise.resolve({
+        statusCode: response.statusCode ?? 200,
+        statusText: response.statusText ?? "OK",
+        headers: {},
+        body: response.body ?? "",
+      })
+    ),
+  });
+
+  describe("execute", () => {
+    it("should execute HTTP request successfully", async () => {
+      const collector = new RequestCollector();
+      const client = createMockClient({
+        statusCode: 200,
+        statusText: "OK",
+        body: "Hello World",
+      });
+
+      const result = await collector.execute({
+        config: { url: "https://example.com", method: "GET", timeout: 5000 },
+        client,
+        pluginId: "test",
+      });
+
+      expect(result.result.statusCode).toBe(200);
+      expect(result.result.statusText).toBe("OK");
+      expect(result.result.success).toBe(true);
+      expect(result.result.bodyLength).toBe(11);
+      expect(result.result.responseTimeMs).toBeGreaterThanOrEqual(0);
+      expect(result.error).toBeUndefined();
+    });
+
+    it("should return error for failed requests", async () => {
+      const collector = new RequestCollector();
+      const client = createMockClient({
+        statusCode: 500,
+        statusText: "Internal Server Error",
+      });
+
+      const result = await collector.execute({
+        config: {
+          url: "https://example.com/error",
+          method: "GET",
+          timeout: 5000,
+        },
+        client,
+        pluginId: "test",
+      });
+
+      expect(result.result.statusCode).toBe(500);
+      expect(result.result.success).toBe(false);
+      expect(result.error).toContain("500");
+    });
+
+    it("should convert headers array to record", async () => {
+      const collector = new RequestCollector();
+      const client = createMockClient();
+
+      await collector.execute({
+        config: {
+          url: "https://example.com",
+          method: "POST",
+          timeout: 5000,
+          headers: [
+            { name: "Content-Type", value: "application/json" },
+            { name: "Authorization", value: "Bearer token" },
+          ],
+        },
+        client,
+        pluginId: "test",
+      });
+
+      expect(client.exec).toHaveBeenCalledWith(
+        expect.objectContaining({
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer token",
+          },
+        })
+      );
+    });
+
+    it("should pass body to client", async () => {
+      const collector = new RequestCollector();
+      const client = createMockClient();
+
+      await collector.execute({
+        config: {
+          url: "https://example.com",
+          method: "POST",
+          timeout: 5000,
+          body: '{"key":"value"}',
+        },
+        client,
+        pluginId: "test",
+      });
+
+      expect(client.exec).toHaveBeenCalledWith(
+        expect.objectContaining({
+          body: '{"key":"value"}',
+        })
+      );
+    });
+  });
+
+  describe("aggregateResult", () => {
+    it("should calculate average response time", () => {
+      const collector = new RequestCollector();
+      const runs = [
+        {
+          id: "1",
+          status: "healthy" as const,
+          latencyMs: 100,
+          checkId: "c1",
+          timestamp: new Date(),
+          metadata: {
+            statusCode: 200,
+            statusText: "OK",
+            responseTimeMs: 50,
+            body: "",
+            bodyLength: 100,
+            success: true,
+          },
+        },
+        {
+          id: "2",
+          status: "healthy" as const,
+          latencyMs: 150,
+          checkId: "c1",
+          timestamp: new Date(),
+          metadata: {
+            statusCode: 200,
+            statusText: "OK",
+            responseTimeMs: 100,
+            body: "",
+            bodyLength: 200,
+            success: true,
+          },
+        },
+      ];
+
+      const aggregated = collector.aggregateResult(runs);
+
+      expect(aggregated.avgResponseTimeMs).toBe(75);
+      expect(aggregated.successRate).toBe(100);
+    });
+
+    it("should calculate success rate correctly", () => {
+      const collector = new RequestCollector();
+      const runs = [
+        {
+          id: "1",
+          status: "healthy" as const,
+          latencyMs: 100,
+          checkId: "c1",
+          timestamp: new Date(),
+          metadata: {
+            statusCode: 200,
+            statusText: "OK",
+            responseTimeMs: 50,
+            body: "",
+            bodyLength: 100,
+            success: true,
+          },
+        },
+        {
+          id: "2",
+          status: "unhealthy" as const,
+          latencyMs: 150,
+          checkId: "c1",
+          timestamp: new Date(),
+          metadata: {
+            statusCode: 500,
+            statusText: "Error",
+            responseTimeMs: 100,
+            body: "",
+            bodyLength: 0,
+            success: false,
+          },
+        },
+      ];
+
+      const aggregated = collector.aggregateResult(runs);
+
+      expect(aggregated.successRate).toBe(50);
+    });
+  });
+
+  describe("metadata", () => {
+    it("should have correct static properties", () => {
+      const collector = new RequestCollector();
+
+      expect(collector.id).toBe("request");
+      expect(collector.displayName).toBe("HTTP Request");
+      expect(collector.allowMultiple).toBe(true);
+      expect(collector.supportedPlugins).toHaveLength(1);
+    });
+  });
+});

package/src/request-collector.ts

@@ -0,0 +1,186 @@
+import {
+  Versioned,
+  z,
+  type HealthCheckRunForAggregation,
+  type CollectorResult,
+  type CollectorStrategy,
+} from "@checkstack/backend-api";
+import {
+  healthResultNumber,
+  healthResultString,
+  healthResultBoolean,
+  healthResultJSONPath,
+} from "@checkstack/healthcheck-common";
+import { pluginMetadata } from "./plugin-metadata";
+import type { HttpTransportClient } from "./transport-client";
+
+// ============================================================================
+// CONFIGURATION SCHEMA
+// ============================================================================
+
+const requestConfigSchema = z.object({
+  url: z.string().url().describe("Full URL to request"),
+  method: z
+    .enum(["GET", "POST", "PUT", "DELETE", "HEAD"])
+    .default("GET")
+    .describe("HTTP method"),
+  headers: z
+    .array(z.object({ name: z.string(), value: z.string() }))
+    .optional()
+    .describe("Request headers"),
+  body: z.string().optional().describe("Request body"),
+  timeout: z
+    .number()
+    .min(100)
+    .default(30_000)
+    .describe("Timeout in milliseconds"),
+});
+
+export type RequestConfig = z.infer<typeof requestConfigSchema>;
+
+// ============================================================================
+// RESULT SCHEMAS
+// ============================================================================
+
+const requestResultSchema = z.object({
+  statusCode: healthResultNumber({
+    "x-chart-type": "counter",
+    "x-chart-label": "Status Code",
+  }),
+  statusText: healthResultString({
+    "x-chart-type": "text",
+    "x-chart-label": "Status",
+  }),
+  responseTimeMs: healthResultNumber({
+    "x-chart-type": "line",
+    "x-chart-label": "Response Time",
+    "x-chart-unit": "ms",
+  }),
+  body: healthResultJSONPath({}),
+  bodyLength: healthResultNumber({
+    "x-chart-type": "counter",
+    "x-chart-label": "Body Length",
+    "x-chart-unit": "bytes",
+  }),
+  success: healthResultBoolean({
+    "x-chart-type": "boolean",
+    "x-chart-label": "Success",
+  }),
+});
+
+export type RequestResult = z.infer<typeof requestResultSchema>;
+
+const requestAggregatedSchema = z.object({
+  avgResponseTimeMs: healthResultNumber({
+    "x-chart-type": "line",
+    "x-chart-label": "Avg Response Time",
+    "x-chart-unit": "ms",
+  }),
+  successRate: healthResultNumber({
+    "x-chart-type": "gauge",
+    "x-chart-label": "Success Rate",
+    "x-chart-unit": "%",
+  }),
+});
+
+export type RequestAggregatedResult = z.infer<typeof requestAggregatedSchema>;
+
+// ============================================================================
+// REQUEST COLLECTOR
+// ============================================================================
+
+/**
+ * Built-in HTTP request collector.
+ * Allows users to make HTTP requests and check responses.
+ */
+export class RequestCollector
+  implements
+    CollectorStrategy<
+      HttpTransportClient,
+      RequestConfig,
+      RequestResult,
+      RequestAggregatedResult
+    >
+{
+  id = "request";
+  displayName = "HTTP Request";
+  description = "Make an HTTP request and check the response";
+
+  supportedPlugins = [pluginMetadata];
+
+  allowMultiple = true;
+
+  config = new Versioned({ version: 1, schema: requestConfigSchema });
+  result = new Versioned({ version: 1, schema: requestResultSchema });
+  aggregatedResult = new Versioned({
+    version: 1,
+    schema: requestAggregatedSchema,
+  });
+
+  async execute({
+    config,
+    client,
+  }: {
+    config: RequestConfig;
+    client: HttpTransportClient;
+    pluginId: string;
+  }): Promise<CollectorResult<RequestResult>> {
+    const startTime = Date.now();
+
+    // Convert headers array to record
+    const headers: Record<string, string> = {};
+    for (const h of config.headers ?? []) {
+      headers[h.name] = h.value;
+    }
+
+    const response = await client.exec({
+      url: config.url,
+      method: config.method,
+      headers,
+      body: config.body,
+      timeout: config.timeout,
+    });
+
+    const responseTimeMs = Date.now() - startTime;
+    const success = response.statusCode >= 200 && response.statusCode < 400;
+
+    return {
+      result: {
+        statusCode: response.statusCode,
+        statusText: response.statusText,
+        responseTimeMs,
+        body: response.body ?? "",
+        bodyLength: response.body?.length ?? 0,
+        success,
+      },
+      error: success
+        ? undefined
+        : `HTTP ${response.statusCode}: ${response.statusText}`,
+    };
+  }
+
+  aggregateResult(
+    runs: HealthCheckRunForAggregation<RequestResult>[]
+  ): RequestAggregatedResult {
+    const times = runs
+      .map((r) => r.metadata?.responseTimeMs)
+      .filter((v): v is number => typeof v === "number");
+
+    const successes = runs
+      .map((r) => r.metadata?.success)
+      .filter((v): v is boolean => typeof v === "boolean");
+
+    const successCount = successes.filter(Boolean).length;
+
+    return {
+      avgResponseTimeMs:
+        times.length > 0
+          ? Math.round(times.reduce((a, b) => a + b, 0) / times.length)
+          : 0,
+      successRate:
+        successes.length > 0
+          ? Math.round((successCount / successes.length) * 100)
+          : 0,
+    };
+  }
+}