@valbuild/cli 0.146.4 → 0.148.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@valbuild/cli",
   "private": false,
-  "version": "0.146.4",
+  "version": "0.148.0",
   "description": "Val CLI tools",
   "repository": {
     "type": "git",
@@ -26,11 +26,11 @@
     "picocolors": "^1.1.1",
     "zod": "^4.4.3",
     "zod-validation-error": "^5.0.0",
-    "@valbuild/core": "0.146.2",
     "@valbuild/eslint-plugin": "0.125.0",
-    "@valbuild/language-server": "0.146.4",
-    "@valbuild/server": "0.146.4",
-    "@valbuild/shared": "0.146.4"
+    "@valbuild/language-server": "0.148.0",
+    "@valbuild/core": "0.148.0",
+    "@valbuild/server": "0.148.0",
+    "@valbuild/shared": "0.148.0"
   },
   "peerDependencies": {
     "prettier": "*",
@@ -38,7 +38,7 @@
     "rolldown": ">=1.2.5",
     "@tanstack/router-generator": ">=1.167.0",
     "@tanstack/router-plugin": ">=1.168.0",
-    "@valbuild/tanstack-build": "^0.146.0"
+    "@valbuild/tanstack-build": "^0.148.0"
   },
   "peerDependenciesMeta": {
     "@valbuild/tanstack-build": {
@@ -70,7 +70,7 @@
     "prettier": "~3.8.5",
     "rolldown": "^1.2.5",
     "tsx": "^4.23.12",
-    "@valbuild/tanstack-build": "0.146.0"
+    "@valbuild/tanstack-build": "0.148.0"
   },
   "scripts": {
     "start": "tsx src/cli.ts --",

package/src/cli.ts

@@ -93,6 +93,8 @@ async function main(): Promise<void> {
         --links-own-css          The app links its own CSS (--no-links-own-css for the
                                  opposite; omit it when the build did not say)
         --dry-run                Verify, and stop before the site changes
+        --skip-validation        Publish without running "val validate" first. It runs by
+                                 default, and an error stops the publish
 
       Command: list-unused-files
       Description: EXPERIMENTAL.
@@ -185,6 +187,9 @@ async function main(): Promise<void> {
         dryRun: {
           type: "boolean",
         },
+        skipValidation: {
+          type: "boolean",
+        },
         yes: {
           type: "boolean",
         },
@@ -263,6 +268,7 @@ async function main(): Promise<void> {
         buildHash: flags.buildHash,
         linksOwnCss: flags.linksOwnCss,
         dryRun: flags.dryRun,
+        skipValidation: flags.skipValidation,
       });
     case "login":
       return login({

package/src/publish.test.ts

@@ -0,0 +1,84 @@
+import { error } from "./logger";
+import { publish } from "./publish";
+import { runPublish } from "./publish/runPublish";
+import { validateOnce } from "./validate";
+
+jest.mock("./validate");
+// chalk is ESM-only, which jest cannot load as CommonJS.
+jest.mock("./logger", () => ({ error: jest.fn() }));
+jest.mock("./publish/runPublish", () => ({
+  ...jest.requireActual("./publish/runPublish"),
+  runPublish: jest.fn(),
+}));
+
+const mockValidateOnce = jest.mocked(validateOnce);
+const mockRunPublish = jest.mocked(runPublish);
+const mockError = jest.mocked(error);
+
+/**
+ * `val publish` validates first: content that does not validate does not go
+ * live. It is what lets the Studio trust a connected project's published
+ * content without checking every file itself (docs/plans/studio-validate.md).
+ */
+describe("val publish validates before it publishes", () => {
+  let log: jest.SpyInstance;
+  let errorLog: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    process.exitCode = undefined;
+    log = jest.spyOn(console, "log").mockImplementation(() => undefined);
+    errorLog = jest.spyOn(console, "error").mockImplementation(() => undefined);
+    mockRunPublish.mockResolvedValue({
+      status: "verified",
+      publishId: "p1",
+      artifacts: 1,
+      uploaded: 0,
+      uploadedBytes: 0,
+      previewUrl: null,
+    });
+  });
+
+  afterEach(() => {
+    log.mockRestore();
+    errorLog.mockRestore();
+    process.exitCode = undefined;
+  });
+
+  test("a validation error stops the publish before anything is built", async () => {
+    mockValidateOnce.mockResolvedValue(2);
+    await publish({ root: "/project", dryRun: true });
+    expect(mockValidateOnce).toHaveBeenCalledWith({
+      projectRoot: "/project",
+      fix: false,
+      // Refused on what the Studio's Publish refuses on, and no more.
+      blockingOnly: true,
+    });
+    expect(mockRunPublish).not.toHaveBeenCalled();
+    expect(mockError).toHaveBeenCalledWith(
+      "Not published: 2 validation errors.",
+    );
+    expect(process.exitCode).toBe(1);
+  });
+
+  test("it never fixes: CI must not rewrite what it was asked to publish", async () => {
+    mockValidateOnce.mockResolvedValue(0);
+    await publish({ root: "/project" });
+    expect(mockValidateOnce).toHaveBeenCalledWith(
+      expect.objectContaining({ fix: false }),
+    );
+  });
+
+  test("content that validates is published", async () => {
+    mockValidateOnce.mockResolvedValue(0);
+    await publish({ root: "/project", dryRun: true });
+    expect(mockRunPublish).toHaveBeenCalledTimes(1);
+    expect(process.exitCode).toBeUndefined();
+  });
+
+  test("--skip-validation publishes without validating", async () => {
+    await publish({ root: "/project", dryRun: true, skipValidation: true });
+    expect(mockValidateOnce).not.toHaveBeenCalled();
+    expect(mockRunPublish).toHaveBeenCalledTimes(1);
+  });
+});

package/src/publish.ts

@@ -1,7 +1,9 @@
+import path from "path";
 import pc from "picocolors";
 import { error } from "./logger";
 import { PublishProblem } from "@valbuild/shared/internal";
 import { formatBytes, runPublish } from "./publish/runPublish";
+import { validateOnce } from "./validate";
 
 /**
  * `val publish` - a built project in, a live site out.
@@ -19,7 +21,42 @@ export async function publish(options: {
   buildHash?: string;
   linksOwnCss?: boolean;
   dryRun?: boolean;
+  skipValidation?: boolean;
 }): Promise<void> {
+  // Content that does not validate is not published. This is the check that
+  // lets the Studio trust a connected project's published content without
+  // re-checking every file itself: whatever reached the site went through
+  // here. Without `--fix`, so CI never rewrites what it was asked to publish.
+  //
+  // Refused on what the Studio's Publish refuses on, and no more: an error
+  // the Studio leaves to the server to repair (a local image in a remote
+  // project, metadata to fill in) is printed and published, as it would be
+  // from the Studio. Every site made on /new starts with its template's
+  // images local, so counting those would refuse its first publish.
+  if (!options.skipValidation) {
+    const projectRoot = options.root
+      ? path.resolve(options.root)
+      : process.cwd();
+    const errorCount = await validateOnce({
+      projectRoot,
+      fix: false,
+      blockingOnly: true,
+    });
+    if (errorCount > 0) {
+      error(
+        `Not published: ${errorCount} validation error${errorCount === 1 ? "" : "s"}.`,
+      );
+      console.error(
+        pc.dim(
+          `    Run "val validate --fix" in the project, commit what it changes and push, ` +
+            `and fix by hand what it cannot. --skip-validation publishes anyway.`,
+        ),
+      );
+      process.exitCode = 1;
+      return;
+    }
+  }
+
   const result = await runPublish({
     ...(options.root ? { root: options.root } : {}),
     ...(options.artifacts ? { artifacts: options.artifacts } : {}),

package/src/runValidation.imageset.test.ts

@@ -213,6 +213,29 @@ describe("val validate with remote image and file collections", () => {
     fs.rmSync(root, { recursive: true, force: true });
   });
 
+  // What `val publish` refuses on (`validateOnce({ blockingOnly })`): a
+  // local file still to upload is the Studio's to repair, and is published;
+  // a gallery keyed by a ref it does not know is a person's to fix.
+  test("an error the Studio repairs on save is marked as such, and a person's is not", async () => {
+    const events = errorsOf(
+      await run(
+        root,
+        ["content/images.val.ts", "content/local-images.val.ts"],
+        false,
+      ),
+    );
+    const repaired = (sourcePath: string) =>
+      events
+        .filter((e) => e.sourcePath === sourcePath)
+        .map((e) => e.repairedOnSave === true);
+    expect(repaired(`/content/images.val.ts?p="${LOGO}"`)).toEqual([true]);
+    const local = events.filter((e) =>
+      e.sourcePath.startsWith("/content/local-images.val.ts"),
+    );
+    expect(local.length).toBeGreaterThan(0);
+    expect(local.every((e) => e.repairedOnSave !== true)).toBe(true);
+  });
+
   test("--fix uploads the entries, renames their keys, and points the page's field and rich text image at them", async () => {
     fs.mkdirSync(path.join(root, ".val"), { recursive: true });
     fs.writeFileSync(

package/src/runValidation.ts

@@ -1,5 +1,6 @@
 import path from "path";
 import {
+  askOncePerHost,
   createDefaultValFSHost,
   createFixPatch,
   createService,
@@ -19,6 +20,7 @@ import {
   SourcePath,
 } from "@valbuild/core";
 import {
+  isRepairedOnSave,
   resolveSchemaSourceFixes,
   type SchemaSourceSnapshot,
 } from "@valbuild/shared/internal";
@@ -58,6 +60,10 @@ export async function* runValidation({
   fs: IValFSHost;
 }): AsyncGenerator<ValidationEvent> {
   const projectRoot = path.resolve(root);
+  // One question per platform host for the whole run: each error is fixed by
+  // its own createFixPatch call, and a host that does not answer would
+  // otherwise cost a timeout per ref.
+  const askHostProject = askOncePerHost();
 
   const service = await createService(projectRoot, fs);
 
@@ -260,6 +266,7 @@ export async function* runValidation({
                   sourcePath,
                   message: result.errorMessage ?? "Unknown error",
                   ...(v.keyError ? { keyError: true } : {}),
+                  ...(isRepairedOnSave(v) ? { repairedOnSave: true } : {}),
                 };
                 fileErrors += 1;
                 continue;
@@ -277,13 +284,18 @@ export async function* runValidation({
                   message: result.fixableErrorMessage,
                   fixable: true,
                   ...(v.keyError ? { keyError: true } : {}),
+                  ...(isRepairedOnSave(v) ? { repairedOnSave: true } : {}),
                 };
               }
 
               // Apply patch if needed
               if (result.shouldApplyPatch) {
                 const fixPatch = await createFixPatch(
-                  { projectRoot, remoteHost: remote.remoteHost },
+                  {
+                    projectRoot,
+                    remoteHost: remote.remoteHost,
+                    askHostProject,
+                  },
                   !!fix,
                   sourcePath as SourcePath,
                   v,
@@ -319,6 +331,7 @@ export async function* runValidation({
                     message: v.message,
                     fixable: true,
                     ...(v.keyError ? { keyError: true } : {}),
+                    ...(isRepairedOnSave(v) ? { repairedOnSave: true } : {}),
                   };
                 }
 
@@ -332,6 +345,7 @@ export async function* runValidation({
                     message: e.message,
                     fixable: !!(e.fixes && e.fixes.length),
                     ...(e.keyError ? { keyError: true } : {}),
+                    ...(isRepairedOnSave(e) ? { repairedOnSave: true } : {}),
                   };
                 }
               }