@platforma-sdk/block-tools 2.14.5 → 2.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/block-tools",
-  "version": "2.14.5",
+  "version": "2.15.0",
   "description": "Utility to manipulate Platforma Blocks and Block Registry",
   "license": "UNLICENSED",
   "bin": {
@@ -36,12 +36,12 @@
     "zod": "~3.25.76",
     "@milaboratories/pl-http": "1.2.4",
     "@milaboratories/pl-model-common": "1.48.0",
-    "@milaboratories/pl-model-middle-layer": "1.32.0",
     "@milaboratories/ts-helpers": "1.8.6",
-    "@platforma-sdk/package-builder-lib": "1.3.0",
+    "@milaboratories/pl-model-middle-layer": "1.32.0",
     "@milaboratories/resolve-helper": "1.1.3",
+    "@milaboratories/pl-model-backend": "1.4.23",
     "@platforma-sdk/blocks-deps-updater": "2.2.0",
-    "@milaboratories/pl-model-backend": "1.4.22"
+    "@platforma-sdk/package-builder-lib": "1.4.0"
   },
   "devDependencies": {
     "@rollup/plugin-node-resolve": "^16.0.1",

package/src/cmd/software/run-build.test.ts

@@ -22,6 +22,9 @@ function fakeBuilder() {
     publishDockerImages: vi.fn(rec("publishDockerImages")),
     publishPackages: vi.fn(async () => void calls.push("publishPackages")),
     buildSwJsonFiles: vi.fn(rec("buildSwJsonFiles")),
+    // A guard, not a build step: kept out of `calls` so the order assertions stay
+    // about what the pass actually builds and pushes.
+    assertDockerCoverage: vi.fn(),
   };
   return { core: core as unknown as Builder, calls, spies: core };
 }
@@ -127,6 +130,47 @@ describe("runBuild orchestration", () => {
     ]);
   });
 
+  it("checks docker coverage up front, so a doomed build fails before it builds", async () => {
+    const b = await run({ channel: "release", location: "remote" });
+    expect(b.spies.assertDockerCoverage).toHaveBeenCalled();
+    expect(b.spies.assertDockerCoverage.mock.invocationCallOrder[0]).toBeLessThan(
+      b.spies.buildDockerImages.mock.invocationCallOrder[0],
+    );
+  });
+
+  it("skips the coverage check when the scenario describes no software at all", async () => {
+    const b = await run({ variant: "none" });
+    expect(b.spies.assertDockerCoverage).not.toHaveBeenCalled();
+    expect(b.spies.buildSwJsonFiles).toHaveBeenCalledWith(
+      expect.objectContaining({ skipDockerCoverage: true }),
+    );
+  });
+
+  // `build:dev-binary-existing` builds nothing: the descriptor points at an artifact whose
+  // coverage was settled when it was released, so this run answers for none of it.
+  it("skips the coverage check when pointing at an already-published binary", async () => {
+    const b = await run({ usePublished: true });
+    expect(b.spies.assertDockerCoverage).not.toHaveBeenCalled();
+    expect(b.spies.buildSwJsonFiles).toHaveBeenCalledWith(
+      expect.objectContaining({ skipDockerCoverage: true }),
+    );
+  });
+
+  it("keeps the coverage check on the scenarios that do build software", async () => {
+    for (const knobs of [
+      { channel: "release", location: "remote" },
+      { channel: "dev", location: "remote" },
+      { channel: "dev", location: "local" },
+      {},
+    ] as const) {
+      const b = await run(knobs);
+      expect(b.spies.assertDockerCoverage).toHaveBeenCalled();
+      expect(b.spies.buildSwJsonFiles).toHaveBeenCalledWith(
+        expect.objectContaining({ skipDockerCoverage: false }),
+      );
+    }
+  });
+
   it("dev docker build targets the built-in dev registry; release the production registry", async () => {
     const dev = await run({ channel: "dev", variant: "docker", location: "remote" });
     expect(dev.spies.buildDockerImages).toHaveBeenCalledWith(

package/src/cmd/software/run-build.ts

@@ -36,6 +36,15 @@ export async function runBuild(params: {
   const ids = opts.ids;
   core.buildMode = buildModeForScenario(scenario);
 
+  // Software with no docker variant cannot run on a k8s install, and the answer comes
+  // from package.json alone — so a CI run that cannot produce a runnable release says
+  // so before building anything. Two scenarios build no software and therefore answer
+  // for none: `no-software` describes none at all, and `binary-existing` points the
+  // descriptor at an artifact whose coverage was settled when it was released. The
+  // engine also skips dev-local builds, whose descriptors never reach a cluster;
+  // buildSwJsonFiles re-checks whatever the remaining scenarios end up writing.
+  if (!buildsNoSoftware(scenario)) core.assertDockerCoverage();
+
   const buildBinary = () =>
     core.buildSoftwareArchives({
       ids,
@@ -109,7 +118,16 @@ export async function runBuild(params: {
   }
 
   // DESCRIPTOR LAST — only after build + push have succeeded.
-  core.buildSwJsonFiles({ packageIds: ids, noSoftware: scenario.kind === "no-software" });
+  core.buildSwJsonFiles({
+    packageIds: ids,
+    noSoftware: scenario.kind === "no-software",
+    skipDockerCoverage: buildsNoSoftware(scenario),
+  });
+}
+
+// Scenarios that build no software of their own, so they answer for no docker coverage.
+function buildsNoSoftware(scenario: Scenario): boolean {
+  return scenario.kind === "no-software" || scenario.kind === "binary-existing";
 }
 
 function buildModeForScenario(scenario: Scenario): util.BuildMode {