@checkstack/healthcheck-tls-backend 0.1.14 → 0.2.1

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # @checkstack/healthcheck-tls-backend
 
+## 0.2.1
+
+### Patch Changes
+
+- 869b4ab: ## Health Check Execution Improvements
+
+  ### Breaking Changes (backend-api)
+
+  - `HealthCheckStrategy.createClient()` now accepts `unknown` instead of `TConfig` due to TypeScript contravariance constraints. Implementations should use `this.config.validate(config)` to narrow the type.
+
+  ### Features
+
+  - **Platform-level hard timeout**: The executor now wraps the entire health check execution (connection + all collectors) in a single timeout, ensuring checks never hang indefinitely.
+  - **Parallel collector execution**: Collectors now run in parallel using `Promise.allSettled()`, improving performance while ensuring all collectors complete regardless of individual failures.
+  - **Base strategy config schema**: All strategy configs now extend `baseStrategyConfigSchema` which provides a standardized `timeout` field with sensible defaults (30s, min 100ms).
+
+  ### Fixes
+
+  - Fixed HTTP and Jenkins strategies clearing timeouts before reading the full response body.
+  - Simplified registry type signatures by using default type parameters.
+
+- Updated dependencies [869b4ab]
+  - @checkstack/backend-api@0.8.0
+
+## 0.2.0
+
+### Minor Changes
+
+- 3dd1914: Migrate health check strategies to VersionedAggregated with \_type discriminator
+
+  All 13 health check strategies now use `VersionedAggregated` for their `aggregatedResult` property, enabling automatic bucket merging with 100% mathematical fidelity.
+
+  **Key changes:**
+
+  - **`_type` discriminator**: All aggregated state objects now include a required `_type` field (`"average"`, `"rate"`, `"counter"`, `"minmax"`) for reliable type detection
+  - The `HealthCheckStrategy` interface now requires `aggregatedResult` to be a `VersionedAggregated<AggregatedResultShape>`
+  - Strategy/collector `mergeResult` methods return state objects with `_type` (e.g., `{ _type: "average", _sum, _count, avg }`)
+  - `mergeAggregatedBucketResults`, `combineBuckets`, and `reaggregateBuckets` now require `registry` and `strategyId` parameters
+  - `HealthCheckService` constructor now requires both `registry` and `collectorRegistry` parameters
+  - Frontend `extractComputedValue` now uses `_type` discriminator for robust type detection
+
+  **Breaking Change**: State objects now require `_type`. Merge functions automatically add `_type` to output. The bucket merging functions and `HealthCheckService` now require additional required parameters.
+
+### Patch Changes
+
+- Updated dependencies [3dd1914]
+  - @checkstack/backend-api@0.7.0
+
 ## 0.1.14
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/healthcheck-tls-backend",
-  "version": "0.1.14",
+  "version": "0.2.1",
   "type": "module",
   "main": "src/index.ts",
   "scripts": {
@@ -9,9 +9,9 @@
     "lint:code": "eslint . --max-warnings 0"
   },
   "dependencies": {
-    "@checkstack/backend-api": "0.5.2",
-    "@checkstack/common": "0.6.1",
-    "@checkstack/healthcheck-common": "0.8.1"
+    "@checkstack/backend-api": "0.7.0",
+    "@checkstack/common": "0.6.2",
+    "@checkstack/healthcheck-common": "0.8.2"
   },
   "devDependencies": {
     "@types/bun": "^1.0.0",

package/src/certificate-collector.test.ts

@@ -115,8 +115,8 @@ describe("CertificateCollector", () => {
       let aggregated = collector.mergeResult(undefined, runs[0]);
       aggregated = collector.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.avgDaysRemaining).toBe(45);
-      expect(aggregated.validRate).toBe(100);
+      expect(aggregated.avgDaysRemaining.avg).toBe(45);
+      expect(aggregated.validRate.rate).toBe(100);
     });
 
     it("should calculate valid rate correctly", () => {
@@ -157,7 +157,7 @@ describe("CertificateCollector", () => {
       let aggregated = collector.mergeResult(undefined, runs[0]);
       aggregated = collector.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.validRate).toBe(50);
+      expect(aggregated.validRate.rate).toBe(50);
     });
   });
 

package/src/certificate-collector.ts

@@ -5,11 +5,11 @@ import {
   type CollectorResult,
   type CollectorStrategy,
   mergeAverage,
-  averageStateSchema,
   mergeRate,
-  rateStateSchema,
-  type AverageState,
-  type RateState,
+  VersionedAggregated,
+  aggregatedAverage,
+  aggregatedRate,
+  type InferAggregatedResult,
 } from "@checkstack/backend-api";
 import {
   healthResultNumber,
@@ -64,32 +64,23 @@ const certificateResultSchema = healthResultSchema({
 
 export type CertificateResult = z.infer<typeof certificateResultSchema>;
 
-const certificateAggregatedDisplaySchema = healthResultSchema({
-  avgDaysRemaining: healthResultNumber({
+// Aggregated result fields definition
+const certificateAggregatedFields = {
+  avgDaysRemaining: aggregatedAverage({
     "x-chart-type": "gauge",
     "x-chart-label": "Avg Days Remaining",
     "x-chart-unit": "days",
   }),
-  validRate: healthResultNumber({
+  validRate: aggregatedRate({
     "x-chart-type": "gauge",
     "x-chart-label": "Valid Rate",
     "x-chart-unit": "%",
   }),
-});
-
-const certificateAggregatedInternalSchema = z.object({
-  _daysRemaining: averageStateSchema
-    .optional(),
-  _valid: rateStateSchema
-    .optional(),
-});
+};
 
-const certificateAggregatedSchema = certificateAggregatedDisplaySchema.merge(
-  certificateAggregatedInternalSchema,
-);
-
-export type CertificateAggregatedResult = z.infer<
-  typeof certificateAggregatedSchema
+// Type inferred from field definitions
+export type CertificateAggregatedResult = InferAggregatedResult<
+  typeof certificateAggregatedFields
 >;
 
 // ============================================================================
@@ -116,9 +107,9 @@ export class CertificateCollector implements CollectorStrategy<
 
   config = new Versioned({ version: 1, schema: certificateConfigSchema });
   result = new Versioned({ version: 1, schema: certificateResultSchema });
-  aggregatedResult = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: certificateAggregatedSchema,
+    fields: certificateAggregatedFields,
   });
 
   async execute({
@@ -162,21 +153,12 @@ export class CertificateCollector implements CollectorStrategy<
   ): CertificateAggregatedResult {
     const metadata = run.metadata;
 
-    const daysState = mergeAverage(
-      existing?._daysRemaining as AverageState | undefined,
-      metadata?.daysRemaining,
-    );
-
-    const validState = mergeRate(
-      existing?._valid as RateState | undefined,
-      metadata?.valid,
-    );
-
     return {
-      avgDaysRemaining: daysState.avg,
-      validRate: validState.rate,
-      _daysRemaining: daysState,
-      _valid: validState,
+      avgDaysRemaining: mergeAverage(
+        existing?.avgDaysRemaining,
+        metadata?.daysRemaining,
+      ),
+      validRate: mergeRate(existing?.validRate, metadata?.valid),
     };
   }
 }

package/src/strategy.test.ts

@@ -207,10 +207,10 @@ describe("TlsHealthCheckStrategy", () => {
       let aggregated = strategy.mergeResult(undefined, runs[0]);
       aggregated = strategy.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.avgDaysUntilExpiry).toBe(25);
-      expect(aggregated.minDaysUntilExpiry).toBe(20);
-      expect(aggregated.invalidCount).toBe(0);
-      expect(aggregated.errorCount).toBe(0);
+      expect(aggregated.avgDaysUntilExpiry.avg).toBe(25);
+      expect(aggregated.minDaysUntilExpiry.min).toBe(20);
+      expect(aggregated.invalidCount.count).toBe(0);
+      expect(aggregated.errorCount.count).toBe(0);
     });
 
     it("should count invalid and errors", () => {
@@ -256,8 +256,8 @@ describe("TlsHealthCheckStrategy", () => {
       let aggregated = strategy.mergeResult(undefined, runs[0]);
       aggregated = strategy.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.invalidCount).toBe(2);
-      expect(aggregated.errorCount).toBe(1);
+      expect(aggregated.invalidCount.count).toBe(2);
+      expect(aggregated.errorCount.count).toBe(1);
     });
   });
 });

package/src/strategy.ts

@@ -3,16 +3,17 @@ import {
   HealthCheckStrategy,
   HealthCheckRunForAggregation,
   Versioned,
-  z,
-  type ConnectedClient,
+  VersionedAggregated,
+  aggregatedAverage,
+  aggregatedMinMax,
+  aggregatedCounter,
   mergeAverage,
-  averageStateSchema,
   mergeCounter,
-  counterStateSchema,
   mergeMinMax,
-  type AverageState,
-  type CounterState,
-  type MinMaxState,
+  z,
+  type ConnectedClient,
+  type InferAggregatedResult,
+  baseStrategyConfigSchema,
 } from "@checkstack/backend-api";
 import {
   healthResultBoolean,
@@ -33,18 +34,13 @@ import type {
 /**
  * Configuration schema for TLS health checks.
  */
-export const tlsConfigSchema = z.object({
+export const tlsConfigSchema = baseStrategyConfigSchema.extend({
   host: z.string().describe("Hostname to connect to"),
   port: z.number().int().min(1).max(65_535).default(443).describe("TLS port"),
   servername: z
     .string()
     .optional()
     .describe("Server name for SNI (defaults to host)"),
-  timeout: z
-    .number()
-    .min(100)
-    .default(10_000)
-    .describe("Connection timeout in milliseconds"),
   minDaysUntilExpiry: z
     .number()
     .int()
@@ -88,44 +84,29 @@ const tlsResultSchema = healthResultSchema({
 
 type TlsResult = z.infer<typeof tlsResultSchema>;
 
-/**
- * Aggregated metadata for buckets.
- */
-const tlsAggregatedDisplaySchema = healthResultSchema({
-  avgDaysUntilExpiry: healthResultNumber({
+/** Aggregated field definitions for bucket merging */
+const tlsAggregatedFields = {
+  avgDaysUntilExpiry: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Days Until Expiry",
     "x-chart-unit": "days",
   }),
-  minDaysUntilExpiry: healthResultNumber({
+  minDaysUntilExpiry: aggregatedMinMax({
     "x-chart-type": "line",
     "x-chart-label": "Min Days Until Expiry",
     "x-chart-unit": "days",
   }),
-  invalidCount: healthResultNumber({
+  invalidCount: aggregatedCounter({
     "x-chart-type": "counter",
     "x-chart-label": "Invalid Certificates",
   }),
-  errorCount: healthResultNumber({
+  errorCount: aggregatedCounter({
     "x-chart-type": "counter",
     "x-chart-label": "Errors",
   }),
-});
-
-const tlsAggregatedInternalSchema = z.object({
-  _daysUntilExpiry: averageStateSchema.optional(),
-  _minDaysUntilExpiry: z
-    .object({ min: z.number(), max: z.number() })
-    .optional(),
-  _invalid: counterStateSchema.optional(),
-  _errors: counterStateSchema.optional(),
-});
-
-const tlsAggregatedSchema = tlsAggregatedDisplaySchema.merge(
-  tlsAggregatedInternalSchema,
-);
+};
 
-type TlsAggregatedResult = z.infer<typeof tlsAggregatedSchema>;
+type TlsAggregatedResult = InferAggregatedResult<typeof tlsAggregatedFields>;
 
 // ============================================================================
 // TLS CLIENT INTERFACE (for testability)
@@ -197,7 +178,7 @@ export class TlsHealthCheckStrategy implements HealthCheckStrategy<
   TlsConfig,
   TlsTransportClient,
   TlsResult,
-  TlsAggregatedResult
+  typeof tlsAggregatedFields
 > {
   id = "tls";
   displayName = "TLS/SSL Health Check";
@@ -235,9 +216,9 @@ export class TlsHealthCheckStrategy implements HealthCheckStrategy<
     ],
   });
 
-  aggregatedResult: Versioned<TlsAggregatedResult> = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: tlsAggregatedSchema,
+    fields: tlsAggregatedFields,
   });
 
   mergeResult(
@@ -246,36 +227,23 @@ export class TlsHealthCheckStrategy implements HealthCheckStrategy<
   ): TlsAggregatedResult {
     const metadata = run.metadata;
 
-    const daysState = mergeAverage(
-      existing?._daysUntilExpiry as AverageState | undefined,
+    const avgDaysUntilExpiry = mergeAverage(
+      existing?.avgDaysUntilExpiry,
       metadata?.daysUntilExpiry,
     );
 
-    const minDaysState = mergeMinMax(
-      existing?._minDaysUntilExpiry as MinMaxState | undefined,
+    const minDaysUntilExpiry = mergeMinMax(
+      existing?.minDaysUntilExpiry,
       metadata?.daysUntilExpiry,
     );
 
-    const invalidState = mergeCounter(
-      existing?._invalid as CounterState | undefined,
-      metadata?.isValid === false,
-    );
+    const isInvalid = metadata?.isValid === false;
+    const invalidCount = mergeCounter(existing?.invalidCount, isInvalid);
 
-    const errorState = mergeCounter(
-      existing?._errors as CounterState | undefined,
-      metadata?.error !== undefined,
-    );
+    const hasError = metadata?.error !== undefined;
+    const errorCount = mergeCounter(existing?.errorCount, hasError);
 
-    return {
-      avgDaysUntilExpiry: daysState.avg,
-      minDaysUntilExpiry: minDaysState.min,
-      invalidCount: invalidState.count,
-      errorCount: errorState.count,
-      _daysUntilExpiry: daysState,
-      _minDaysUntilExpiry: minDaysState,
-      _invalid: invalidState,
-      _errors: errorState,
-    };
+    return { avgDaysUntilExpiry, minDaysUntilExpiry, invalidCount, errorCount };
   }
 
   async createClient(