@checkstack/healthcheck-postgres-backend 0.1.12 → 0.1.14

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # @checkstack/healthcheck-postgres-backend
 
+## 0.1.14
+
+### Patch Changes
+
+- 48c2080: Migrate aggregation from batch to incremental (`mergeResult`)
+
+  ### Breaking Changes (Internal)
+
+  - Replaced `aggregateResult(runs[])` with `mergeResult(existing, run)` interface across all HealthCheckStrategy and CollectorStrategy implementations
+
+  ### New Features
+
+  - Added incremental aggregation utilities in `@checkstack/backend-api`:
+    - `mergeCounter()` - track occurrences
+    - `mergeAverage()` - track sum/count, compute avg
+    - `mergeRate()` - track success/total, compute %
+    - `mergeMinMax()` - track min/max values
+  - Exported Zod schemas for internal state: `averageStateSchema`, `rateStateSchema`, `minMaxStateSchema`, `counterStateSchema`
+
+  ### Improvements
+
+  - Enables O(1) storage overhead by maintaining incremental aggregation state
+  - Prepares for real-time hourly aggregation without batch accumulation
+
+- Updated dependencies [f676e11]
+- Updated dependencies [48c2080]
+  - @checkstack/common@0.6.2
+  - @checkstack/backend-api@0.6.0
+  - @checkstack/healthcheck-common@0.8.2
+
+## 0.1.13
+
+### Patch Changes
+
+- 0b9fc58: Fix workspace:\* protocol resolution in published packages
+
+  Published packages now correctly have resolved dependency versions instead of `workspace:*` references. This is achieved by using `bun publish` which properly resolves workspace protocol references.
+
+- Updated dependencies [0b9fc58]
+  - @checkstack/backend-api@0.5.2
+  - @checkstack/common@0.6.1
+  - @checkstack/healthcheck-common@0.8.1
+
 ## 0.1.12
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/healthcheck-postgres-backend",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "type": "module",
   "main": "src/index.ts",
   "scripts": {
@@ -9,16 +9,16 @@
     "lint:code": "eslint . --max-warnings 0"
   },
   "dependencies": {
-    "@checkstack/backend-api": "workspace:*",
-    "@checkstack/common": "workspace:*",
-    "@checkstack/healthcheck-common": "workspace:*",
+    "@checkstack/backend-api": "0.5.2",
+    "@checkstack/common": "0.6.1",
+    "@checkstack/healthcheck-common": "0.8.1",
     "pg": "^8.11.0"
   },
   "devDependencies": {
     "@types/bun": "^1.0.0",
     "@types/pg": "^8.11.0",
     "typescript": "^5.0.0",
-    "@checkstack/tsconfig": "workspace:*",
-    "@checkstack/scripts": "workspace:*"
+    "@checkstack/tsconfig": "0.0.3",
+    "@checkstack/scripts": "0.1.1"
   }
 }

package/src/query-collector.test.ts

@@ -64,7 +64,7 @@ describe("QueryCollector", () => {
     });
   });
 
-  describe("aggregateResult", () => {
+  describe("mergeResult", () => {
     it("should calculate average execution time and success rate", () => {
       const collector = new QueryCollector();
       const runs = [
@@ -86,7 +86,8 @@ describe("QueryCollector", () => {
         },
       ];
 
-      const aggregated = collector.aggregateResult(runs);
+      let aggregated = collector.mergeResult(undefined, runs[0]);
+      aggregated = collector.mergeResult(aggregated, runs[1]);
 
       expect(aggregated.avgExecutionTimeMs).toBe(75);
       expect(aggregated.successRate).toBe(100);
@@ -113,7 +114,8 @@ describe("QueryCollector", () => {
         },
       ];
 
-      const aggregated = collector.aggregateResult(runs);
+      let aggregated = collector.mergeResult(undefined, runs[0]);
+      aggregated = collector.mergeResult(aggregated, runs[1]);
 
       expect(aggregated.successRate).toBe(50);
     });

package/src/query-collector.ts

@@ -4,6 +4,12 @@ import {
   type HealthCheckRunForAggregation,
   type CollectorResult,
   type CollectorStrategy,
+  mergeAverage,
+  mergeRate,
+  averageStateSchema,
+  rateStateSchema,
+  type AverageState,
+  type RateState,
 } from "@checkstack/backend-api";
 import {
   healthResultNumber,
@@ -45,7 +51,7 @@ const queryResultSchema = healthResultSchema({
 
 export type QueryResult = z.infer<typeof queryResultSchema>;
 
-const queryAggregatedSchema = healthResultSchema({
+const queryAggregatedDisplaySchema = healthResultSchema({
   avgExecutionTimeMs: healthResultNumber({
     "x-chart-type": "line",
     "x-chart-label": "Avg Execution Time",
@@ -58,6 +64,15 @@ const queryAggregatedSchema = healthResultSchema({
   }),
 });
 
+const queryAggregatedInternalSchema = z.object({
+  _executionTime: averageStateSchema.optional(),
+  _success: rateStateSchema.optional(),
+});
+
+const queryAggregatedSchema = queryAggregatedDisplaySchema.merge(
+  queryAggregatedInternalSchema,
+);
+
 export type QueryAggregatedResult = z.infer<typeof queryAggregatedSchema>;
 
 // ============================================================================
@@ -68,15 +83,12 @@ export type QueryAggregatedResult = z.infer<typeof queryAggregatedSchema>;
  * Built-in PostgreSQL query collector.
  * Executes SQL queries and checks results.
  */
-export class QueryCollector
-  implements
-    CollectorStrategy<
-      PostgresTransportClient,
-      QueryConfig,
-      QueryResult,
-      QueryAggregatedResult
-    >
-{
+export class QueryCollector implements CollectorStrategy<
+  PostgresTransportClient,
+  QueryConfig,
+  QueryResult,
+  QueryAggregatedResult
+> {
   id = "query";
   displayName = "SQL Query";
   description = "Execute a SQL query and check the result";
@@ -115,28 +127,27 @@ export class QueryCollector
     };
   }
 
-  aggregateResult(
-    runs: HealthCheckRunForAggregation<QueryResult>[]
+  mergeResult(
+    existing: QueryAggregatedResult | undefined,
+    run: HealthCheckRunForAggregation<QueryResult>,
   ): QueryAggregatedResult {
-    const times = runs
-      .map((r) => r.metadata?.executionTimeMs)
-      .filter((v): v is number => typeof v === "number");
+    const metadata = run.metadata;
 
-    const successes = runs
-      .map((r) => r.metadata?.success)
-      .filter((v): v is boolean => typeof v === "boolean");
+    const executionTimeState = mergeAverage(
+      existing?._executionTime as AverageState | undefined,
+      metadata?.executionTimeMs,
+    );
 
-    const successCount = successes.filter(Boolean).length;
+    const successState = mergeRate(
+      existing?._success as RateState | undefined,
+      metadata?.success,
+    );
 
     return {
-      avgExecutionTimeMs:
-        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,
+      avgExecutionTimeMs: executionTimeState.avg,
+      successRate: successState.rate,
+      _executionTime: executionTimeState,
+      _success: successState,
     };
   }
 }

package/src/strategy.test.ts

@@ -8,7 +8,7 @@ describe("PostgresHealthCheckStrategy", () => {
       rowCount?: number;
       queryError?: Error;
       connectError?: Error;
-    } = {}
+    } = {},
   ): DbClient => ({
     connect: mock(() =>
       config.connectError
@@ -17,10 +17,10 @@ describe("PostgresHealthCheckStrategy", () => {
             query: mock(() =>
               config.queryError
                 ? Promise.reject(config.queryError)
-                : Promise.resolve({ rowCount: config.rowCount ?? 1 })
+                : Promise.resolve({ rowCount: config.rowCount ?? 1 }),
             ),
             end: mock(() => Promise.resolve()),
-          })
+          }),
     ),
   });
 
@@ -46,7 +46,7 @@ describe("PostgresHealthCheckStrategy", () => {
 
     it("should throw for connection error", async () => {
       const strategy = new PostgresHealthCheckStrategy(
-        createMockClient({ connectError: new Error("Connection refused") })
+        createMockClient({ connectError: new Error("Connection refused") }),
       );
 
       await expect(
@@ -57,7 +57,7 @@ describe("PostgresHealthCheckStrategy", () => {
           user: "postgres",
           password: "secret",
           timeout: 5000,
-        })
+        }),
       ).rejects.toThrow("Connection refused");
     });
   });
@@ -85,7 +85,7 @@ describe("PostgresHealthCheckStrategy", () => {
 
     it("should return error for query error", async () => {
       const strategy = new PostgresHealthCheckStrategy(
-        createMockClient({ queryError: new Error("Syntax error") })
+        createMockClient({ queryError: new Error("Syntax error") }),
       );
       const connectedClient = await strategy.createClient({
         host: "localhost",
@@ -107,7 +107,7 @@ describe("PostgresHealthCheckStrategy", () => {
 
     it("should return custom row count", async () => {
       const strategy = new PostgresHealthCheckStrategy(
-        createMockClient({ rowCount: 5 })
+        createMockClient({ rowCount: 5 }),
       );
       const connectedClient = await strategy.createClient({
         host: "localhost",
@@ -128,8 +128,8 @@ describe("PostgresHealthCheckStrategy", () => {
     });
   });
 
-  describe("aggregateResult", () => {
-    it("should calculate averages correctly", () => {
+  describe("mergeResult", () => {
+    it("should calculate averages correctly through incremental merging", () => {
       const strategy = new PostgresHealthCheckStrategy();
       const runs = [
         {
@@ -158,7 +158,9 @@ describe("PostgresHealthCheckStrategy", () => {
         },
       ];
 
-      const aggregated = strategy.aggregateResult(runs);
+      // Merge incrementally
+      let aggregated = strategy.mergeResult(undefined, runs[0]);
+      aggregated = strategy.mergeResult(aggregated, runs[1]);
 
       expect(aggregated.avgConnectionTime).toBe(75);
       expect(aggregated.successRate).toBe(100);
@@ -167,22 +169,20 @@ describe("PostgresHealthCheckStrategy", () => {
 
     it("should count errors", () => {
       const strategy = new PostgresHealthCheckStrategy();
-      const runs = [
-        {
-          id: "1",
-          status: "unhealthy" as const,
-          latencyMs: 100,
-          checkId: "c1",
-          timestamp: new Date(),
-          metadata: {
-            connected: false,
-            connectionTimeMs: 100,
-            error: "Connection refused",
-          },
+      const run = {
+        id: "1",
+        status: "unhealthy" as const,
+        latencyMs: 100,
+        checkId: "c1",
+        timestamp: new Date(),
+        metadata: {
+          connected: false,
+          connectionTimeMs: 100,
+          error: "Connection refused",
         },
-      ];
+      };
 
-      const aggregated = strategy.aggregateResult(runs);
+      const aggregated = strategy.mergeResult(undefined, run);
 
       expect(aggregated.errorCount).toBe(1);
       expect(aggregated.successRate).toBe(0);

package/src/strategy.ts

@@ -8,6 +8,18 @@ import {
   configNumber,
   configBoolean,
   type ConnectedClient,
+  mergeAverage,
+  mergeRate,
+  mergeCounter,
+  mergeMinMax,
+  averageStateSchema,
+  minMaxStateSchema,
+  rateStateSchema,
+  counterStateSchema,
+  type AverageState,
+  type RateState,
+  type CounterState,
+  type MinMaxState,
 } from "@checkstack/backend-api";
 import {
   healthResultBoolean,
@@ -73,7 +85,8 @@ type PostgresResult = z.infer<typeof postgresResultSchema>;
 /**
  * Aggregated metadata for buckets.
  */
-const postgresAggregatedSchema = healthResultSchema({
+// UI-visible aggregated fields (for charts)
+const postgresAggregatedDisplaySchema = healthResultSchema({
   avgConnectionTime: healthResultNumber({
     "x-chart-type": "line",
     "x-chart-label": "Avg Connection Time",
@@ -95,6 +108,18 @@ const postgresAggregatedSchema = healthResultSchema({
   }),
 });
 
+// Internal state for incremental aggregation
+const postgresAggregatedInternalSchema = z.object({
+  _connectionTime: averageStateSchema.optional(),
+  _maxConnectionTime: minMaxStateSchema.optional(),
+  _success: rateStateSchema.optional(),
+  _errors: counterStateSchema.optional(),
+});
+
+const postgresAggregatedSchema = postgresAggregatedDisplaySchema.merge(
+  postgresAggregatedInternalSchema,
+);
+
 type PostgresAggregatedResult = z.infer<typeof postgresAggregatedSchema>;
 
 // ============================================================================
@@ -133,15 +158,12 @@ const defaultDbClient: DbClient = {
 // STRATEGY
 // ============================================================================
 
-export class PostgresHealthCheckStrategy
-  implements
-    HealthCheckStrategy<
-      PostgresConfig,
-      PostgresTransportClient,
-      PostgresResult,
-      PostgresAggregatedResult
-    >
-{
+export class PostgresHealthCheckStrategy implements HealthCheckStrategy<
+  PostgresConfig,
+  PostgresTransportClient,
+  PostgresResult,
+  PostgresAggregatedResult
+> {
   id = "postgres";
   displayName = "PostgreSQL Health Check";
   description = "PostgreSQL database connectivity and query health check";
@@ -183,53 +205,50 @@ export class PostgresHealthCheckStrategy
     schema: postgresAggregatedSchema,
   });
 
-  aggregateResult(
-    runs: HealthCheckRunForAggregation<PostgresResult>[]
+  mergeResult(
+    existing: PostgresAggregatedResult | undefined,
+    run: HealthCheckRunForAggregation<PostgresResult>,
   ): PostgresAggregatedResult {
-    const validRuns = runs.filter((r) => r.metadata);
-
-    if (validRuns.length === 0) {
-      return {
-        avgConnectionTime: 0,
-        maxConnectionTime: 0,
-        successRate: 0,
-        errorCount: 0,
-      };
-    }
-
-    const connectionTimes = validRuns
-      .map((r) => r.metadata?.connectionTimeMs)
-      .filter((t): t is number => typeof t === "number");
+    const metadata = run.metadata;
 
-    const avgConnectionTime =
-      connectionTimes.length > 0
-        ? Math.round(
-            connectionTimes.reduce((a, b) => a + b, 0) / connectionTimes.length
-          )
-        : 0;
+    // Merge connection time average
+    const connectionTimeState = mergeAverage(
+      existing?._connectionTime as AverageState | undefined,
+      metadata?.connectionTimeMs,
+    );
 
-    const maxConnectionTime =
-      connectionTimes.length > 0 ? Math.max(...connectionTimes) : 0;
+    // Merge max connection time
+    const maxConnectionTimeState = mergeMinMax(
+      existing?._maxConnectionTime as MinMaxState | undefined,
+      metadata?.connectionTimeMs,
+    );
 
-    const successCount = validRuns.filter(
-      (r) => r.metadata?.connected === true
-    ).length;
-    const successRate = Math.round((successCount / validRuns.length) * 100);
+    // Merge success rate
+    const successState = mergeRate(
+      existing?._success as RateState | undefined,
+      metadata?.connected,
+    );
 
-    const errorCount = validRuns.filter(
-      (r) => r.metadata?.error !== undefined
-    ).length;
+    // Merge error count
+    const errorState = mergeCounter(
+      existing?._errors as CounterState | undefined,
+      metadata?.error !== undefined,
+    );
 
     return {
-      avgConnectionTime,
-      maxConnectionTime,
-      successRate,
-      errorCount,
+      avgConnectionTime: connectionTimeState.avg,
+      maxConnectionTime: maxConnectionTimeState.max,
+      successRate: successState.rate,
+      errorCount: errorState.count,
+      _connectionTime: connectionTimeState,
+      _maxConnectionTime: maxConnectionTimeState,
+      _success: successState,
+      _errors: errorState,
     };
   }
 
   async createClient(
-    config: PostgresConfigInput
+    config: PostgresConfigInput,
   ): Promise<ConnectedClient<PostgresTransportClient>> {
     const validatedConfig = this.config.validate(config);