@smoothbricks/cli 0.10.1 → 0.10.3

package/src/github-ci/index.ts

@@ -3,6 +3,8 @@ import { appendFile, mkdtemp, realpath, rename, rm } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { $ } from 'bun';
 import { decode, run, runStatus } from '../lib/run.js';
+import { type ProjectTargets, readProjectTargets } from '../nx/index.js';
+import type { NxTargetRun } from './outputs.js';
 
 type NxSmartMode = 'auto' | 'affected' | 'run-many';
 
@@ -113,6 +115,15 @@ async function addReferencesFrom(roots: Set<string>, path: string, cwd: string):
   }
 }
 
+export function nxSmartArgs(target: string, mode: 'affected' | 'run-many', configuration?: string): string[] {
+  const args = [mode, '-t', target];
+  if (configuration) {
+    args.push(`--configuration=${configuration}`);
+  }
+  args.push(`--exclude=tag:ci:skip:${target}`, '--parallel=5');
+  return args;
+}
+
 export async function githubCiNxSmart(
   root: string,
   options: { target: string; name?: string; step?: string; mode?: NxSmartMode; configuration?: string },
@@ -121,11 +132,7 @@ export async function githubCiNxSmart(
   const step = options.step ?? '';
   await createGithubStatus(name, step);
   const mode = resolveNxSmartMode(options.mode ?? 'auto');
-  const nxArgs = mode === 'run-many' ? ['run-many', '-t', options.target] : ['affected', '-t', options.target];
-  if (options.configuration) {
-    nxArgs.push(`--configuration=${options.configuration}`);
-  }
-  nxArgs.push('--parallel=5');
+  const nxArgs = nxSmartArgs(options.target, mode, options.configuration);
   const status = await runStatus('nx', nxArgs, root);
   await updateGithubStatus(name, status === 0 ? 'success' : 'failure', step);
   if (status !== 0) {
@@ -133,18 +140,170 @@ export async function githubCiNxSmart(
   }
 }
 
-export async function githubCiNxRunMany(
+export interface NxRunManyOptions {
+  targets: string;
+  projects?: string;
+  configuration?: string;
+  collectOutputs?: string;
+  allowEmptyProjects?: boolean;
+}
+
+export interface ExpandedNxTargetRuns {
+  runs: NxTargetRun[];
+  unmatchedGlobs: string[];
+}
+
+export function expandNxTargetRuns(projects: ProjectTargets[], options: NxRunManyOptions): ExpandedNxTargetRuns {
+  const selectedProjects = selectProjects(projects, options.projects);
+  if (options.projects !== undefined && selectedProjects.length === 0 && options.allowEmptyProjects !== true) {
+    throw new Error(`No Nx projects matched --projects ${options.projects}.`);
+  }
+  const selectedTargetNames = [...new Set(selectedProjects.flatMap((project) => project.targets))].sort((a, b) =>
+    a.localeCompare(b),
+  );
+  const runs: NxTargetRun[] = [];
+  const unmatchedGlobs: string[] = [];
+  const addedTargets = new Set<string>();
+  for (const targetPattern of commaSeparatedValues(options.targets)) {
+    const isGlob = isGlobPattern(targetPattern);
+    const targets = isGlob
+      ? selectedTargetNames.filter((target) => new Bun.Glob(targetPattern).match(target))
+      : [targetPattern];
+    if (isGlob && targets.length === 0) {
+      unmatchedGlobs.push(targetPattern);
+    }
+    for (const target of targets) {
+      if (addedTargets.has(target)) {
+        continue;
+      }
+      const owners = selectedProjects.filter((project) => project.targets.includes(target));
+      const runProjects = owners.length > 0 ? owners : selectedProjects;
+      if (runProjects.length === 0) {
+        continue;
+      }
+      addedTargets.add(target);
+      runs.push({ target, projects: runProjects });
+    }
+  }
+  return { runs, unmatchedGlobs };
+}
+
+export function expandNxTargetDependencyRuns(runs: NxTargetRun[]): NxTargetRun[] {
+  const expanded: NxTargetRun[] = [];
+  const added = new Set<string>();
+  const visiting = new Set<string>();
+
+  const visit = (project: ProjectTargets, target: string): void => {
+    const key = `${project.project}:${target}`;
+    if (added.has(key)) {
+      return;
+    }
+    if (visiting.has(key)) {
+      throw new Error(`Nx target dependency cycle detected at ${key}.`);
+    }
+    visiting.add(key);
+    for (const dependency of project.targetDependencies?.get(target) ?? []) {
+      if (dependency.startsWith('^')) {
+        continue;
+      }
+      const dependencyTargets = isGlobPattern(dependency)
+        ? project.targets.filter((candidate) => new Bun.Glob(dependency).match(candidate))
+        : project.targets.includes(dependency)
+          ? [dependency]
+          : [];
+      for (const dependencyTarget of dependencyTargets.sort((left, right) => left.localeCompare(right))) {
+        visit(project, dependencyTarget);
+      }
+    }
+    visiting.delete(key);
+    added.add(key);
+    if ((project.targetOutputs?.get(target)?.length ?? 0) > 0) {
+      expanded.push({ target, projects: [project] });
+    }
+  };
+
+  for (const run of runs) {
+    for (const project of run.projects) {
+      visit(project, run.target);
+    }
+  }
+  return expanded;
+}
+
+export function nxRunManyArgs(run: NxTargetRun, configuration?: string): string[] {
+  if (run.projects.length === 0) {
+    throw new Error(`Nx target ${run.target} has no selected projects.`);
+  }
+  const nxArgs = [
+    'run-many',
+    '-t',
+    run.target,
+    `--projects=${run.projects.map((project) => project.project).join(',')}`,
+  ];
+  if (configuration) {
+    nxArgs.push(`--configuration=${configuration}`);
+  }
+  nxArgs.push('--parallel=5');
+  return nxArgs;
+}
+
+export async function readGitHeadSha(root: string): Promise<string> {
+  // invariant throw: GitHub CI commands require a valid repository root.
+  return decode((await $`git rev-parse HEAD`.cwd(root).quiet()).stdout).trim();
+}
+
+export async function githubCiNxRunMany(root: string, options: NxRunManyOptions): Promise<void> {
+  const expanded = expandNxTargetRuns(await readProjectTargets(root), options);
+  if (expanded.unmatchedGlobs.length > 0) {
+    console.log(`No Nx targets matched target glob(s): ${expanded.unmatchedGlobs.join(', ')}; skipping.`);
+  }
+  for (const targetRun of expanded.runs) {
+    await run('nx', nxRunManyArgs(targetRun, options.configuration), root);
+  }
+  if (options.collectOutputs) {
+    const { collectNxOutputs } = await loadOutputBoundary();
+    const sourceSha = await readGitHeadSha(root);
+    await collectNxOutputs(root, options.collectOutputs, expandNxTargetDependencyRuns(expanded.runs), sourceSha);
+  }
+}
+
+export async function githubCiApplyOutputs(
   root: string,
-  options: { targets: string; projects?: string; configuration?: string },
+  directories: string[],
+  expectedSourceSha: string,
 ): Promise<void> {
-  const nxArgs = ['run-many', '-t', options.targets, '--parallel=5'];
-  if (options.projects) {
-    nxArgs.push(`--projects=${options.projects}`);
+  const { applyCollectedOutputs } = await loadOutputBoundary();
+  await applyCollectedOutputs(root, directories, expectedSourceSha);
+}
+
+async function loadOutputBoundary() {
+  if (import.meta.url.endsWith('/src/github-ci/index.ts')) {
+    // The source self-hosting shim has no Typia transform; register it before loading manifest validators.
+    await import('@smoothbricks/validation/bun/preload');
   }
-  if (options.configuration) {
-    nxArgs.push(`--configuration=${options.configuration}`);
+  // This boundary must stay lazy because the transformed dist and source self-hosting paths initialize Typia differently.
+  return import('./outputs.js');
+}
+
+function isGlobPattern(value: string): boolean {
+  return /[*?{[]/.test(value);
+}
+
+function selectProjects(projects: ProjectTargets[], selectors: string | undefined): ProjectTargets[] {
+  if (selectors === undefined) {
+    return projects.slice().sort((left, right) => left.project.localeCompare(right.project));
   }
-  await run('nx', nxArgs, root);
+  const patterns = commaSeparatedValues(selectors);
+  return projects
+    .filter((project) => patterns.some((pattern) => new Bun.Glob(pattern).match(project.project)))
+    .sort((left, right) => left.project.localeCompare(right.project));
+}
+
+function commaSeparatedValues(value: string): string[] {
+  return value
+    .split(',')
+    .map((entry) => entry.trim())
+    .filter(Boolean);
 }
 
 export async function githubCiNxDeploy(
@@ -220,9 +379,11 @@ function nxProjectList(output: string): string[] {
 }
 
 function recordValue(value: unknown): Record<string, unknown> | undefined {
-  return value !== null && typeof value === 'object' && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : undefined;
+  return isRecord(value) ? value : undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
 async function createGithubStatus(name: string, step: string): Promise<void> {