@smoothbricks/cli 0.1.1 → 0.2.0

package/src/monorepo/packed-package.ts

@@ -3,67 +3,119 @@ import { join } from 'node:path';
 import { publint } from 'publint';
 import { formatMessage } from 'publint/utils';
 import { isRecord } from '../lib/json.js';
-import { runStatus } from '../lib/run.js';
+import { runResult, runStatus } from '../lib/run.js';
 import type { PackageInfo } from '../lib/workspace.js';
 import { listPublicPackages } from '../lib/workspace.js';
 import { readPackedPackageJson, validatePackedWorkspaceDependencies } from './packed-manifest.js';
 
 export async function validatePackedPublicPackages(root: string): Promise<number> {
+  return (
+    (await validatePackedPublicPackagePublint(root)) +
+    (await validatePackedPublicPackageManifest(root)) +
+    (await validatePackedPublicPackageTypes(root))
+  );
+}
+
+export async function validatePackedPublicPackagePublint(root: string): Promise<number> {
   let failures = 0;
   for (const pkg of listPublicPackages(root)) {
-    failures += await validatePackedPublicPackage(root, pkg);
+    failures += await validatePackedPublicPackageTool(root, pkg, validatePublint);
   }
   return failures;
 }
 
-async function validatePackedPublicPackage(root: string, pkg: PackageInfo): Promise<number> {
+export async function validatePackedPublicPackageManifest(root: string): Promise<number> {
   let failures = 0;
-  const packed = await packPackage(root, pkg);
-  try {
-    const lint = await publint({ pack: { tarball: packed.arrayBuffer }, level: 'warning', strict: true });
-    for (const message of lint.messages) {
-      console.error(`${pkg.path}: publint ${message.type} ${message.code}: ${formatMessage(message, lint.pkg)}`);
-      failures++;
-    }
+  for (const pkg of listPublicPackages(root)) {
+    failures += await validatePackedPublicPackageTool(root, pkg, validatePackedManifest);
+  }
+  return failures;
+}
 
-    const packedPackage = await readPackedPackageJson(root, packed.path, pkg.name);
-    for (const message of validatePackedWorkspaceDependencies(root, pkg, packedPackage)) {
-      console.error(message);
-      failures++;
-    }
+export async function validatePackedPublicPackageTypes(root: string): Promise<number> {
+  let failures = 0;
+  for (const pkg of listPublicPackages(root)) {
+    failures += await validatePackedPublicPackageTool(root, pkg, validateAttw);
+  }
+  return failures;
+}
 
-    const attwArgs = [
-      packed.path,
-      '--format',
-      'ascii',
-      '--no-color',
-      '--profile',
-      'node16',
-      '--ignore-rules',
-      'cjs-resolves-to-esm',
-      ...attwExcludedEntrypointArgs(pkg),
-    ];
-    const attwStatus = await runStatus('attw', ['--quiet', ...attwArgs], root, true);
-    if (attwStatus !== 0) {
-      await runStatus('attw', attwArgs, root);
-      console.error(`${pkg.path}: are-the-types-wrong validation failed`);
-      failures++;
-    } else {
-      console.log(`${pkg.path}: are-the-types-wrong valid.`);
-    }
+async function validatePackedPublicPackageTool(
+  root: string,
+  pkg: PackageInfo,
+  validate: (root: string, pkg: PackageInfo, packed: { path: string; arrayBuffer: ArrayBuffer }) => Promise<number>,
+): Promise<number> {
+  const packed = await packPackage(root, pkg);
+  try {
+    return await validate(root, pkg, packed);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     console.error(`${pkg.path}: packed package validation failed: ${message}`);
-    failures++;
+    return 1;
   } finally {
     unlinkSync(packed.path);
   }
-  if (failures === 0) {
-    console.log(`${pkg.path}: packed package is valid.`);
+}
+
+async function validatePublint(
+  _root: string,
+  pkg: PackageInfo,
+  packed: { path: string; arrayBuffer: ArrayBuffer },
+): Promise<number> {
+  let failures = 0;
+  const lint = await publint({ pack: { tarball: packed.arrayBuffer }, level: 'warning', strict: true });
+  for (const message of lint.messages) {
+    console.error(`${pkg.path}: publint ${message.type} ${message.code}: ${formatMessage(message, lint.pkg)}`);
+    failures++;
+  }
+  return failures;
+}
+
+async function validatePackedManifest(
+  root: string,
+  pkg: PackageInfo,
+  packed: { path: string; arrayBuffer: ArrayBuffer },
+): Promise<number> {
+  let failures = 0;
+  const packedPackage = await readPackedPackageJson(root, packed.path, pkg.name);
+  for (const message of validatePackedWorkspaceDependencies(root, pkg, packedPackage)) {
+    console.error(message);
+    failures++;
   }
   return failures;
 }
 
+async function validateAttw(root: string, pkg: PackageInfo, packed: { path: string }): Promise<number> {
+  const attwArgs = [
+    packed.path,
+    '--format',
+    'ascii',
+    '--no-color',
+    '--profile',
+    'node16',
+    '--ignore-rules',
+    'cjs-resolves-to-esm',
+    ...attwExcludedEntrypointArgs(pkg),
+  ];
+  const attw = await runResult('attw', attwArgs, root);
+  if (attw.exitCode === 0) {
+    return 0;
+  }
+  printAttwOutput(attw.stdout);
+  printAttwOutput(attw.stderr);
+  console.error(`${pkg.path}: are-the-types-wrong validation failed`);
+  return 1;
+}
+
+function printAttwOutput(output: string): void {
+  for (const line of output.split('\n')) {
+    if (!line || line.includes('(ignored)')) {
+      continue;
+    }
+    console.error(line);
+  }
+}
+
 function attwExcludedEntrypointArgs(pkg: PackageInfo): string[] {
   const excluded = wasmExportEntrypoints(pkg.json.exports);
   return excluded.length === 0 ? [] : ['--exclude-entrypoints', ...excluded];

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']);
+  });
+});