@smoothbricks/cli 0.10.2 → 0.10.4

package/src/github-ci/index.ts

@@ -1,8 +1,29 @@
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { appendFile, mkdtemp, realpath, rename, rm } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { $ } from 'bun';
+import typia from 'typia';
+import { parseStringArrayText } from '../lib/json.js';
 import { decode, run, runStatus } from '../lib/run.js';
+import { type ProjectTargets, readProjectTargets } from '../nx/index.js';
+import type { NxTargetRun } from './outputs.js';
+
+interface GithubActionsEventPayload {
+  repository?: {
+    default_branch?: string;
+  };
+}
+
+interface NxProjectDeployConfigurations {
+  targets?: {
+    deploy?: {
+      configurations?: Record<string, unknown>;
+    };
+  };
+}
+
+const parseGithubActionsEvent = typia.json.createIsParse<GithubActionsEventPayload>();
+const parseNxProjectDeployConfigurations = typia.json.createIsParse<NxProjectDeployConfigurations>();
 
 type NxSmartMode = 'auto' | 'affected' | 'run-many';
 
@@ -113,6 +134,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 +151,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 +159,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/cli/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(
@@ -182,7 +360,31 @@ function resolveNxSmartMode(mode: NxSmartMode): 'affected' | 'run-many' {
   if (mode === 'affected' || mode === 'run-many') {
     return mode;
   }
-  return process.env.GITHUB_EVENT_NAME === 'push' && process.env.GITHUB_REF_NAME === 'main' ? 'run-many' : 'affected';
+  const defaultBranch = eventDefaultBranch() ?? 'main';
+  if (process.env.GITHUB_EVENT_NAME === 'push') {
+    return process.env.GITHUB_REF_NAME === defaultBranch ? 'run-many' : 'affected';
+  }
+  // A PR into a NON-default branch is an integration surface (e.g. a mirror-sync
+  // review branch): its base moves outside the default-branch workflow that
+  // affected scoping is calibrated against, so under-selection can pass PR CI
+  // and only fail after merge. Validate those PRs in full.
+  if (process.env.GITHUB_EVENT_NAME === 'pull_request') {
+    const base = process.env.GITHUB_BASE_REF;
+    return base && base !== defaultBranch ? 'run-many' : 'affected';
+  }
+  return 'affected';
+}
+
+/** The repository default branch from the Actions event payload. */
+function eventDefaultBranch(): string | undefined {
+  const eventPath = process.env.GITHUB_EVENT_PATH;
+  if (!eventPath) return undefined;
+  try {
+    const payload = parseGithubActionsEvent(readFileSync(eventPath, 'utf8'));
+    return payload?.repository?.default_branch || undefined;
+  } catch {
+    return undefined;
+  }
 }
 
 async function deployProjectsWithConfiguration(
@@ -207,24 +409,12 @@ async function deployProjectsWithConfiguration(
 
 async function deployTargetHasConfiguration(root: string, project: string, configuration: string): Promise<boolean> {
   const result = await $`nx show project ${project} --json`.cwd(root).quiet();
-  const parsed: unknown = JSON.parse(decode(result.stdout));
-  const targets = recordValue(parsed)?.targets;
-  const deploy = recordValue(targets)?.deploy;
-  const configurations = recordValue(deploy)?.configurations;
-  return recordValue(configurations)?.[configuration] !== undefined;
+  const parsed = parseNxProjectDeployConfigurations(decode(result.stdout));
+  return parsed?.targets?.deploy?.configurations?.[configuration] !== undefined;
 }
 
 function nxProjectList(output: string): string[] {
-  const parsed: unknown = JSON.parse(output);
-  return Array.isArray(parsed) ? parsed.filter((project): project is string => typeof project === 'string') : [];
-}
-
-function recordValue(value: unknown): 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);
+  return parseStringArrayText(output) ?? [];
 }
 
 async function createGithubStatus(name: string, step: string): Promise<void> {