@checkstack/healthcheck-http-backend 0.2.5 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @checkstack/healthcheck-http-backend
 
+## 0.3.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.2.5
 
 ### Patch Changes

package/package.json

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

package/src/request-collector.test.ts

@@ -156,8 +156,8 @@ describe("RequestCollector", () => {
       let aggregated = collector.mergeResult(undefined, runs[0]);
       aggregated = collector.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.avgResponseTimeMs).toBe(75);
-      expect(aggregated.successRate).toBe(100);
+      expect(aggregated.avgResponseTimeMs.avg).toBe(75);
+      expect(aggregated.successRate.rate).toBe(100);
     });
 
     it("should calculate success rate correctly", () => {
@@ -199,7 +199,7 @@ describe("RequestCollector", () => {
       let aggregated = collector.mergeResult(undefined, runs[0]);
       aggregated = collector.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.successRate).toBe(50);
+      expect(aggregated.successRate.rate).toBe(50);
     });
   });
 

package/src/request-collector.ts

@@ -7,8 +7,10 @@ import {
   type CollectorStrategy,
   mergeAverage,
   mergeRate,
-  averageStateSchema,
-  rateStateSchema,
+  VersionedAggregated,
+  aggregatedAverage,
+  aggregatedRate,
+  type InferAggregatedResult,
 } from "@checkstack/backend-api";
 import {
   healthResultNumber,
@@ -80,32 +82,24 @@ const requestResultSchema = healthResultSchema({
 
 export type RequestResult = z.infer<typeof requestResultSchema>;
 
-// UI-visible aggregated fields (for charts)
-const requestAggregatedDisplaySchema = healthResultSchema({
-  avgResponseTimeMs: healthResultNumber({
+// Aggregated result fields definition
+const requestAggregatedFields = {
+  avgResponseTimeMs: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Response Time",
     "x-chart-unit": "ms",
   }),
-  successRate: healthResultNumber({
+  successRate: aggregatedRate({
     "x-chart-type": "gauge",
     "x-chart-label": "Success Rate",
     "x-chart-unit": "%",
   }),
-});
-
-// Internal state for incremental aggregation (not shown in charts)
-const requestAggregatedInternalSchema = z.object({
-  _responseTime: averageStateSchema.optional(),
-  _success: rateStateSchema.optional(),
-});
+};
 
-// Combined schema for storage
-const requestAggregatedSchema = requestAggregatedDisplaySchema.and(
-  requestAggregatedInternalSchema,
-);
-
-export type RequestAggregatedResult = z.infer<typeof requestAggregatedSchema>;
+// Type inferred automatically from field definitions
+export type RequestAggregatedResult = InferAggregatedResult<
+  typeof requestAggregatedFields
+>;
 
 // ============================================================================
 // REQUEST COLLECTOR
@@ -131,9 +125,9 @@ export class RequestCollector implements CollectorStrategy<
 
   config = new Versioned({ version: 1, schema: requestConfigSchema });
   result = new Versioned({ version: 1, schema: requestResultSchema });
-  aggregatedResult = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: requestAggregatedSchema,
+    fields: requestAggregatedFields,
   });
 
   async execute({
@@ -182,17 +176,12 @@ export class RequestCollector implements CollectorStrategy<
     existing: RequestAggregatedResult | undefined,
     newRun: HealthCheckRunForAggregation<RequestResult>,
   ): RequestAggregatedResult {
-    const responseTime = mergeAverage(
-      existing?._responseTime,
-      newRun.metadata?.responseTimeMs,
-    );
-    const success = mergeRate(existing?._success, newRun.metadata?.success);
-
     return {
-      avgResponseTimeMs: responseTime.avg,
-      successRate: success.rate,
-      _responseTime: responseTime,
-      _success: success,
+      avgResponseTimeMs: mergeAverage(
+        existing?.avgResponseTimeMs,
+        newRun.metadata?.responseTimeMs,
+      ),
+      successRate: mergeRate(existing?.successRate, newRun.metadata?.success),
     };
   }
 }

package/src/strategy.test.ts

@@ -218,7 +218,7 @@ describe("HttpHealthCheckStrategy", () => {
       aggregated = strategy.mergeResult(aggregated, runs[1]);
       aggregated = strategy.mergeResult(aggregated, runs[2]);
 
-      expect(aggregated.errorCount).toBe(2);
+      expect(aggregated.errorCount.count).toBe(2);
     });
 
     it("should return zero errors when all runs succeed", () => {
@@ -245,7 +245,7 @@ describe("HttpHealthCheckStrategy", () => {
       let aggregated = strategy.mergeResult(undefined, runs[0]);
       aggregated = strategy.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.errorCount).toBe(0);
+      expect(aggregated.errorCount.count).toBe(0);
     });
   });
 });

package/src/strategy.ts

@@ -2,12 +2,14 @@ import {
   HealthCheckStrategy,
   HealthCheckRunForAggregation,
   Versioned,
+  VersionedAggregated,
+  aggregatedCounter,
+  mergeCounter,
   z,
+  type InferAggregatedResult,
   type ConnectedClient,
-  mergeCounter,
 } from "@checkstack/backend-api";
 import {
-  healthResultNumber,
   healthResultString,
   healthResultSchema,
 } from "@checkstack/healthcheck-common";
@@ -58,15 +60,15 @@ const httpResultMetadataSchema = healthResultSchema({
 
 type HttpResultMetadata = z.infer<typeof httpResultMetadataSchema>;
 
-/** Aggregated metadata for buckets */
-const httpAggregatedMetadataSchema = healthResultSchema({
-  errorCount: healthResultNumber({
+/** Aggregated field definitions for bucket merging */
+const httpAggregatedFields = {
+  errorCount: aggregatedCounter({
     "x-chart-type": "counter",
     "x-chart-label": "Errors",
   }),
-});
+};
 
-type HttpAggregatedMetadata = z.infer<typeof httpAggregatedMetadataSchema>;
+type HttpAggregatedResult = InferAggregatedResult<typeof httpAggregatedFields>;
 
 // ============================================================================
 // STRATEGY
@@ -76,7 +78,7 @@ export class HttpHealthCheckStrategy implements HealthCheckStrategy<
   HttpHealthCheckConfig,
   HttpTransportClient,
   HttpResultMetadata,
-  HttpAggregatedMetadata
+  typeof httpAggregatedFields
 > {
   id = "http";
   displayName = "HTTP/HTTPS Health Check";
@@ -112,21 +114,18 @@ export class HttpHealthCheckStrategy implements HealthCheckStrategy<
     schema: httpResultMetadataSchema,
   });
 
-  aggregatedResult: Versioned<HttpAggregatedMetadata> = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: httpAggregatedMetadataSchema,
+    fields: httpAggregatedFields,
   });
 
   mergeResult(
-    existing: HttpAggregatedMetadata | undefined,
+    existing: HttpAggregatedResult | undefined,
     newRun: HealthCheckRunForAggregation<HttpResultMetadata>,
-  ): HttpAggregatedMetadata {
+  ): HttpAggregatedResult {
     const hasError = !!newRun.metadata?.error;
     return {
-      errorCount: mergeCounter(
-        existing ? { count: existing.errorCount } : undefined,
-        hasError,
-      ).count,
+      errorCount: mergeCounter(existing?.errorCount, hasError),
     };
   }