@smoothbricks/cli 0.1.0 → 0.1.1

package/src/release/__tests__/retag-unpublished.test.ts

@@ -0,0 +1,160 @@
+import { describe, expect, it } from 'bun:test';
+import type { ReleasePackageInfo } from '../core.js';
+import {
+  type RetagUnpublishedOptions,
+  type RetagUnpublishedShell,
+  type RetagUnpublishedTagUpdate,
+  retagUnpublished,
+} from '../retag-unpublished.js';
+
+const pkg: ReleasePackageInfo = { name: '@scope/pkg', path: 'packages/pkg', version: '1.2.3' };
+
+describe('retag unpublished releases', () => {
+  it('moves unpublished owned tags, pushes with a remote lease, and dispatches publish auto', async () => {
+    const shell = new RecordingRetagShell({
+      versionAtRef: '1.2.3',
+      remoteTagObjects: new Map([['@scope/pkg@1.2.3', 'old-tag-object']]),
+      dispatchSha: 'target-sha',
+    });
+
+    const updates = await retagUnpublished(shell, retagOptions({ push: true, dispatch: true }));
+
+    expect(updates).toEqual([{ tag: '@scope/pkg@1.2.3', pkg, expectedRemoteObject: 'old-tag-object' }]);
+    expect(shell.movedTags).toEqual([{ tag: '@scope/pkg@1.2.3', ref: 'HEAD' }]);
+    expect(shell.pushed).toEqual([[{ tag: '@scope/pkg@1.2.3', expectedRemoteObject: 'old-tag-object' }]]);
+    expect(shell.dispatched).toEqual([{ workflow: 'publish.yml', branch: 'main' }]);
+    expect(shell.dispatchRefLookups).toEqual(['main']);
+    expect(shell.remoteTagLookups).toEqual(['@scope/pkg@1.2.3']);
+  });
+
+  it('rejects tags whose package version already exists on npm', async () => {
+    const shell = new RecordingRetagShell({ versionAtRef: '1.2.3', npmPublished: true });
+
+    await expect(retagUnpublished(shell, retagOptions())).rejects.toThrow(
+      'Cannot retag @scope/pkg@1.2.3: @scope/pkg@1.2.3 already exists on npm.',
+    );
+
+    expect(shell.movedTags).toEqual([]);
+    expect(shell.pushed).toEqual([]);
+  });
+
+  it('rejects tags whose version does not match the target ref package manifest', async () => {
+    const shell = new RecordingRetagShell({ versionAtRef: '1.2.4' });
+
+    await expect(retagUnpublished(shell, retagOptions())).rejects.toThrow(
+      'Release tag @scope/pkg@1.2.3 cannot move to HEAD: packages/pkg/package.json has version 1.2.4, expected 1.2.3.',
+    );
+  });
+
+  it('rejects workflow dispatch when the target ref is not the remote branch head', async () => {
+    const shell = new RecordingRetagShell({ versionAtRef: '1.2.3', dispatchSha: 'other-sha' });
+
+    await expect(retagUnpublished(shell, retagOptions({ push: true, dispatch: true }))).rejects.toThrow(
+      'Cannot dispatch publish.yml: HEAD resolves to target-sha, but main resolves to other-sha.',
+    );
+
+    expect(shell.movedTags).toEqual([]);
+    expect(shell.pushed).toEqual([]);
+    expect(shell.dispatched).toEqual([]);
+  });
+
+  it('dry-runs without moving, pushing, or dispatching tags', async () => {
+    const shell = new RecordingRetagShell({ versionAtRef: '1.2.3', dispatchSha: 'target-sha' });
+
+    await retagUnpublished(shell, retagOptions({ push: true, dispatch: true, dryRun: true }));
+
+    expect(shell.movedTags).toEqual([]);
+    expect(shell.pushed).toEqual([]);
+    expect(shell.dispatched).toEqual([]);
+    expect(shell.logs).toContain('Would move @scope/pkg@1.2.3 to HEAD (target-sha).');
+    expect(shell.logs).toContain('Would push 1 retagged release tag.');
+    expect(shell.logs).toContain('Would dispatch publish.yml on main with bump=auto.');
+  });
+});
+
+function retagOptions(overrides: Partial<RetagUnpublishedOptions> = {}): RetagUnpublishedOptions {
+  return {
+    tags: ['@scope/pkg@1.2.3'],
+    toRef: 'HEAD',
+    push: false,
+    dispatch: false,
+    dryRun: false,
+    branch: 'main',
+    workflow: 'publish.yml',
+    ...overrides,
+  };
+}
+
+class RecordingRetagShell implements RetagUnpublishedShell<ReleasePackageInfo> {
+  readonly movedTags: Array<{ tag: string; ref: string }> = [];
+  readonly pushed: Array<Array<{ tag: string; expectedRemoteObject: string | null }>> = [];
+  readonly dispatched: Array<{ workflow: string; branch: string }> = [];
+  readonly dispatchRefLookups: string[] = [];
+  readonly remoteTagLookups: string[] = [];
+  readonly logs: string[] = [];
+  private readonly versionAtRef: string | null;
+  private readonly npmPublished: boolean;
+  private readonly githubReleaseCreated: boolean;
+  private readonly remoteTagObjects: Map<string, string>;
+  private readonly dispatchSha: string | null;
+
+  constructor(options: {
+    versionAtRef: string | null;
+    npmPublished?: boolean;
+    githubReleaseCreated?: boolean;
+    remoteTagObjects?: Map<string, string>;
+    dispatchSha?: string | null;
+  }) {
+    this.versionAtRef = options.versionAtRef;
+    this.npmPublished = options.npmPublished === true;
+    this.githubReleaseCreated = options.githubReleaseCreated === true;
+    this.remoteTagObjects = options.remoteTagObjects ?? new Map();
+    this.dispatchSha = options.dispatchSha ?? null;
+  }
+
+  listReleasePackages(): ReleasePackageInfo[] {
+    return [pkg];
+  }
+
+  async resolveRef(): Promise<string> {
+    return 'target-sha';
+  }
+
+  async resolveDispatchRef(branch: string): Promise<string | null> {
+    this.dispatchRefLookups.push(branch);
+    return this.dispatchSha;
+  }
+
+  async packageVersionAtRef(): Promise<string | null> {
+    return this.versionAtRef;
+  }
+
+  async npmVersionExists(): Promise<boolean> {
+    return this.npmPublished;
+  }
+
+  async githubReleaseExists(): Promise<boolean> {
+    return this.githubReleaseCreated;
+  }
+
+  async remoteTagObject(tag: string): Promise<string | null> {
+    this.remoteTagLookups.push(tag);
+    return this.remoteTagObjects.get(tag) ?? null;
+  }
+
+  async createOrMoveTag(tag: string, ref: string): Promise<void> {
+    this.movedTags.push({ tag, ref });
+  }
+
+  async pushTags(updates: Array<RetagUnpublishedTagUpdate<ReleasePackageInfo>>): Promise<void> {
+    this.pushed.push(updates.map((update) => ({ tag: update.tag, expectedRemoteObject: update.expectedRemoteObject })));
+  }
+
+  async dispatchPublishWorkflow(workflow: string, branch: string): Promise<void> {
+    this.dispatched.push({ workflow, branch });
+  }
+
+  log(message: string): void {
+    this.logs.push(message);
+  }
+}

package/src/release/core.ts

@@ -0,0 +1,170 @@
+export interface ReleasePackageInfo {
+  name: string;
+  path: string;
+  version: string;
+}
+
+export interface GitReleaseTagInfo {
+  name: string;
+  sha: string;
+  timestamp: number;
+}
+
+export interface MatchedReleaseTag<Package extends ReleasePackageInfo = ReleasePackageInfo> {
+  tag: string;
+  sha: string;
+  timestamp: number;
+  pkg: Package;
+}
+
+export interface ReleaseTagRecord<Package extends ReleasePackageInfo = ReleasePackageInfo>
+  extends MatchedReleaseTag<Package> {
+  needsNpmPublish: boolean;
+  needsGithubRelease: boolean;
+}
+
+export interface ReleaseTarget<Package extends ReleasePackageInfo = ReleasePackageInfo> {
+  sha: string;
+  timestamp: number;
+  packages: Package[];
+  npmPackages: Package[];
+  githubPackages: Package[];
+}
+
+export interface DurableTagState {
+  npmPublished: boolean;
+  githubReleaseExists: boolean;
+}
+
+export interface ReleasePlanningShell {
+  listReleaseTagsByCreatorDate(): Promise<GitReleaseTagInfo[]>;
+  isAncestor(ancestor: string, descendant: string): Promise<boolean>;
+  packageVersionAtRef(packagePath: string, ref: string): Promise<string | null>;
+  durableTagState(pkg: ReleasePackageInfo, tag: string): Promise<DurableTagState>;
+}
+
+export function releaseTag(pkg: Pick<ReleasePackageInfo, 'name' | 'version'>): string {
+  return `${pkg.name}@${pkg.version}`;
+}
+
+export function npmDistTagForVersion(version: string): string {
+  return version.includes('-') ? 'next' : 'latest';
+}
+
+export function releasePackageForTag<Package extends Omit<ReleasePackageInfo, 'version'>>(
+  packages: Package[],
+  tag: string,
+): { pkg: Package; version: string } | null {
+  for (const pkg of packages) {
+    const prefix = `${pkg.name}@`;
+    if (tag.startsWith(prefix)) {
+      const version = tag.slice(prefix.length);
+      if (!version) {
+        throw new Error(`Release tag ${tag} does not include a version.`);
+      }
+      return { pkg, version };
+    }
+  }
+  return null;
+}
+
+export function classifyReleaseTag<Package extends ReleasePackageInfo>(
+  tag: MatchedReleaseTag<Package>,
+  state: DurableTagState,
+): ReleaseTagRecord<Package> {
+  return {
+    ...tag,
+    needsNpmPublish: !state.npmPublished,
+    needsGithubRelease: !state.githubReleaseExists,
+  };
+}
+
+export async function collectOwnedReleaseTagRecords<Package extends Omit<ReleasePackageInfo, 'version'>>(
+  packages: Package[],
+  ref: string,
+  shell: ReleasePlanningShell,
+): Promise<Array<ReleaseTagRecord<Package & { version: string }>>> {
+  const records: Array<ReleaseTagRecord<Package & { version: string }>> = [];
+  const completedPackages = new Set<string>();
+  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;
+    }
+    const versionAtTag = await shell.packageVersionAtRef(match.pkg.path, tag.sha);
+    if (versionAtTag !== match.version) {
+      throw new Error(
+        `Release tag ${tag.name} points at ${tag.sha.slice(0, 12)}, but ${match.pkg.path}/package.json has version ${
+          versionAtTag ?? 'missing'
+        }.`,
+      );
+    }
+    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));
+    if (state.npmPublished && state.githubReleaseExists) {
+      completedPackages.add(pkg.name);
+    }
+  }
+  return records;
+}
+
+export function groupReleaseTargets<Package extends ReleasePackageInfo>(
+  records: ReleaseTagRecord<Package>[],
+): ReleaseTarget<Package>[] {
+  const targets = new Map<string, ReleaseTarget<Package>>();
+  const packageNamesByTarget = new Map<string, Set<string>>();
+  for (const record of records) {
+    let target = targets.get(record.sha);
+    let packageNames = packageNamesByTarget.get(record.sha);
+    if (!target) {
+      target = { sha: record.sha, timestamp: record.timestamp, packages: [], npmPackages: [], githubPackages: [] };
+      targets.set(record.sha, target);
+      packageNames = new Set<string>();
+      packageNamesByTarget.set(record.sha, packageNames);
+    } else if (record.timestamp > target.timestamp) {
+      target.timestamp = record.timestamp;
+    }
+    if (!packageNames) {
+      throw new Error(`Release target ${record.sha.slice(0, 12)} lost package tracking state.`);
+    }
+    if (packageNames.has(record.pkg.name)) {
+      throw new Error(
+        `Release target ${record.sha.slice(0, 12)} has more than one release tag for ${record.pkg.name}.`,
+      );
+    }
+    packageNames.add(record.pkg.name);
+    if (record.needsNpmPublish || record.needsGithubRelease) {
+      target.packages.push(record.pkg);
+    }
+    if (record.needsNpmPublish) {
+      target.npmPackages.push(record.pkg);
+    }
+    if (record.needsGithubRelease) {
+      target.githubPackages.push(record.pkg);
+    }
+  }
+  return [...targets.values()].sort(
+    (left, right) => right.timestamp - left.timestamp || right.sha.localeCompare(left.sha),
+  );
+}
+
+export function pendingReleaseTargets<Package extends ReleasePackageInfo>(
+  records: ReleaseTagRecord<Package>[],
+  headSha: string,
+): ReleaseTarget<Package>[] {
+  const pending: ReleaseTarget<Package>[] = [];
+  for (const target of groupReleaseTargets(records)) {
+    if (target.sha === headSha) {
+      continue;
+    }
+    if (target.npmPackages.length === 0 && target.githubPackages.length === 0) {
+      break;
+    }
+    pending.push(target);
+  }
+  return pending.reverse();
+}

package/src/release/github-release.ts

@@ -0,0 +1,134 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { ChangelogOptions } from 'nx/src/command-line/release/command-object.js';
+import type { NxReleaseConfiguration } from 'nx/src/config/nx-json.js';
+import { type ReleasePackageInfo, releaseTag } from './core.js';
+
+const nxRenderOnlyReleaseConfig = {
+  changelog: {
+    workspaceChangelog: false,
+    projectChangelogs: {
+      createRelease: false,
+      file: false,
+    },
+  },
+} satisfies NxReleaseConfiguration;
+
+interface ProjectChangelogLookupResult {
+  projectChangelogs?: Record<string, { contents: string }>;
+}
+
+export interface RenderNxProjectChangelogInput<Package extends ReleasePackageInfo = ReleasePackageInfo> {
+  root: string;
+  pkg: Package;
+  previousTag: string | null;
+  dryRun: boolean;
+}
+
+export interface GithubReleaseWriteShell {
+  githubReleaseExists(tag: string): Promise<boolean>;
+  runGhRelease(args: string[]): Promise<void>;
+  log(message: string): void;
+}
+
+export async function renderNxProjectChangelogContents(input: RenderNxProjectChangelogInput): Promise<string> {
+  return withNxWorkspaceRoot(input.root, async () => {
+    const { createAPI } = await import('nx/src/command-line/release/changelog.js');
+    const result = await createAPI(
+      nxRenderOnlyReleaseConfig,
+      false,
+    )(nxProjectChangelogArgs(input.pkg, input.previousTag, input.dryRun));
+    return projectChangelogContents(result, input.pkg.name);
+  });
+}
+
+export async function createOrUpdateGithubRelease(
+  pkg: ReleasePackageInfo,
+  contents: string,
+  shell: GithubReleaseWriteShell,
+): Promise<void> {
+  const tag = releaseTag(pkg);
+  const releaseExists = await shell.githubReleaseExists(tag);
+  shell.log(`${pkg.name}@${pkg.version}: ${releaseExists ? 'updating' : 'creating'} GitHub Release for ${tag}.`);
+
+  const tempDir = await mkdtemp(join(tmpdir(), 'smoo-github-release-'));
+  const notesFile = join(tempDir, 'notes.md');
+  try {
+    await writeFile(notesFile, contents);
+    await shell.runGhRelease(githubReleaseCommandArgs(tag, notesFile, releaseExists, pkg.version));
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+}
+
+export function nxProjectChangelogArgs(pkg: ReleasePackageInfo, previousTag: string | null, dryRun: boolean) {
+  const base = {
+    version: pkg.version,
+    projects: [pkg.name],
+    gitCommit: false,
+    gitTag: false,
+    gitPush: false,
+    stageChanges: false,
+    createRelease: false,
+    deleteVersionPlans: false,
+    dryRun,
+  } satisfies ChangelogOptions;
+  return previousTag ? { ...base, from: previousTag } : { ...base, firstRelease: true };
+}
+
+export function projectChangelogContents(result: ProjectChangelogLookupResult, projectName: string): string {
+  const changelog = result.projectChangelogs?.[projectName];
+  if (!changelog) {
+    throw new Error(`Nx did not generate a project changelog for ${projectName}.`);
+  }
+  return changelog.contents;
+}
+
+export function githubReleaseCommandArgs(
+  tag: string,
+  notesFile: string,
+  releaseExists: boolean,
+  version: string,
+): string[] {
+  const args = [
+    'release',
+    releaseExists ? 'edit' : 'create',
+    tag,
+    '--title',
+    tag,
+    '--notes-file',
+    notesFile,
+    '--verify-tag',
+    `--latest=${isPrereleaseVersion(version) ? 'false' : 'true'}`,
+  ];
+  if (isPrereleaseVersion(version)) {
+    args.push('--prerelease');
+  }
+  return args;
+}
+
+function isPrereleaseVersion(version: string): boolean {
+  return version.includes('-');
+}
+
+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;
+  const previousCwd = process.cwd();
+  process.env.NX_WORKSPACE_ROOT_PATH = root;
+  process.chdir(root);
+  workspaceRootModule.setWorkspaceRoot(root);
+  try {
+    return await run();
+  } finally {
+    workspaceRootModule.setWorkspaceRoot(previousWorkspaceRoot);
+    if (previousEnvWorkspaceRoot === undefined) {
+      delete process.env.NX_WORKSPACE_ROOT_PATH;
+    } else {
+      process.env.NX_WORKSPACE_ROOT_PATH = previousEnvWorkspaceRoot;
+    }
+    process.chdir(previousCwd);
+  }
+}