@smoothbricks/cli 0.1.1 → 0.3.0

package/src/monorepo/packs/index.test.ts

@@ -0,0 +1,189 @@
+import { describe, expect, it } from 'bun:test';
+import type { MonorepoPack } from './index.js';
+import { runValidatePacks } from './index.js';
+
+const ctx = { root: '/workspace', syncRuntime: false };
+
+describe('monorepo validation pack phases', () => {
+  it('runs fix mode in pre-fix, build, post-fix, then validation order', async () => {
+    const events: string[] = [];
+    const packs: MonorepoPack[] = [
+      {
+        name: 'pre',
+        fixPreBuild() {
+          events.push('pre-fix');
+        },
+        validatePreBuild() {
+          events.push('pre-validate');
+          return 0;
+        },
+      },
+      {
+        name: 'post',
+        fixPostBuild() {
+          events.push('post-fix');
+        },
+        validatePostBuild() {
+          events.push('post-validate');
+          return 0;
+        },
+      },
+    ];
+
+    const result = await runValidatePacks(
+      ctx,
+      { fix: true },
+      {
+        packs,
+        runBuild() {
+          events.push('build');
+          return 0;
+        },
+      },
+    );
+
+    expect(result).toEqual({ failures: 0, failedChecks: 0 });
+    expect(events).toEqual(['pre-fix', 'build', 'post-fix', 'pre-validate', 'post-validate']);
+  });
+
+  it('runs normal mode in pre-validation, build, then post-validation order', async () => {
+    const events: string[] = [];
+    const packs: MonorepoPack[] = [
+      {
+        name: 'pre',
+        validatePreBuild() {
+          events.push('pre-validate');
+          return 0;
+        },
+      },
+      {
+        name: 'post',
+        validatePostBuild() {
+          events.push('post-validate');
+          return 0;
+        },
+      },
+    ];
+
+    const result = await runValidatePacks(
+      ctx,
+      {},
+      {
+        packs,
+        runBuild() {
+          events.push('build');
+          return 0;
+        },
+      },
+    );
+
+    expect(result).toEqual({ failures: 0, failedChecks: 0 });
+    expect(events).toEqual(['pre-validate', 'build', 'post-validate']);
+  });
+
+  it('counts separate post-build packs as separate failed checks', async () => {
+    const packs: MonorepoPack[] = [
+      {
+        name: 'workspace-dependencies',
+        validatePostBuild() {
+          return 88;
+        },
+      },
+      {
+        name: 'package-hygiene',
+        validatePostBuild() {
+          return 0;
+        },
+      },
+    ];
+
+    const result = await runValidatePacks(
+      ctx,
+      {},
+      {
+        packs,
+        runBuild() {
+          return 0;
+        },
+      },
+    );
+
+    expect(result).toEqual({ failures: 88, failedChecks: 1 });
+  });
+
+  it('does not build or run post-build validation after a fail-fast pre-build failure', async () => {
+    const events: string[] = [];
+    const packs: MonorepoPack[] = [
+      {
+        name: 'pre',
+        validatePreBuild() {
+          events.push('pre-validate');
+          return 2;
+        },
+      },
+      {
+        name: 'post',
+        validatePostBuild() {
+          events.push('post-validate');
+          return 0;
+        },
+      },
+    ];
+
+    const result = await runValidatePacks(
+      ctx,
+      { failFast: true },
+      {
+        packs,
+        runBuild() {
+          events.push('build');
+          return 0;
+        },
+      },
+    );
+
+    expect(result).toEqual({ failures: 2, failedChecks: 1 });
+    expect(events).toEqual(['pre-validate']);
+  });
+
+  it('does not run post-build fixers or validation after a build failure', async () => {
+    const events: string[] = [];
+    const packs: MonorepoPack[] = [
+      {
+        name: 'pre',
+        fixPreBuild() {
+          events.push('pre-fix');
+        },
+        validatePreBuild() {
+          events.push('pre-validate');
+          return 0;
+        },
+      },
+      {
+        name: 'post',
+        fixPostBuild() {
+          events.push('post-fix');
+        },
+        validatePostBuild() {
+          events.push('post-validate');
+          return 0;
+        },
+      },
+    ];
+
+    const result = await runValidatePacks(
+      ctx,
+      { fix: true },
+      {
+        packs,
+        runBuild() {
+          events.push('build');
+          return 1;
+        },
+      },
+    );
+
+    expect(result).toEqual({ failures: 1, failedChecks: 1 });
+    expect(events).toEqual(['pre-fix', 'build']);
+  });
+});

package/src/monorepo/packs/index.ts

@@ -1,35 +1,66 @@
 import { chmodSync, existsSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-import { validateBunLockfileVersions } from '../lockfile.js';
+import { runStatus } from '../../lib/run.js';
+import { readProjectTargets } from '../../nx/index.js';
+import { syncBunLockfileVersions, validateBunLockfileVersions } from '../lockfile.js';
 import { validateManagedFiles } from '../managed-files.js';
-import { validateNxSync } from '../nx-sync.js';
+import { fixNxSync, validateNxSync } from '../nx-sync.js';
 import { fixPackageHygiene, validatePackageHygiene } from '../package-hygiene.js';
 import {
+  applyFixableMonorepoDefaults,
   applyNxReleaseDefaults,
   applyPublicPackageDefaults,
   applyWorkspaceDependencyDefaults,
+  type ResolvedProjectTargets,
+  validateNxProjectNames,
   validateNxReleaseConfig,
   validatePublicPackageMetadata,
   validatePublicTags,
   validateRootPackagePolicy,
   validateWorkspaceDependencies,
 } from '../package-policy.js';
-import { validatePackedPublicPackages } from '../packed-package.js';
+import {
+  validatePackedPublicPackageManifest,
+  validatePackedPublicPackagePublint,
+  validatePackedPublicPackageTypes,
+} from '../packed-package.js';
 import { syncRootRuntimeVersions } from '../runtime.js';
+import { applyToolConfigDefaults, validateToolConfig } from '../tool-validation.js';
 
 export interface MonorepoContext {
   root: string;
   syncRuntime: boolean;
+  verbose?: boolean;
 }
 
 export interface ValidatePackOptions {
   failFast?: boolean;
+  fix?: boolean;
+  verbose?: boolean;
 }
 
-interface MonorepoPack {
+export interface MonorepoPack {
   name: string;
   init?(ctx: MonorepoContext): Promise<void> | void;
-  validate?(ctx: MonorepoContext): Promise<number> | number;
+  fixPreBuild?(ctx: MonorepoContext): Promise<void> | void;
+  fixPostBuild?(ctx: MonorepoContext): Promise<void> | void;
+  validatePreBuild?(ctx: MonorepoContext): Promise<number> | number;
+  validatePostBuild?(ctx: MonorepoContext): Promise<number> | number;
+}
+
+export interface ValidatePackRunHooks {
+  packs?: readonly MonorepoPack[];
+  runBuild?: (ctx: MonorepoContext, options?: ValidatePackOptions) => Promise<number> | number;
+}
+
+export interface ValidatePackResult {
+  failures: number;
+  failedChecks: number;
+}
+
+interface CapturedOutput {
+  logs: string[];
+  errors: string[];
 }
 
 const packs: MonorepoPack[] = [
@@ -44,13 +75,22 @@ const packs: MonorepoPack[] = [
         console.log('skip           root runtime versions (outside devenv; pass --sync-runtime to force)');
       }
     },
-    async validate(ctx) {
+    async fixPreBuild(ctx) {
+      applyFixableMonorepoDefaults(ctx.root);
+      await applyToolConfigDefaults(ctx.root);
+      syncBunLockfileVersions(ctx.root);
+      await fixNxSync(ctx.root, ctx.verbose === true);
+      applyWorkspaceDependencyDefaults(ctx.root, { resolvedTargetsByProject: await readResolvedTargetsByProject(ctx) });
+    },
+    async validatePreBuild(ctx) {
       return (
         validateManagedFiles(ctx.root) +
         validateRootPackagePolicy(ctx.root) +
+        validateToolConfig(ctx.root) +
+        validateNxProjectNames(ctx.root) +
         validateNxReleaseConfig(ctx.root) +
         validateBunLockfileVersions(ctx.root) +
-        (await validateNxSync(ctx.root))
+        (await validateNxSync(ctx.root, ctx.verbose === true))
       );
     },
   },
@@ -59,24 +99,55 @@ const packs: MonorepoPack[] = [
     init(ctx) {
       applyPublicPackageDefaults(ctx.root);
     },
-    validate(ctx) {
+    fixPreBuild(ctx) {
+      applyPublicPackageDefaults(ctx.root);
+    },
+    validatePreBuild(ctx) {
       return validatePublicTags(ctx.root) + validatePublicPackageMetadata(ctx.root);
     },
   },
   {
     name: 'workspace-dependencies',
-    async init(ctx) {
+    init(ctx) {
       applyWorkspaceDependencyDefaults(ctx.root);
+    },
+    async fixPostBuild(ctx) {
+      applyWorkspaceDependencyDefaults(ctx.root, { resolvedTargetsByProject: await readResolvedTargetsByProject(ctx) });
+    },
+    async validatePostBuild(ctx) {
+      return validateWorkspaceDependencies(ctx.root, {
+        resolvedTargetsByProject: await readResolvedTargetsByProject(ctx),
+      });
+    },
+  },
+  {
+    name: 'package-hygiene',
+    async init(ctx) {
+      await fixPackageHygiene(ctx.root, ctx.verbose === true);
+    },
+    async fixPostBuild(ctx) {
       await fixPackageHygiene(ctx.root);
     },
-    async validate(ctx) {
-      return validateWorkspaceDependencies(ctx.root) + (await validatePackageHygiene(ctx.root));
+    async validatePostBuild(ctx) {
+      return validatePackageHygiene(ctx.root, ctx.verbose === true);
+    },
+  },
+  {
+    name: 'packed-package-publint',
+    validatePostBuild(ctx) {
+      return validatePackedPublicPackagePublint(ctx.root);
+    },
+  },
+  {
+    name: 'packed-package-manifest',
+    validatePostBuild(ctx) {
+      return validatePackedPublicPackageManifest(ctx.root);
     },
   },
   {
-    name: 'packed-packages',
-    validate(ctx) {
-      return validatePackedPublicPackages(ctx.root);
+    name: 'packed-package-types',
+    validatePostBuild(ctx) {
+      return validatePackedPublicPackageTypes(ctx.root);
     },
   },
 ];
@@ -87,22 +158,242 @@ export async function runInitPacks(ctx: MonorepoContext): Promise<void> {
   }
 }
 
-export async function runValidatePacks(ctx: MonorepoContext, options: ValidatePackOptions = {}): Promise<number> {
+export async function runValidatePacks(
+  ctx: MonorepoContext,
+  options: ValidatePackOptions = {},
+  hooks: ValidatePackRunHooks = {},
+): Promise<ValidatePackResult> {
+  const selectedPacks = hooks.packs ?? packs;
+  const build = hooks.runBuild ?? runBuild;
+
+  if (options.fix) {
+    await runFixPhase(ctx, selectedPacks, 'pre-build', 'fixPreBuild');
+    const buildFailures = await build(ctx, options);
+    if (buildFailures > 0) {
+      return { failures: buildFailures, failedChecks: 1 };
+    }
+    await runFixPhase(ctx, selectedPacks, 'post-build', 'fixPostBuild');
+    return runValidationPhases(ctx, selectedPacks, options, false);
+  }
+
+  const preBuild = await runValidationPhase(ctx, selectedPacks, options, 'pre-build', 'validatePreBuild', false);
+  if (preBuild.failures > 0 && options.failFast) {
+    return preBuild;
+  }
+  const buildFailures = await build(ctx, options);
+  if (buildFailures > 0) {
+    return { failures: preBuild.failures + buildFailures, failedChecks: preBuild.failedChecks + 1 };
+  }
+  return sumResults(
+    preBuild,
+    await runValidationPhase(ctx, selectedPacks, options, 'post-build', 'validatePostBuild', true),
+  );
+}
+
+async function runValidationPhases(
+  ctx: MonorepoContext,
+  selectedPacks: readonly MonorepoPack[],
+  options: ValidatePackOptions,
+  printedBefore: boolean,
+): Promise<ValidatePackResult> {
+  const preBuild = await runValidationPhase(
+    ctx,
+    selectedPacks,
+    options,
+    'pre-build',
+    'validatePreBuild',
+    printedBefore,
+  );
+  if (preBuild.failures > 0 && options.failFast) {
+    return preBuild;
+  }
+  return sumResults(
+    preBuild,
+    await runValidationPhase(ctx, selectedPacks, options, 'post-build', 'validatePostBuild', true),
+  );
+}
+
+async function runValidationPhase(
+  ctx: MonorepoContext,
+  selectedPacks: readonly MonorepoPack[],
+  options: ValidatePackOptions,
+  phase: 'pre-build' | 'post-build',
+  method: 'validatePreBuild' | 'validatePostBuild',
+  printedBefore: boolean,
+): Promise<ValidatePackResult> {
   let failures = 0;
+  let failedChecks = 0;
   let checkedPacks = 0;
-  for (const pack of packs) {
-    if (!pack.validate) {
+  let hasPrinted = printedBefore;
+  for (const pack of selectedPacks) {
+    const validate = pack[method];
+    if (!validate) {
       continue;
     }
-    console.log(`${checkedPacks === 0 ? '' : '\n'}== ${pack.name} ==`);
+    const label = `${pack.name} (${phase})`;
+    if (options.verbose) {
+      printCheckHeading(label, hasPrinted || checkedPacks > 0);
+    }
+    hasPrinted = true;
     checkedPacks++;
-    const packFailures = await pack.validate(ctx);
+    let packFailures: number;
+    let output = emptyCapturedOutput();
+    try {
+      if (options.verbose) {
+        packFailures = await validate(ctx);
+      } else {
+        const captured = await captureConsoleOutput(() => validate(ctx));
+        packFailures = captured.result;
+        output = captured.output;
+      }
+    } catch (error) {
+      if (!options.verbose) {
+        printCheckHeading(label, true);
+        if (error instanceof CapturedConsoleError) {
+          output = error.output;
+        }
+        printCapturedOutput(output);
+      }
+      throw error instanceof CapturedConsoleError ? error.cause : error;
+    }
     failures += packFailures;
+    if (packFailures > 0) {
+      failedChecks++;
+    }
+    if (!options.verbose && packFailures > 0) {
+      printCheckHeading(label, true);
+      printCapturedOutput(output);
+    }
+    printCheckStatus(label, packFailures);
     if (packFailures > 0 && options.failFast) {
       break;
     }
   }
-  return failures;
+  return { failures, failedChecks };
+}
+
+function sumResults(left: ValidatePackResult, right: ValidatePackResult): ValidatePackResult {
+  return { failures: left.failures + right.failures, failedChecks: left.failedChecks + right.failedChecks };
+}
+
+async function runFixPhase(
+  ctx: MonorepoContext,
+  selectedPacks: readonly MonorepoPack[],
+  phase: 'pre-build' | 'post-build',
+  method: 'fixPreBuild' | 'fixPostBuild',
+): Promise<void> {
+  let checkedPacks = 0;
+  for (const pack of selectedPacks) {
+    const fix = pack[method];
+    if (!fix) {
+      continue;
+    }
+    const label = `${pack.name} (${phase} fix)`;
+    if (ctx.verbose) {
+      printCheckHeading(label, checkedPacks > 0);
+    }
+    checkedPacks++;
+    if (ctx.verbose) {
+      await fix(ctx);
+      continue;
+    }
+    let output = emptyCapturedOutput();
+    try {
+      output = (await captureConsoleOutput(() => fix(ctx))).output;
+    } catch (error) {
+      if (error instanceof CapturedConsoleError) {
+        output = error.output;
+      }
+      printCheckHeading(label, true);
+      printCapturedOutput(output);
+      throw error instanceof CapturedConsoleError ? error.cause : error;
+    }
+  }
+}
+
+async function runBuild(ctx: MonorepoContext, options: ValidatePackOptions = {}): Promise<number> {
+  if (options.verbose) {
+    printCheckHeading('build', true);
+  }
+  const status = await runStatus('nx', ['run-many', '-t', 'build'], ctx.root, options.verbose !== true);
+  if (status !== 0) {
+    if (!options.verbose) {
+      printCheckHeading('build', true);
+    }
+    console.error('nx run-many -t build failed');
+    printCheckStatus('build', 1);
+    return 1;
+  }
+  printCheckStatus('build', 0);
+  return 0;
+}
+
+function printCheckStatus(label: string, failures: number): void {
+  if (failures === 0) {
+    console.log(`🆗 ${label}`);
+    return;
+  }
+  const noun = failures === 1 ? 'problem' : 'problems';
+  console.log(`👎 ${label} (${failures} ${noun})\n`);
+}
+
+function printCheckHeading(label: string, separate: boolean): void {
+  console.log(`${separate ? '\n' : ''}== ${label} ==`);
+}
+
+function emptyCapturedOutput(): CapturedOutput {
+  return { logs: [], errors: [] };
+}
+
+async function captureConsoleOutput<T>(fn: () => Promise<T> | T): Promise<{ result: T; output: CapturedOutput }> {
+  const output = emptyCapturedOutput();
+  const originalLog = console.log;
+  const originalError = console.error;
+  console.log = (...args: unknown[]) => {
+    output.logs.push(args.join(' '));
+  };
+  console.error = (...args: unknown[]) => {
+    output.errors.push(args.join(' '));
+  };
+  try {
+    return { result: await fn(), output };
+  } catch (error) {
+    throw new CapturedConsoleError(error, output);
+  } finally {
+    console.log = originalLog;
+    console.error = originalError;
+  }
+}
+
+class CapturedConsoleError extends Error {
+  constructor(
+    public override readonly cause: unknown,
+    public readonly output: CapturedOutput,
+  ) {
+    super(cause instanceof Error ? cause.message : String(cause));
+  }
+}
+
+function printCapturedOutput(output: CapturedOutput): void {
+  for (const line of output.logs) {
+    console.log(line);
+  }
+  for (const line of output.errors) {
+    console.log(line);
+  }
+}
+
+async function readResolvedTargetsByProject(ctx: MonorepoContext): Promise<Map<string, ResolvedProjectTargets>> {
+  const projects = await readProjectTargets(ctx.root);
+  return new Map(
+    projects.map((project) => [
+      project.project,
+      {
+        targets: new Set(project.targets),
+        ...(project.buildDependsOn ? { buildDependsOn: project.buildDependsOn } : {}),
+      },
+    ]),
+  );
 }
 
 function ensureLocalSmooShim(root: string): void {