@smoothbricks/cli 0.1.1 → 0.3.0

package/src/release/candidates.ts

@@ -0,0 +1,225 @@
+import { isRecord } from '../lib/json.js';
+import type { ReleasePackageInfo } from './core.js';
+import { releaseTag } from './core.js';
+
+export interface AutoReleaseCandidateShell {
+  gitRefExists(ref: string): Promise<boolean>;
+  packageChangedFilesSince(ref: string, packagePath: string): Promise<string[]>;
+  packageJsonAtRef(ref: string, packagePath: string): Promise<Record<string, unknown> | null>;
+  currentPackageJson(packagePath: string): Promise<Record<string, unknown> | null>;
+  packageBuildInputPatterns(projectName: string, packagePath: string): Promise<string[]>;
+  packageHasHistory(packagePath: string): Promise<boolean>;
+}
+
+const releasableManifestKeys = [
+  'author',
+  'bin',
+  'browser',
+  'bugs',
+  'cpu',
+  'dependencies',
+  'description',
+  'engines',
+  'exports',
+  'files',
+  'funding',
+  'homepage',
+  'imports',
+  'keywords',
+  'license',
+  'main',
+  'module',
+  'name',
+  'optionalDependencies',
+  'os',
+  'peerDependencies',
+  'peerDependenciesMeta',
+  'publishConfig',
+  'repository',
+  'sideEffects',
+  'types',
+  'typesVersions',
+] as const;
+
+export async function autoReleaseCandidatePackages<Package extends ReleasePackageInfo>(
+  shell: AutoReleaseCandidateShell,
+  packages: Package[],
+): Promise<Package[]> {
+  const candidates: Package[] = [];
+  for (const pkg of packages) {
+    if (await isAutoReleaseCandidate(shell, pkg)) {
+      candidates.push(pkg);
+    }
+  }
+  return candidates;
+}
+
+async function isAutoReleaseCandidate<Package extends ReleasePackageInfo>(
+  shell: AutoReleaseCandidateShell,
+  pkg: Package,
+): Promise<boolean> {
+  const tagRef = `refs/tags/${releaseTag(pkg)}`;
+  if (await shell.gitRefExists(tagRef)) {
+    return packageHasReleasableChangesSince(shell, tagRef, pkg);
+  }
+  return !pkg.version.includes('-') && shell.packageHasHistory(pkg.path);
+}
+
+async function packageHasReleasableChangesSince<Package extends ReleasePackageInfo>(
+  shell: AutoReleaseCandidateShell,
+  ref: string,
+  pkg: Package,
+): Promise<boolean> {
+  const changedFiles = await shell.packageChangedFilesSince(ref, pkg.path);
+  if (changedFiles.length === 0) {
+    return false;
+  }
+  const currentManifest = await shell.currentPackageJson(pkg.path);
+  const buildInputPatterns = await shell.packageBuildInputPatterns(pkg.projectName, pkg.path);
+  for (const changedFile of changedFiles) {
+    if (changedFile === 'package.json') {
+      const previousManifest = await shell.packageJsonAtRef(ref, pkg.path);
+      if (!previousManifest || !currentManifest || releasableManifestChanged(previousManifest, currentManifest)) {
+        return true;
+      }
+      continue;
+    }
+    if (isReleasablePackagePath(changedFile, currentManifest, buildInputPatterns)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function releasableManifestChanged(
+  previousManifest: Record<string, unknown>,
+  currentManifest: Record<string, unknown>,
+): boolean {
+  for (const key of releasableManifestKeys) {
+    if (!stableJsonEqual(previousManifest[key], currentManifest[key])) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function isReleasablePackagePath(
+  path: string,
+  manifest: Record<string, unknown> | null,
+  buildInputPatterns: string[],
+): boolean {
+  return (
+    isBuildInputPath(path, buildInputPatterns) || isPackageMetadataPath(path) || isManifestFilesPath(path, manifest)
+  );
+}
+
+function isBuildInputPath(path: string, patterns: string[]): boolean {
+  if (isReleaseIgnoredBuildInputPath(path)) {
+    return false;
+  }
+  let matched = false;
+  for (const pattern of patterns) {
+    const excluded = pattern.startsWith('!');
+    const rawPattern = excluded ? pattern.slice(1) : pattern;
+    if (matchesBuildInputPattern(path, rawPattern)) {
+      matched = !excluded;
+    }
+  }
+  return matched;
+}
+
+function matchesBuildInputPattern(path: string, pattern: string): boolean {
+  const normalized = pattern.replace(/^\.\//, '').replace(/\/$/, '');
+  if (!normalized) {
+    return false;
+  }
+  return globPatternToRegExp(normalized).test(path);
+}
+
+function globPatternToRegExp(pattern: string): RegExp {
+  let source = '^';
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index];
+    if (char === '*') {
+      if (pattern[index + 1] === '*') {
+        if (pattern[index + 2] === '/') {
+          source += '(?:.*/)?';
+          index += 2;
+        } else {
+          source += '.*';
+          index += 1;
+        }
+      } else {
+        source += '[^/]*';
+      }
+    } else {
+      source += escapeRegExpChar(char);
+    }
+  }
+  return new RegExp(`${source}$`);
+}
+
+function escapeRegExpChar(char: string | undefined): string {
+  if (!char) {
+    return '';
+  }
+  return /[\\^$+?.()|[\]{}]/.test(char) ? `\\${char}` : char;
+}
+
+function isReleaseIgnoredBuildInputPath(path: string): boolean {
+  return (
+    path === 'package.json' ||
+    path === 'tsconfig.test.json' ||
+    path.includes('/__tests__/') ||
+    path.endsWith('.test.ts') ||
+    path.endsWith('.test.tsx') ||
+    path.endsWith('.spec.ts') ||
+    path.endsWith('.spec.tsx')
+  );
+}
+
+function isPackageMetadataPath(path: string): boolean {
+  return /^(README|LICENSE|CHANGELOG)(\.|$)/.test(path);
+}
+
+function isManifestFilesPath(path: string, manifest: Record<string, unknown> | null): boolean {
+  const files = manifest?.files;
+  if (!Array.isArray(files)) {
+    return false;
+  }
+  for (const entry of files) {
+    if (typeof entry !== 'string' || entry.length === 0 || entry.startsWith('!')) {
+      continue;
+    }
+    if (matchesManifestFilesEntry(path, entry)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function matchesManifestFilesEntry(path: string, entry: string): boolean {
+  const normalized = entry.replace(/^\.\//, '').replace(/\/$/, '');
+  if (!normalized || normalized.includes('*')) {
+    return false;
+  }
+  return path === normalized || path.startsWith(`${normalized}/`);
+}
+
+function stableJsonEqual(left: unknown, right: unknown): boolean {
+  return JSON.stringify(stableJson(left)) === JSON.stringify(stableJson(right));
+}
+
+function stableJson(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map(stableJson);
+  }
+  if (isRecord(value)) {
+    const normalized: Record<string, unknown> = {};
+    for (const key of Object.keys(value).sort()) {
+      normalized[key] = stableJson(value[key]);
+    }
+    return normalized;
+  }
+  return value;
+}

package/src/release/core.ts

@@ -1,5 +1,6 @@
 export interface ReleasePackageInfo {
   name: string;
+  projectName: string;
   path: string;
   version: string;
 }
@@ -43,10 +44,18 @@ export interface ReleasePlanningShell {
   durableTagState(pkg: ReleasePackageInfo, tag: string): Promise<DurableTagState>;
 }
 
-export function releaseTag(pkg: Pick<ReleasePackageInfo, 'name' | 'version'>): string {
+export function releaseTag(pkg: Pick<ReleasePackageInfo, 'projectName' | 'version'>): string {
+  return `${pkg.projectName}@${pkg.version}`;
+}
+
+export function legacyReleaseTag(pkg: Pick<ReleasePackageInfo, 'name' | 'version'>): string {
   return `${pkg.name}@${pkg.version}`;
 }
 
+export function releaseTagAliases(pkg: Pick<ReleasePackageInfo, 'name' | 'projectName' | 'version'>): string[] {
+  return [...new Set([releaseTag(pkg), legacyReleaseTag(pkg)])];
+}
+
 export function npmDistTagForVersion(version: string): string {
   return version.includes('-') ? 'next' : 'latest';
 }
@@ -56,7 +65,7 @@ export function releasePackageForTag<Package extends Omit<ReleasePackageInfo, 'v
   tag: string,
 ): { pkg: Package; version: string } | null {
   for (const pkg of packages) {
-    const prefix = `${pkg.name}@`;
+    const prefix = `${pkg.projectName}@`;
     if (tag.startsWith(prefix)) {
       const version = tag.slice(prefix.length);
       if (!version) {
@@ -84,13 +93,14 @@ export async function collectOwnedReleaseTagRecords<Package extends Omit<Release
   ref: string,
   shell: ReleasePlanningShell,
 ): Promise<Array<ReleaseTagRecord<Package & { version: string }>>> {
-  const records: Array<ReleaseTagRecord<Package & { version: string }>> = [];
-  const completedPackages = new Set<string>();
+  const candidates: Array<{
+    tag: GitReleaseTagInfo;
+    pkg: Package & { version: string };
+  }> = [];
+  const durableStates = new BoundedPromiseRunner(8);
+
   for (const tag of await shell.listReleaseTagsByCreatorDate()) {
     const match = releasePackageForTag(packages, tag.name);
-    if (match && completedPackages.has(match.pkg.name)) {
-      continue;
-    }
     if (!match || !(await shell.isAncestor(tag.sha, ref))) {
       continue;
     }
@@ -103,15 +113,91 @@ export async function collectOwnedReleaseTagRecords<Package extends Omit<Release
       );
     }
     const pkg = { ...match.pkg, version: match.version };
-    const state = await shell.durableTagState(pkg, tag.name);
-    records.push(classifyReleaseTag({ tag: tag.name, sha: tag.sha, timestamp: tag.timestamp, pkg }, state));
+    candidates.push({ tag, pkg });
+  }
+
+  const records: Array<ReleaseTagRecord<Package & { version: string }>> = [];
+  const completedPackages = new Set<string>();
+  const activePackages = new Set<string>();
+  const states = new Map<number, Promise<DurableTagState>>();
+
+  // Run durable-state checks concurrently across packages, but do not query an
+  // older tag for the same package until its newer tag proves incomplete.
+  const scheduleFrom = (startIndex: number) => {
+    for (let index = startIndex; index < candidates.length; index += 1) {
+      if (states.size >= 8) {
+        return;
+      }
+      const candidate = candidates[index];
+      if (!candidate || states.has(index) || completedPackages.has(candidate.pkg.name)) {
+        continue;
+      }
+      if (activePackages.has(candidate.pkg.name)) {
+        continue;
+      }
+      activePackages.add(candidate.pkg.name);
+      states.set(
+        index,
+        durableStates.run(() => shell.durableTagState(candidate.pkg, candidate.tag.name)),
+      );
+    }
+  };
+
+  for (const candidate of candidates) {
+    const index = candidates.indexOf(candidate);
+    scheduleFrom(index);
+    if (completedPackages.has(candidate.pkg.name)) {
+      continue;
+    }
+    const state = await states.get(index);
+    if (!state) {
+      throw new Error(`Release tag ${candidate.tag.name} lost durable state planning.`);
+    }
+    activePackages.delete(candidate.pkg.name);
+    states.delete(index);
+    records.push(
+      classifyReleaseTag(
+        { tag: candidate.tag.name, sha: candidate.tag.sha, timestamp: candidate.tag.timestamp, pkg: candidate.pkg },
+        state,
+      ),
+    );
     if (state.npmPublished && state.githubReleaseExists) {
-      completedPackages.add(pkg.name);
+      completedPackages.add(candidate.pkg.name);
     }
   }
   return records;
 }
 
+class BoundedPromiseRunner {
+  private active = 0;
+  private readonly waiting: Array<() => void> = [];
+
+  constructor(private readonly limit: number) {}
+
+  async run<T>(operation: () => Promise<T>): Promise<T> {
+    await this.acquire();
+    try {
+      return await operation();
+    } finally {
+      this.release();
+    }
+  }
+
+  private async acquire(): Promise<void> {
+    if (this.active < this.limit) {
+      this.active += 1;
+      return;
+    }
+    await new Promise<void>((resolve) => this.waiting.push(resolve));
+    this.active += 1;
+  }
+
+  private release(): void {
+    this.active -= 1;
+    this.waiting.shift()?.();
+  }
+}
+
 export function groupReleaseTargets<Package extends ReleasePackageInfo>(
   records: ReleaseTagRecord<Package>[],
 ): ReleaseTarget<Package>[] {

package/src/release/github-release.ts

@@ -39,7 +39,7 @@ export async function renderNxProjectChangelogContents(input: RenderNxProjectCha
       nxRenderOnlyReleaseConfig,
       false,
     )(nxProjectChangelogArgs(input.pkg, input.previousTag, input.dryRun));
-    return projectChangelogContents(result, input.pkg.name);
+    return projectChangelogContents(result, input.pkg.projectName);
   });
 }
 
@@ -65,7 +65,7 @@ export async function createOrUpdateGithubRelease(
 export function nxProjectChangelogArgs(pkg: ReleasePackageInfo, previousTag: string | null, dryRun: boolean) {
   const base = {
     version: pkg.version,
-    projects: [pkg.name],
+    projects: [pkg.projectName],
     gitCommit: false,
     gitTag: false,
     gitPush: false,
@@ -112,7 +112,7 @@ function isPrereleaseVersion(version: string): boolean {
   return version.includes('-');
 }
 
-async function withNxWorkspaceRoot<T>(root: string, run: () => Promise<T>): Promise<T> {
+export async function withNxWorkspaceRoot<T>(root: string, run: () => Promise<T>): Promise<T> {
   const workspaceRootModule = await import('nx/src/utils/workspace-root.js');
   const previousWorkspaceRoot = workspaceRootModule.workspaceRoot;
   const previousEnvWorkspaceRoot = process.env.NX_WORKSPACE_ROOT_PATH;