@valbuild/cli 0.147.0 → 0.148.0

package/src/validate.ts

@@ -45,338 +45,360 @@ export async function validate({
     console.log("Prettier not found, skipping formatting");
   }
 
-  // Runs a single validation pass over the project and returns the number of
-  // errors found. Re-reads config and val files each call so it always reflects
-  // the latest state on disk (used both for one-shot and watch mode).
-  async function runOnce(): Promise<number> {
-    const valConfigFile = await findAndEvalValConfigFile(projectRoot);
-
-    const resolvedValConfigFile = valConfigFile
-      ? {
-          ...valConfigFile,
-          project: process.env.VAL_PROJECT || valConfigFile.project,
-        }
-      : process.env.VAL_PROJECT
-        ? { project: process.env.VAL_PROJECT }
-        : undefined;
+  const runOnce = () => validateOnce({ projectRoot, fix: !!fix, prettier });
 
-    console.log(
-      picocolors.greenBright(
-        `Validating project${resolvedValConfigFile?.project ? ` '${picocolors.inverse(resolvedValConfigFile.project)}'` : ""}...`,
-      ),
-    );
+  if (!watch) {
+    const totalErrors = await runOnce();
+    if (totalErrors > 0) {
+      process.exit(1);
+    }
+    return;
+  }
 
-    const valFiles: string[] = await glob("**/*.val.{js,ts}", {
-      ignore: ["node_modules/**"],
-      cwd: projectRoot,
-    });
-
-    console.log(picocolors.greenBright(`Found ${valFiles.length} files...`));
-
-    const fixedFiles = new Set<string>();
-    let totalErrors = 0;
-
-    // Caches each val file's parsed source so files are read/parsed at most once
-    // per pass when resolving sourcePaths to file locations and code frames.
-    const sourceFileCache: SourceFileCache = new Map();
-
-    // Diagnostics are buffered per module (keyed by relative file path) so we can
-    // render them grouped and prioritised after the run, rather than streaming
-    // them out interleaved. Transient progress (remote/fix-applied) still streams
-    // live below.
-    const reports = new Map<string, ModuleReport>();
-    const valid: { file: string; durationMs: number }[] = [];
-    const skipped: string[] = [];
-
-    // Relative file path (no leading slash), matching the code frame's
-    // relativeFile so headers, diagnostics and frames all agree.
-    const relFile = (file: string) => file.replace(/^\//, "");
-    // The module a sourcePath/file belongs to is the part before the `?p=...`.
-    const moduleOf = (sourcePathOrFile: string) =>
-      relFile(sourcePathOrFile.split("?")[0]);
-
-    const reportFor = (file: string): ModuleReport => {
-      const key = relFile(file);
-      let report = reports.get(key);
-      if (!report) {
-        report = { file: key, durationMs: 0, diagnostics: [] };
-        reports.set(key, report);
-      }
-      return report;
-    };
-
-    for await (const event of runValidation({
-      root: projectRoot,
-      fix: !!fix,
-      valFiles,
-      project: resolvedValConfigFile?.project,
-      remote: {
-        remoteHost: process.env.VAL_REMOTE_HOST || DEFAULT_VAL_REMOTE_HOST,
-        getSettings: (projectName, options) =>
-          getSettings(projectName, options),
-        uploadFile: (project, bucket, fileHash, fileExt, fileBuffer, options) =>
-          uploadRemoteFile(
-            process.env.VAL_CONTENT_URL || DEFAULT_CONTENT_HOST,
-            project,
-            bucket,
-            fileHash,
-            fileExt ?? "",
-            fileBuffer,
-            options,
-          ),
-      },
-      fs: createDefaultValFSHost(),
-    })) {
-      switch (event.type) {
-        case "file-valid":
-          valid.push({
-            file: relFile(event.file),
-            durationMs: event.durationMs,
-          });
-          break;
-        case "file-error-count":
-          reportFor(event.file).durationMs = event.durationMs;
-          totalErrors += event.errorCount;
-          break;
-        case "validation-error":
-          reportFor(moduleOf(event.sourcePath)).diagnostics.push({
-            severity: "error",
-            sourcePath: event.sourcePath,
-            message: event.message,
-            ...(event.keyError ? { keyError: true } : {}),
-          });
-          break;
-        case "validation-fixable-error":
-          reportFor(moduleOf(event.sourcePath)).diagnostics.push({
-            severity: event.fixable ? "fixable" : "error",
-            sourcePath: event.sourcePath,
-            message: event.message,
-            ...(event.keyError ? { keyError: true } : {}),
-          });
-          break;
-        case "unknown-fix":
-          reportFor(moduleOf(event.sourcePath)).diagnostics.push({
-            severity: "error",
-            sourcePath: event.sourcePath,
-            message: `Unknown fix: ${event.fixes.join(", ")}`,
-            ...(event.keyError ? { keyError: true } : {}),
-          });
-          break;
-        case "unregistered-module":
-          skipped.push(event.file);
-          break;
-        case "fatal-error":
-          // No sourcePath for fatal errors; group by file, render message only.
-          reportFor(event.file).diagnostics.push({
-            severity: "error",
-            sourcePath: event.file,
-            message: event.message,
-          });
-          break;
-        case "fix-applied":
-          console.log(
-            picocolors.yellow("⚠"),
-            "Applied fix for",
-            event.sourcePath,
-          );
-          fixedFiles.add(event.file);
-          break;
-        case "remote-uploading":
-          console.log(
-            picocolors.yellow("⚠"),
-            `Uploading remote file: '${event.ref}'...`,
-          );
-          break;
-        case "remote-uploaded":
-          console.log(
-            picocolors.green("✔"),
-            `Completed upload of remote file: '${event.ref}'`,
-          );
-          break;
-        case "remote-already-uploaded":
-          console.log(
-            picocolors.yellow("⚠"),
-            `Remote file ${event.filePath} already uploaded`,
-          );
-          break;
-        case "remote-downloading":
-          console.log(
-            picocolors.yellow("⚠"),
-            `Downloading remote file in ${event.sourcePath}...`,
-          );
-          break;
-        case "summary-errors":
-        case "summary-success":
-          break;
+  await watchAndValidate(projectRoot, runOnce);
+}
+
+/**
+ * One validation pass over the project, printed as `val validate` prints it,
+ * returning the number of errors found.
+ *
+ * Re-reads config and val files on each call so it always reflects the latest
+ * state on disk: `val validate` calls it once or on every change (`--watch`),
+ * and `val publish` calls it before it builds anything.
+ */
+export async function validateOnce({
+  projectRoot,
+  fix,
+  prettier,
+  blockingOnly = false,
+}: {
+  projectRoot: string;
+  fix: boolean;
+  /** Formats the files a fix rewrote. Absent: they are left as written. */
+  prettier?: typeof import("prettier");
+  /**
+   * Count only the errors that would hold a publish back in the Studio, not
+   * the ones it leaves to the server to repair on save (`isRepairedOnSave`):
+   * what `val publish` refuses on. Every error is still printed.
+   */
+  blockingOnly?: boolean;
+}): Promise<number> {
+  const valConfigFile = await findAndEvalValConfigFile(projectRoot);
+
+  const resolvedValConfigFile = valConfigFile
+    ? {
+        ...valConfigFile,
+        project: process.env.VAL_PROJECT || valConfigFile.project,
       }
+    : process.env.VAL_PROJECT
+      ? { project: process.env.VAL_PROJECT }
+      : undefined;
+
+  console.log(
+    picocolors.greenBright(
+      `Validating project${resolvedValConfigFile?.project ? ` '${picocolors.inverse(resolvedValConfigFile.project)}'` : ""}...`,
+    ),
+  );
+
+  const valFiles: string[] = await glob("**/*.val.{js,ts}", {
+    ignore: ["node_modules/**"],
+    cwd: projectRoot,
+  });
+
+  console.log(picocolors.greenBright(`Found ${valFiles.length} files...`));
+
+  const fixedFiles = new Set<string>();
+  let totalErrors = 0;
+  let repairedOnSave = 0;
+
+  // Caches each val file's parsed source so files are read/parsed at most once
+  // per pass when resolving sourcePaths to file locations and code frames.
+  const sourceFileCache: SourceFileCache = new Map();
+
+  // Diagnostics are buffered per module (keyed by relative file path) so we can
+  // render them grouped and prioritised after the run, rather than streaming
+  // them out interleaved. Transient progress (remote/fix-applied) still streams
+  // live below.
+  const reports = new Map<string, ModuleReport>();
+  const valid: { file: string; durationMs: number }[] = [];
+  const skipped: string[] = [];
+
+  // Relative file path (no leading slash), matching the code frame's
+  // relativeFile so headers, diagnostics and frames all agree.
+  const relFile = (file: string) => file.replace(/^\//, "");
+  // The module a sourcePath/file belongs to is the part before the `?p=...`.
+  const moduleOf = (sourcePathOrFile: string) =>
+    relFile(sourcePathOrFile.split("?")[0]);
+
+  const reportFor = (file: string): ModuleReport => {
+    const key = relFile(file);
+    let report = reports.get(key);
+    if (!report) {
+      report = { file: key, durationMs: 0, diagnostics: [] };
+      reports.set(key, report);
+    }
+    return report;
+  };
+
+  for await (const event of runValidation({
+    root: projectRoot,
+    fix,
+    valFiles,
+    project: resolvedValConfigFile?.project,
+    remote: {
+      remoteHost: process.env.VAL_REMOTE_HOST || DEFAULT_VAL_REMOTE_HOST,
+      getSettings: (projectName, options) => getSettings(projectName, options),
+      uploadFile: (project, bucket, fileHash, fileExt, fileBuffer, options) =>
+        uploadRemoteFile(
+          process.env.VAL_CONTENT_URL || DEFAULT_CONTENT_HOST,
+          project,
+          bucket,
+          fileHash,
+          fileExt ?? "",
+          fileBuffer,
+          options,
+        ),
+    },
+    fs: createDefaultValFSHost(),
+  })) {
+    switch (event.type) {
+      case "file-valid":
+        valid.push({
+          file: relFile(event.file),
+          durationMs: event.durationMs,
+        });
+        break;
+      case "file-error-count":
+        reportFor(event.file).durationMs = event.durationMs;
+        totalErrors += event.errorCount;
+        break;
+      case "validation-error":
+        if (event.repairedOnSave) repairedOnSave += 1;
+        reportFor(moduleOf(event.sourcePath)).diagnostics.push({
+          severity: "error",
+          sourcePath: event.sourcePath,
+          message: event.message,
+          ...(event.keyError ? { keyError: true } : {}),
+        });
+        break;
+      case "validation-fixable-error":
+        if (event.repairedOnSave) repairedOnSave += 1;
+        reportFor(moduleOf(event.sourcePath)).diagnostics.push({
+          severity: event.fixable ? "fixable" : "error",
+          sourcePath: event.sourcePath,
+          message: event.message,
+          ...(event.keyError ? { keyError: true } : {}),
+        });
+        break;
+      case "unknown-fix":
+        reportFor(moduleOf(event.sourcePath)).diagnostics.push({
+          severity: "error",
+          sourcePath: event.sourcePath,
+          message: `Unknown fix: ${event.fixes.join(", ")}`,
+          ...(event.keyError ? { keyError: true } : {}),
+        });
+        break;
+      case "unregistered-module":
+        skipped.push(event.file);
+        break;
+      case "fatal-error":
+        // No sourcePath for fatal errors; group by file, render message only.
+        reportFor(event.file).diagnostics.push({
+          severity: "error",
+          sourcePath: event.file,
+          message: event.message,
+        });
+        break;
+      case "fix-applied":
+        console.log(
+          picocolors.yellow("⚠"),
+          "Applied fix for",
+          event.sourcePath,
+        );
+        fixedFiles.add(event.file);
+        break;
+      case "remote-uploading":
+        console.log(
+          picocolors.yellow("⚠"),
+          `Uploading remote file: '${event.ref}'...`,
+        );
+        break;
+      case "remote-uploaded":
+        console.log(
+          picocolors.green("✔"),
+          `Completed upload of remote file: '${event.ref}'`,
+        );
+        break;
+      case "remote-already-uploaded":
+        console.log(
+          picocolors.yellow("⚠"),
+          `Remote file ${event.filePath} already uploaded`,
+        );
+        break;
+      case "remote-downloading":
+        console.log(
+          picocolors.yellow("⚠"),
+          `Downloading remote file in ${event.sourcePath}...`,
+        );
+        break;
+      case "summary-errors":
+      case "summary-success":
+        break;
     }
+  }
 
-    // Renders a module's diagnostics under a single left "│" gutter bar, with the
-    // file name on top and blank gutter lines for air. Output flows least- to
-    // most-actionable top-to-bottom, so fixable diagnostics are shown last (at the
-    // bottom, nearest the prompt).
-    const renderModule = (report: ModuleReport) => {
-      const bar = picocolors.dim("│");
-      const diagnostics = [...report.diagnostics].sort((a, b) =>
-        a.severity === b.severity ? 0 : a.severity === "fixable" ? 1 : -1,
+  // Renders a module's diagnostics under a single left "│" gutter bar, with the
+  // file name on top and blank gutter lines for air. Output flows least- to
+  // most-actionable top-to-bottom, so fixable diagnostics are shown last (at the
+  // bottom, nearest the prompt).
+  const renderModule = (report: ModuleReport) => {
+    const bar = picocolors.dim("│");
+    const diagnostics = [...report.diagnostics].sort((a, b) =>
+      a.severity === b.severity ? 0 : a.severity === "fixable" ? 1 : -1,
+    );
+    const fixableCount = diagnostics.filter(
+      (d) => d.severity === "fixable",
+    ).length;
+    const total = diagnostics.length;
+    const hasError = fixableCount < total;
+    const symbol = hasError ? picocolors.red("✘") : picocolors.yellow("⚠");
+    let label: string;
+    if (fixableCount === total) {
+      label = `${fixableCount} fixable`;
+    } else if (fixableCount > 0) {
+      label = `${total} error${total > 1 ? "s" : ""} (${fixableCount} fixable)`;
+    } else {
+      label = `${total} error${total > 1 ? "s" : ""}`;
+    }
+    console.log(
+      `${picocolors.bold(report.file)}  ${symbol} ${label}  ${picocolors.dim(
+        `(${report.durationMs}ms)`,
+      )}`,
+    );
+    for (const d of diagnostics) {
+      const target = d.keyError ? "key" : "value";
+      const dsym =
+        d.severity === "fixable" ? picocolors.yellow("⚠") : picocolors.red("✘");
+      const parts = sourcePathToLocationParts(
+        d.sourcePath,
+        projectRoot,
+        sourceFileCache,
+        target,
       );
-      const fixableCount = diagnostics.filter(
-        (d) => d.severity === "fixable",
-      ).length;
-      const total = diagnostics.length;
-      const hasError = fixableCount < total;
-      const symbol = hasError ? picocolors.red("✘") : picocolors.yellow("⚠");
-      let label: string;
-      if (fixableCount === total) {
-        label = `${fixableCount} fixable`;
-      } else if (fixableCount > 0) {
-        label = `${total} error${total > 1 ? "s" : ""} (${fixableCount} fixable)`;
+      console.log(bar);
+      if (parts) {
+        // `file:line:col` (no key/value label) so VS Code's terminal links it.
+        console.log(
+          `${bar}  ${dsym}  ${parts.relativeFile}:${parts.line}:${parts.character}`,
+        );
+        console.log(`${bar}     ${d.message}`);
       } else {
-        label = `${total} error${total > 1 ? "s" : ""}`;
+        console.log(`${bar}  ${dsym}  ${d.message}`);
       }
-      console.log(
-        `${picocolors.bold(report.file)}  ${symbol} ${label}  ${picocolors.dim(
-          `(${report.durationMs}ms)`,
-        )}`,
+      const frame = sourcePathToCodeFrame(
+        d.sourcePath,
+        projectRoot,
+        sourceFileCache,
+        target,
       );
-      for (const d of diagnostics) {
-        const target = d.keyError ? "key" : "value";
-        const dsym =
-          d.severity === "fixable"
-            ? picocolors.yellow("⚠")
-            : picocolors.red("✘");
-        const parts = sourcePathToLocationParts(
-          d.sourcePath,
-          projectRoot,
-          sourceFileCache,
-          target,
-        );
+      if (frame !== undefined) {
         console.log(bar);
-        if (parts) {
-          // `file:line:col` (no key/value label) so VS Code's terminal links it.
-          console.log(
-            `${bar}  ${dsym}  ${parts.relativeFile}:${parts.line}:${parts.character}`,
-          );
-          console.log(`${bar}     ${d.message}`);
-        } else {
-          console.log(`${bar}  ${dsym}  ${d.message}`);
-        }
-        const frame = sourcePathToCodeFrame(
-          d.sourcePath,
-          projectRoot,
-          sourceFileCache,
-          target,
-        );
-        if (frame !== undefined) {
-          console.log(bar);
-          for (const frameLine of frame.split("\n")) {
-            console.log(`${bar}     ${frameLine}`);
-          }
-        }
-        if (d.severity === "fixable") {
-          console.log(
-            `${bar}     ${picocolors.dim("→ run with --fix to apply")}`,
-          );
+        for (const frameLine of frame.split("\n")) {
+          console.log(`${bar}     ${frameLine}`);
         }
       }
-      console.log(bar);
-      console.log("");
-    };
-
-    // Format the files that had fixes applied, the way the project formats
-    // everything else. See `formatFixedFiles` for why this cannot simply be
-    // `prettier.format(code, { filepath })`.
-    //
-    // A file that could not be formatted is reported and skipped rather than
-    // thrown: the fix itself landed, and aborting here would leave the fix
-    // applied and the report below unwritten.
-    if (prettier) {
-      const { failures } = await formatFixedFiles(
-        prettier,
-        projectRoot,
-        fixedFiles,
-      );
-      for (const failure of failures) {
+      if (d.severity === "fixable") {
         console.log(
-          picocolors.yellow("⚠"),
-          `Could not format ${relFile(failure.file)}: ${failure.message}`,
+          `${bar}     ${picocolors.dim("→ run with --fix to apply")}`,
         );
       }
     }
+    console.log(bar);
+    console.log("");
+  };
 
-    // Render the grouped report least- to most-actionable, top-to-bottom, so the
-    // most important things end up at the bottom nearest the prompt: valid files
-    // and skipped modules first, then error-only modules, then fixable modules.
-    const allReports = [...reports.values()];
-    const fixableModules = allReports.filter((r) =>
-      r.diagnostics.some((d) => d.severity === "fixable"),
-    );
-    const errorModules = allReports.filter(
-      (r) => !r.diagnostics.some((d) => d.severity === "fixable"),
+  // Format the files that had fixes applied, the way the project formats
+  // everything else. See `formatFixedFiles` for why this cannot simply be
+  // `prettier.format(code, { filepath })`.
+  //
+  // A file that could not be formatted is reported and skipped rather than
+  // thrown: the fix itself landed, and aborting here would leave the fix
+  // applied and the report below unwritten.
+  if (prettier) {
+    const { failures } = await formatFixedFiles(
+      prettier,
+      projectRoot,
+      fixedFiles,
     );
-
-    for (const v of valid) {
-      console.log(
-        picocolors.green("✔"),
-        picocolors.dim(`${v.file}  valid (${v.durationMs}ms)`),
-      );
-    }
-    for (const file of skipped) {
+    for (const failure of failures) {
       console.log(
         picocolors.yellow("⚠"),
-        picocolors.dim(`/${file} is not registered in val.modules - skipping`),
+        `Could not format ${relFile(failure.file)}: ${failure.message}`,
       );
     }
+  }
 
-    if (allReports.length > 0) {
-      console.log("");
-    }
-    for (const report of [...errorModules, ...fixableModules]) {
-      renderModule(report);
-    }
+  // Render the grouped report least- to most-actionable, top-to-bottom, so the
+  // most important things end up at the bottom nearest the prompt: valid files
+  // and skipped modules first, then error-only modules, then fixable modules.
+  const allReports = [...reports.values()];
+  const fixableModules = allReports.filter((r) =>
+    r.diagnostics.some((d) => d.severity === "fixable"),
+  );
+  const errorModules = allReports.filter(
+    (r) => !r.diagnostics.some((d) => d.severity === "fixable"),
+  );
 
-    const fixableTotal = allReports.reduce(
-      (n, r) =>
-        n + r.diagnostics.filter((d) => d.severity === "fixable").length,
-      0,
+  for (const v of valid) {
+    console.log(
+      picocolors.green("✔"),
+      picocolors.dim(`${v.file}  valid (${v.durationMs}ms)`),
+    );
+  }
+  for (const file of skipped) {
+    console.log(
+      picocolors.yellow("⚠"),
+      picocolors.dim(`/${file} is not registered in val.modules - skipping`),
     );
-    if (totalErrors > 0) {
-      let summary = `${totalErrors} error${totalErrors > 1 ? "s" : ""}`;
-      if (fixableTotal > 0) {
-        summary += ` (${fixableTotal} fixable)`;
-      }
-      summary += ` across ${allReports.length} file${
-        allReports.length > 1 ? "s" : ""
-      }`;
-      if (valid.length > 0) {
-        summary += ` · ${valid.length} valid`;
-      }
-      if (skipped.length > 0) {
-        summary += ` · ${skipped.length} skipped`;
-      }
-      console.log(picocolors.red("✘"), summary);
-    } else {
-      let summary = "No validation errors found";
-      if (valid.length > 0) {
-        summary += ` · ${valid.length} valid`;
-      }
-      if (skipped.length > 0) {
-        summary += ` · ${skipped.length} skipped`;
-      }
-      console.log(picocolors.green("✔"), summary);
-    }
-    return totalErrors;
   }
 
-  if (!watch) {
-    const totalErrors = await runOnce();
-    if (totalErrors > 0) {
-      process.exit(1);
-    }
-    return;
+  if (allReports.length > 0) {
+    console.log("");
+  }
+  for (const report of [...errorModules, ...fixableModules]) {
+    renderModule(report);
   }
 
-  await watchAndValidate(projectRoot, runOnce);
+  const fixableTotal = allReports.reduce(
+    (n, r) => n + r.diagnostics.filter((d) => d.severity === "fixable").length,
+    0,
+  );
+  if (totalErrors > 0) {
+    let summary = `${totalErrors} error${totalErrors > 1 ? "s" : ""}`;
+    if (fixableTotal > 0) {
+      summary += ` (${fixableTotal} fixable)`;
+    }
+    summary += ` across ${allReports.length} file${
+      allReports.length > 1 ? "s" : ""
+    }`;
+    if (valid.length > 0) {
+      summary += ` · ${valid.length} valid`;
+    }
+    if (skipped.length > 0) {
+      summary += ` · ${skipped.length} skipped`;
+    }
+    console.log(picocolors.red("✘"), summary);
+  } else {
+    let summary = "No validation errors found";
+    if (valid.length > 0) {
+      summary += ` · ${valid.length} valid`;
+    }
+    if (skipped.length > 0) {
+      summary += ` · ${skipped.length} skipped`;
+    }
+    console.log(picocolors.green("✔"), summary);
+  }
+  return blockingOnly ? totalErrors - repairedOnSave : totalErrors;
 }
 
 // Directory names anywhere in the path that should never be watched.