@checkstack/healthcheck-script-backend 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @checkstack/healthcheck-script-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.0
 
 ### Minor Changes

package/package.json

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

package/src/execute-collector.test.ts

@@ -139,8 +139,8 @@ describe("ExecuteCollector", () => {
       let aggregated = collector.mergeResult(undefined, runs[0]);
       aggregated = collector.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.avgExecutionTimeMs).toBe(75);
-      expect(aggregated.successRate).toBe(100);
+      expect(aggregated.avgExecutionTimeMs.avg).toBe(75);
+      expect(aggregated.successRate.rate).toBe(100);
     });
 
     it("should calculate success rate correctly", () => {
@@ -181,7 +181,7 @@ describe("ExecuteCollector", () => {
       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/execute-collector.ts

@@ -6,11 +6,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,
@@ -78,29 +78,24 @@ const executeResultSchema = healthResultSchema({
 
 export type ExecuteResult = z.infer<typeof executeResultSchema>;
 
-const executeAggregatedDisplaySchema = healthResultSchema({
-  avgExecutionTimeMs: healthResultNumber({
+// Aggregated result fields definition
+const executeAggregatedFields = {
+  avgExecutionTimeMs: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Execution Time",
     "x-chart-unit": "ms",
   }),
-  successRate: healthResultNumber({
+  successRate: aggregatedRate({
     "x-chart-type": "gauge",
     "x-chart-label": "Success Rate",
     "x-chart-unit": "%",
   }),
-});
-
-const executeAggregatedInternalSchema = z.object({
-  _executionTime: averageStateSchema.optional(),
-  _success: rateStateSchema.optional(),
-});
+};
 
-const executeAggregatedSchema = executeAggregatedDisplaySchema.merge(
-  executeAggregatedInternalSchema,
-);
-
-export type ExecuteAggregatedResult = z.infer<typeof executeAggregatedSchema>;
+// Type inferred from field definitions
+export type ExecuteAggregatedResult = InferAggregatedResult<
+  typeof executeAggregatedFields
+>;
 
 // ============================================================================
 // EXECUTE COLLECTOR
@@ -126,9 +121,9 @@ export class ExecuteCollector implements CollectorStrategy<
 
   config = new Versioned({ version: 1, schema: executeConfigSchema });
   result = new Versioned({ version: 1, schema: executeResultSchema });
-  aggregatedResult = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: executeAggregatedSchema,
+    fields: executeAggregatedFields,
   });
 
   async execute({
@@ -173,21 +168,12 @@ export class ExecuteCollector implements CollectorStrategy<
   ): ExecuteAggregatedResult {
     const metadata = run.metadata;
 
-    const executionTimeState = mergeAverage(
-      existing?._executionTime as AverageState | undefined,
-      metadata?.executionTimeMs,
-    );
-
-    const successState = mergeRate(
-      existing?._success as RateState | undefined,
-      metadata?.success,
-    );
-
     return {
-      avgExecutionTimeMs: executionTimeState.avg,
-      successRate: successState.rate,
-      _executionTime: executionTimeState,
-      _success: successState,
+      avgExecutionTimeMs: mergeAverage(
+        existing?.avgExecutionTimeMs,
+        metadata?.executionTimeMs,
+      ),
+      successRate: mergeRate(existing?.successRate, metadata?.success),
     };
   }
 }

package/src/inline-script-collector.test.ts

@@ -249,8 +249,8 @@ describe("InlineScriptCollector", () => {
       aggregated = collector.mergeResult(aggregated, run2 as never);
       aggregated = collector.mergeResult(aggregated, run3 as never);
 
-      expect(aggregated.avgExecutionTimeMs).toBe(150); // (100+200+150)/3
-      expect(aggregated.successRate).toBeCloseTo(67, 0); // 2/3 * 100 = ~67
+      expect(aggregated.avgExecutionTimeMs.avg).toBe(150); // (100+200+150)/3
+      expect(aggregated.successRate.rate).toBeCloseTo(67, 0); // 2/3 * 100 = ~67
     });
   });
 });

package/src/inline-script-collector.ts

@@ -7,11 +7,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,
@@ -179,30 +179,23 @@ const inlineScriptResultSchema = healthResultSchema({
 
 export type InlineScriptResult = z.infer<typeof inlineScriptResultSchema>;
 
-const inlineScriptAggregatedDisplaySchema = healthResultSchema({
-  avgExecutionTimeMs: healthResultNumber({
+// Aggregated result fields definition
+const inlineScriptAggregatedFields = {
+  avgExecutionTimeMs: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Execution Time",
     "x-chart-unit": "ms",
   }),
-  successRate: healthResultNumber({
+  successRate: aggregatedRate({
     "x-chart-type": "gauge",
     "x-chart-label": "Success Rate",
     "x-chart-unit": "%",
   }),
-});
-
-const inlineScriptAggregatedInternalSchema = z.object({
-  _executionTime: averageStateSchema.optional(),
-  _success: rateStateSchema.optional(),
-});
+};
 
-const inlineScriptAggregatedSchema = inlineScriptAggregatedDisplaySchema.merge(
-  inlineScriptAggregatedInternalSchema,
-);
-
-export type InlineScriptAggregatedResult = z.infer<
-  typeof inlineScriptAggregatedSchema
+// Type inferred from field definitions
+export type InlineScriptAggregatedResult = InferAggregatedResult<
+  typeof inlineScriptAggregatedFields
 >;
 
 // ============================================================================
@@ -253,9 +246,9 @@ export class InlineScriptCollector implements CollectorStrategy<
 
   config = new Versioned({ version: 1, schema: inlineScriptConfigSchema });
   result = new Versioned({ version: 1, schema: inlineScriptResultSchema });
-  aggregatedResult = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: inlineScriptAggregatedSchema,
+    fields: inlineScriptAggregatedFields,
   });
 
   async execute({
@@ -344,21 +337,12 @@ export class InlineScriptCollector implements CollectorStrategy<
   ): InlineScriptAggregatedResult {
     const metadata = run.metadata;
 
-    const executionTimeState = mergeAverage(
-      existing?._executionTime as AverageState | undefined,
-      metadata?.executionTimeMs,
-    );
-
-    const successState = mergeRate(
-      existing?._success as RateState | undefined,
-      metadata?.success,
-    );
-
     return {
-      avgExecutionTimeMs: executionTimeState.avg,
-      successRate: successState.rate,
-      _executionTime: executionTimeState,
-      _success: successState,
+      avgExecutionTimeMs: mergeAverage(
+        existing?.avgExecutionTimeMs,
+        metadata?.executionTimeMs,
+      ),
+      successRate: mergeRate(existing?.successRate, metadata?.success),
     };
   }
 }

package/src/strategy.test.ts

@@ -175,10 +175,10 @@ describe("ScriptHealthCheckStrategy", () => {
       let aggregated = strategy.mergeResult(undefined, runs[0]);
       aggregated = strategy.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.avgExecutionTime).toBe(75);
-      expect(aggregated.successRate).toBe(100);
-      expect(aggregated.errorCount).toBe(0);
-      expect(aggregated.timeoutCount).toBe(0);
+      expect(aggregated.avgExecutionTime.avg).toBe(75);
+      expect(aggregated.successRate.rate).toBe(100);
+      expect(aggregated.errorCount.count).toBe(0);
+      expect(aggregated.timeoutCount.count).toBe(0);
     });
 
     it("should count errors and timeouts", () => {
@@ -217,9 +217,9 @@ describe("ScriptHealthCheckStrategy", () => {
       let aggregated = strategy.mergeResult(undefined, runs[0]);
       aggregated = strategy.mergeResult(aggregated, runs[1]);
 
-      expect(aggregated.errorCount).toBe(1);
-      expect(aggregated.timeoutCount).toBe(1);
-      expect(aggregated.successRate).toBe(0);
+      expect(aggregated.errorCount.count).toBe(1);
+      expect(aggregated.timeoutCount.count).toBe(1);
+      expect(aggregated.successRate.rate).toBe(0);
     });
   });
 });

package/src/strategy.ts

@@ -3,17 +3,16 @@ import {
   HealthCheckStrategy,
   HealthCheckRunForAggregation,
   Versioned,
-  z,
-  type ConnectedClient,
+  VersionedAggregated,
+  aggregatedAverage,
+  aggregatedRate,
+  aggregatedCounter,
   mergeAverage,
-  averageStateSchema,
   mergeRate,
-  rateStateSchema,
   mergeCounter,
-  counterStateSchema,
-  type AverageState,
-  type RateState,
-  type CounterState,
+  z,
+  type ConnectedClient,
+  type InferAggregatedResult,
 } from "@checkstack/backend-api";
 import {
   healthResultBoolean,
@@ -88,44 +87,31 @@ const scriptResultSchema = healthResultSchema({
 
 type ScriptResult = z.infer<typeof scriptResultSchema>;
 
-/**
- * Aggregated metadata for buckets.
- */
-const scriptAggregatedDisplaySchema = healthResultSchema({
-  avgExecutionTime: healthResultNumber({
+/** Aggregated field definitions for bucket merging */
+const scriptAggregatedFields = {
+  avgExecutionTime: aggregatedAverage({
     "x-chart-type": "line",
     "x-chart-label": "Avg Execution Time",
     "x-chart-unit": "ms",
   }),
-  successRate: healthResultNumber({
+  successRate: aggregatedRate({
     "x-chart-type": "gauge",
     "x-chart-label": "Success Rate",
     "x-chart-unit": "%",
   }),
-  errorCount: healthResultNumber({
+  errorCount: aggregatedCounter({
     "x-chart-type": "counter",
     "x-chart-label": "Errors",
   }),
-  timeoutCount: healthResultNumber({
+  timeoutCount: aggregatedCounter({
     "x-chart-type": "counter",
     "x-chart-label": "Timeouts",
   }),
-});
-
-const scriptAggregatedInternalSchema = z.object({
-  _executionTime: averageStateSchema
-    .optional(),
-  _success: rateStateSchema
-    .optional(),
-  _errors: counterStateSchema.optional(),
-  _timeouts: counterStateSchema.optional(),
-});
-
-const scriptAggregatedSchema = scriptAggregatedDisplaySchema.merge(
-  scriptAggregatedInternalSchema,
-);
+};
 
-type ScriptAggregatedResult = z.infer<typeof scriptAggregatedSchema>;
+type ScriptAggregatedResult = InferAggregatedResult<
+  typeof scriptAggregatedFields
+>;
 
 // ============================================================================
 // SCRIPT EXECUTOR INTERFACE (for testability)
@@ -208,7 +194,7 @@ export class ScriptHealthCheckStrategy implements HealthCheckStrategy<
   ScriptConfig,
   ScriptTransportClient,
   ScriptResult,
-  ScriptAggregatedResult
+  typeof scriptAggregatedFields
 > {
   id = "script";
   displayName = "Script Health Check";
@@ -248,9 +234,9 @@ export class ScriptHealthCheckStrategy implements HealthCheckStrategy<
     ],
   });
 
-  aggregatedResult: Versioned<ScriptAggregatedResult> = new Versioned({
+  aggregatedResult = new VersionedAggregated({
     version: 1,
-    schema: scriptAggregatedSchema,
+    fields: scriptAggregatedFields,
   });
 
   mergeResult(
@@ -259,36 +245,21 @@ export class ScriptHealthCheckStrategy implements HealthCheckStrategy<
   ): ScriptAggregatedResult {
     const metadata = run.metadata;
 
-    const executionTimeState = mergeAverage(
-      existing?._executionTime as AverageState | undefined,
+    const avgExecutionTime = mergeAverage(
+      existing?.avgExecutionTime,
       metadata?.executionTimeMs,
     );
 
-    const successState = mergeRate(
-      existing?._success as RateState | undefined,
-      metadata?.success,
-    );
+    const isSuccess = metadata?.success ?? false;
+    const successRate = mergeRate(existing?.successRate, isSuccess);
 
-    const errorState = mergeCounter(
-      existing?._errors as CounterState | undefined,
-      metadata?.error !== undefined,
-    );
+    const hasError = metadata?.error !== undefined;
+    const errorCount = mergeCounter(existing?.errorCount, hasError);
 
-    const timeoutState = mergeCounter(
-      existing?._timeouts as CounterState | undefined,
-      metadata?.timedOut === true,
-    );
+    const hasTimeout = metadata?.timedOut === true;
+    const timeoutCount = mergeCounter(existing?.timeoutCount, hasTimeout);
 
-    return {
-      avgExecutionTime: executionTimeState.avg,
-      successRate: successState.rate,
-      errorCount: errorState.count,
-      timeoutCount: timeoutState.count,
-      _executionTime: executionTimeState,
-      _success: successState,
-      _errors: errorState,
-      _timeouts: timeoutState,
-    };
+    return { avgExecutionTime, successRate, errorCount, timeoutCount };
   }
 
   async createClient(