@checkstack/healthcheck-ping-backend 0.2.23 → 0.3.1

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # @checkstack/healthcheck-ping-backend
 
+## 0.3.1
+
+### Patch Changes
+
+- Updated dependencies [13373ce]
+  - @checkstack/common@0.14.0
+  - @checkstack/backend-api@0.21.1
+  - @checkstack/healthcheck-common@1.5.1
+
+## 0.3.0
+
+### Minor Changes
+
+- 9dcc848: Health-check strategy and collector configs now migrate-then-validate when loaded, instead of being cast/rendered raw.
+
+  These configs declared `version: 2`/`3` migrations but the load path never ran them: stored values are persisted UNVERSIONED, and the executor cast them straight to the strategy/collector type. Both the execution path (`queue-executor`) and the read API (`mapConfig`, feeding router / frontend / gitops `getConfiguration`) now use assume-v1-on-read (`Versioned.parseAssumingV1`): wrap as version 1, run the declared chain, then validate. Order is preserved: migrate -> secret resolve -> template render -> execute. An unregistered strategy/collector or a failed migrate falls back to the raw stored blob rather than dropping the configuration. Every reshaper migration is now IDEMPOTENT, guarding on its legacy discriminator so already-current data passes through untouched.
+
+  BREAKING CHANGE: for any config GENUINELY at version 1 in the database (e.g. an HTTP strategy still carrying `url`/`method`, or an execute collector still carrying `command`/`args`), the declared migrations now actually RUN on load, so the loaded/returned shape changes for such rows. This is the intended fix - those fields were already supposed to have been migrated away. Configs already at the current shape are unaffected. No data backfill is performed; migration is applied on every read.
+
+  This is a beta minor.
+
+### Patch Changes
+
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+- Updated dependencies [9dcc848]
+  - @checkstack/backend-api@0.21.0
+  - @checkstack/healthcheck-common@1.5.0
+  - @checkstack/common@0.13.0
+
 ## 0.2.23
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/healthcheck-ping-backend",
-  "version": "0.2.23",
+  "version": "0.3.1",
   "type": "module",
   "main": "src/index.ts",
   "checkstack": {
@@ -14,15 +14,15 @@
     "pack": "bunx @checkstack/scripts plugin-pack"
   },
   "dependencies": {
-    "@checkstack/backend-api": "0.18.0",
-    "@checkstack/common": "0.12.0",
-    "@checkstack/healthcheck-common": "1.3.0"
+    "@checkstack/backend-api": "0.21.0",
+    "@checkstack/common": "0.13.0",
+    "@checkstack/healthcheck-common": "1.5.0"
   },
   "devDependencies": {
     "@types/bun": "^1.0.0",
     "typescript": "^5.0.0",
     "@checkstack/tsconfig": "0.0.7",
-    "@checkstack/scripts": "0.3.4"
+    "@checkstack/scripts": "0.4.0"
   },
   "description": "Checkstack healthcheck-ping-backend plugin",
   "author": {

package/src/migration-chain-contract.test.ts

@@ -0,0 +1,38 @@
+/**
+ * Contract test: every Ping health-check Versioned schema stored UNVERSIONED
+ * and read back via assume-v1-on-read MUST have a COMPLETE, contiguous
+ * migration chain from version 1 to its current `version`. Pure STRUCTURAL
+ * check (`validateMigrationChainFromV1`); enumerates every Versioned field
+ * (config + result + aggregatedResult) of this plugin's strategy + collectors
+ * so a new collector or a bumped result schema is covered automatically. See
+ * the HTTP plugin's equivalent test for the full rationale.
+ */
+import { describe, expect, it } from "bun:test";
+import { PingHealthCheckStrategy } from "./strategy";
+import { PingCollector } from "./ping-collector";
+
+describe("ping health-check migration-chain contract", () => {
+  const strategy = new PingHealthCheckStrategy();
+  const collector = new PingCollector();
+  const configs = [
+    { name: "ping strategy config", config: strategy.config },
+    { name: "ping strategy result", config: strategy.result },
+    { name: "ping strategy aggregatedResult", config: strategy.aggregatedResult },
+    { name: "ping collector config", config: collector.config },
+    { name: "ping collector result", config: collector.result },
+    {
+      name: "ping collector aggregatedResult",
+      config: collector.aggregatedResult,
+    },
+  ];
+
+  it("every registered Versioned schema has a complete v1->version chain", () => {
+    for (const { name, config } of configs) {
+      const problem = config.validateMigrationChainFromV1();
+      expect(
+        problem,
+        `${name} (version ${config.version}) has a broken migration chain: ${problem}`,
+      ).toBeUndefined();
+    }
+  });
+});

package/src/strategy.test.ts

@@ -249,4 +249,26 @@ describe("PingHealthCheckStrategy", () => {
       connectedClient.close();
     });
   });
+
+  describe("config migration (assume-v1-on-read)", () => {
+    const strategy = new PingHealthCheckStrategy();
+
+    it("migrates a genuine v1 blob (host/count/...) down to {timeout}", async () => {
+      const migrated = await strategy.config.parseAssumingV1({
+        host: "8.8.8.8",
+        count: 4,
+        timeout: 7000,
+      });
+      expect(migrated).toEqual({ timeout: 7000 });
+    });
+
+    it("is idempotent: an already-current {timeout} blob is unchanged", async () => {
+      const migrated = await strategy.config.parseAssumingV1({ timeout: 3000 });
+      expect(migrated).toEqual({ timeout: 3000 });
+    });
+
+    it("has a complete v1->version migration chain", () => {
+      expect(strategy.config.validateMigrationChainFromV1()).toBeUndefined();
+    });
+  });
 });

package/src/strategy.ts

@@ -39,11 +39,19 @@ export const pingConfigSchema = baseStrategyConfigSchema.extend({});
 
 export type PingConfig = z.infer<typeof pingConfigSchema>;
 
-// Legacy config type for migrations
-interface PingConfigV1 {
-  host: string;
-  count: number;
-  timeout: number;
+// The migrate input is `unknown` per the versioning chain, so narrowing is
+// done with `typeof`/`in` guards (no casts).
+
+/** Type guard: the migrate input is a plain object whose keys can be probed. */
+function isRecord(data: unknown): data is Record<string, unknown> {
+  return typeof data === "object" && data !== null;
+}
+
+/** Read a numeric `timeout` field from a legacy/current config blob. */
+function readTimeout(data: unknown): number | undefined {
+  if (!isRecord(data)) return undefined;
+  const value = data.timeout;
+  return typeof value === "number" ? value : undefined;
 }
 
 /**
@@ -166,9 +174,14 @@ export class PingHealthCheckStrategy implements HealthCheckStrategy<
         fromVersion: 1,
         toVersion: 2,
         description: "Remove host/count (moved to PingCollector)",
-        migrate: (data: PingConfigV1): PingConfig => ({
-          timeout: data.timeout,
-        }),
+        // IDEMPOTENT: only a genuine v1 blob still carries host/count. An
+        // already-v2 blob (just `{ timeout }`) passes through untouched.
+        migrate: (data: unknown): unknown => {
+          if (isRecord(data) && ("host" in data || "count" in data)) {
+            return { timeout: readTimeout(data) };
+          }
+          return data;
+        },
       },
     ],
   });