@norskvideo/ctl-dev-kit 0.2.39 → 0.2.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@norskvideo/ctl-dev-kit",
-  "version": "0.2.39",
+  "version": "0.2.40",
   "type": "module",
   "exports": {
     "./create-product": "./create-product/create-product.ts",

package/publish/product-channel.ts

@@ -16,16 +16,72 @@
  * are not reliable yet: it skips only the guide half of the gate, must give a
  * reason, and the reason travels into the published row, so nobody reads
  * "passed" off an image whose guides never ran.
+ *
+ * Self-contained on purpose: it imports nothing outside node and this package.
+ * Products resolve the dev-kit's siblings from their OWN lockfiles, so a sibling
+ * import here bound the writer to whatever schema version a product happened to
+ * lock -- the first gated publish in every product died on a missing export.
+ * The object's contract is @norskvideo/ctl-product-template-schema's
+ * product-channels; product-channel.test.ts parses this module's output with it.
  */
 import { existsSync, readFileSync } from "node:fs";
-import {
-  type ProductChannelRow,
-  ProductChannelSchema,
-  parseProductChannels,
-  withChannelRow,
-} from "@norskvideo/ctl-product-template-schema/product-channels";
 import { builtImageName } from "../licence/check-template.ts";
 
+const CHANNELS = ["nightly", "rc", "latest"] as const;
+type Channel = (typeof CHANNELS)[number];
+
+export interface ProductChannelRow {
+  image: string;
+  sha: string;
+  publishedAt: string;
+  runtimeImages: string[];
+  gate: { checks: "passed"; guides: "passed" | { skipped: string }; run?: string };
+}
+
+interface ProductChannels {
+  schemaVersion: 1;
+  product: string;
+  imageRef: string;
+  updated: string;
+  channels: Partial<Record<Channel, unknown>>;
+}
+
+/** The current object, checked only as far as the merge needs: other channels'
+ *  rows are carried through untouched, so a newer writer's fields survive. */
+function parseCurrent(text: string): ProductChannels {
+  const raw = JSON.parse(text) as Partial<ProductChannels>;
+  if (raw.schemaVersion !== 1) throw new Error(`channels object has schemaVersion ${raw.schemaVersion}, not 1`);
+  if (typeof raw.product !== "string" || typeof raw.imageRef !== "string") {
+    throw new Error("channels object has no product/imageRef");
+  }
+  if (typeof raw.channels !== "object" || raw.channels === null) throw new Error("channels object has no channels");
+  return raw as ProductChannels;
+}
+
+/** `current` with `channel` set to `row`; every other channel is kept. */
+export function withChannelRow(
+  current: ProductChannels | null,
+  opts: { product: string; imageRef: string; channel: Channel; row: ProductChannelRow; updated: string },
+): ProductChannels {
+  if (current && (current.product !== opts.product || current.imageRef !== opts.imageRef)) {
+    throw new Error(
+      `channels object belongs to ${current.product} (${current.imageRef}), not ${opts.product} (${opts.imageRef})`,
+    );
+  }
+  return {
+    schemaVersion: 1,
+    product: opts.product,
+    imageRef: opts.imageRef,
+    updated: opts.updated,
+    channels: { ...(current?.channels ?? {}), [opts.channel]: opts.row },
+  };
+}
+
+function parseChannel(value: string): Channel {
+  if (!(CHANNELS as readonly string[]).includes(value)) throw new Error(`not a channel: ${value}`);
+  return value as Channel;
+}
+
 export type GuideGate = { run: true } | { run: false; reason: string };
 
 /** Whether the guides gate this product's publish, from its opt-out file. */
@@ -106,20 +162,12 @@ if (import.meta.main) {
     console.log(productForImage(readFileSync(need("template"), "utf8"), need("image")));
   } else if (cmd === "row") {
     const currentText = readIfPresent(flag("current"));
-    let current = null;
-    if (currentText !== undefined) {
-      const parsed = parseProductChannels(JSON.parse(currentText));
-      if (!parsed.ok) {
-        console.error(`product-channel row: the current object does not parse:\n${parsed.error}`);
-        process.exit(1);
-      }
-      current = parsed.value;
-    }
+    const current = currentText === undefined ? null : parseCurrent(currentText);
     const skipped = flag("skipped");
     const merged = withChannelRow(current, {
       product: need("product"),
       imageRef: need("image-ref"),
-      channel: ProductChannelSchema.parse(need("channel")),
+      channel: parseChannel(need("channel")),
       updated: need("published-at"),
       row: gateRow({
         image: need("image"),