release-it 0.0.0-pl.0

package/lib/plugin/git/Git.js

@@ -0,0 +1,220 @@
+import { EOL } from 'node:os';
+import _ from 'lodash';
+import { execa } from 'execa';
+import matcher from 'wildcard-match';
+import { format, e } from '../../util.js';
+import GitBase from '../GitBase.js';
+import prompts from './prompts.js';
+
+const noop = Promise.resolve();
+const invalidPushRepoRe = /^\S+@/;
+const options = { write: false };
+const fixArgs = args => (args ? (typeof args === 'string' ? args.split(' ') : args) : []);
+
+const docs = 'https://git.io/release-it-git';
+
+const isGitRepo = () =>
+  execa('git', ['rev-parse', '--git-dir']).then(
+    () => true,
+    () => false
+  );
+
+class Git extends GitBase {
+  constructor(...args) {
+    super(...args);
+    this.registerPrompts(prompts);
+  }
+
+  static async isEnabled(options) {
+    return options !== false && (await isGitRepo());
+  }
+
+  async init() {
+    if (this.options.requireBranch && !(await this.isRequiredBranch(this.options.requireBranch))) {
+      throw e(`Must be on branch ${this.options.requireBranch}`, docs);
+    }
+    if (this.options.requireCleanWorkingDir && !(await this.isWorkingDirClean())) {
+      throw e(`Working dir must be clean.${EOL}Please stage and commit your changes.`, docs);
+    }
+
+    await super.init();
+
+    const remoteUrl = this.getContext('remoteUrl');
+    if (this.options.push && !remoteUrl) {
+      throw e(`Could not get remote Git url.${EOL}Please add a remote repository.`, docs);
+    }
+    if (this.options.requireUpstream && !(await this.hasUpstreamBranch())) {
+      throw e(`No upstream configured for current branch.${EOL}Please set an upstream branch.`, docs);
+    }
+    if (this.options.requireCommits && (await this.getCommitsSinceLatestTag(this.options.commitsPath)) === 0) {
+      throw e(`There are no commits since the latest tag.`, docs, this.options.requireCommitsFail);
+    }
+  }
+
+  rollback() {
+    this.log.info('Rolling back changes...');
+    const { tagName } = this.config.getContext();
+    const { isCommitted, isTagged } = this.getContext();
+    if (isTagged) {
+      this.exec(`git tag --delete ${tagName}`);
+    }
+    this.exec(`git reset --hard HEAD${isCommitted ? '~1' : ''}`);
+  }
+
+  enableRollback() {
+    this.rollbackOnce = _.once(this.rollback.bind(this));
+    process.on('SIGINT', this.rollbackOnce);
+    process.on('exit', this.rollbackOnce);
+  }
+
+  disableRollback() {
+    if (this.rollbackOnce) {
+      process.removeListener('SIGINT', this.rollbackOnce);
+      process.removeListener('exit', this.rollbackOnce);
+    }
+  }
+
+  async beforeRelease() {
+    if (this.options.commit) {
+      if (this.options.requireCleanWorkingDir) {
+        this.enableRollback();
+      }
+      const changeSet = await this.status();
+      this.log.preview({ title: 'changeset', text: changeSet });
+      await this.stageDir();
+    }
+  }
+
+  async release() {
+    const { commit, tag, push } = this.options;
+    await this.step({ enabled: commit, task: () => this.commit(), label: 'Git commit', prompt: 'commit' });
+    await this.step({ enabled: tag, task: () => this.tag(), label: 'Git tag', prompt: 'tag' });
+    return !!(await this.step({ enabled: push, task: () => this.push(), label: 'Git push', prompt: 'push' }));
+  }
+
+  async isRequiredBranch() {
+    const branch = await this.getBranchName();
+    const requiredBranches = _.castArray(this.options.requireBranch);
+    const [branches, negated] = requiredBranches.reduce(
+      ([p, n], b) => (b.startsWith('!') ? [p, [...n, b.slice(1)]] : [[...p, b], n]),
+      [[], []]
+    );
+    return (
+      (branches.length > 0 ? matcher(branches)(branch) : true) &&
+      (negated.length > 0 ? !matcher(negated)(branch) : true)
+    );
+  }
+
+  async hasUpstreamBranch() {
+    const ref = await this.exec('git symbolic-ref HEAD', { options });
+    const branch = await this.exec(`git for-each-ref --format="%(upstream:short)" ${ref}`, { options }).catch(
+      () => null
+    );
+    return Boolean(branch);
+  }
+
+  tagExists(tag) {
+    return this.exec(`git show-ref --tags --quiet --verify -- refs/tags/${tag}`, { options }).then(
+      () => true,
+      () => false
+    );
+  }
+
+  isWorkingDirClean() {
+    return this.exec('git diff --quiet HEAD', { options }).then(
+      () => true,
+      () => false
+    );
+  }
+
+  async getCommitsSinceLatestTag(commitsPath = '') {
+    const latestTagName = await this.getLatestTagName();
+    const ref = latestTagName ? `${latestTagName}..HEAD` : 'HEAD';
+    return this.exec(`git rev-list ${ref} --count ${commitsPath}`, { options }).then(Number);
+  }
+
+  async getUpstreamArgs(pushRepo) {
+    if (pushRepo && !this.isRemoteName(pushRepo)) {
+      // Use (only) `pushRepo` if it's configured and looks like a url
+      return [pushRepo];
+    } else if (!(await this.hasUpstreamBranch())) {
+      // Start tracking upstream branch (`pushRepo` is a name if set)
+      return ['--set-upstream', pushRepo || 'origin', await this.getBranchName()];
+    } else if (pushRepo && !invalidPushRepoRe.test(pushRepo)) {
+      return [pushRepo];
+    } else {
+      return [];
+    }
+  }
+
+  stage(file) {
+    if (!file || !file.length) return noop;
+    const files = _.castArray(file);
+    return this.exec(['git', 'add', ...files]).catch(err => {
+      this.log.warn(`Could not stage ${files}`);
+      this.debug(err);
+    });
+  }
+
+  stageDir({ baseDir = '.' } = {}) {
+    const { addUntrackedFiles } = this.options;
+    return this.exec(['git', 'add', baseDir, addUntrackedFiles ? '--all' : '--update']);
+  }
+
+  reset(file) {
+    const files = _.castArray(file);
+    return this.exec(['git', 'checkout', 'HEAD', '--', ...files]).catch(err => {
+      this.log.warn(`Could not reset ${files}`);
+      this.debug(err);
+    });
+  }
+
+  status() {
+    return this.exec('git status --short --untracked-files=no', { options }).catch(() => null);
+  }
+
+  commit({ message = this.options.commitMessage, args = this.options.commitArgs } = {}) {
+    const msg = format(message, this.config.getContext());
+    const commitMessageArgs = msg ? ['--message', msg] : [];
+    return this.exec(['git', 'commit', ...commitMessageArgs, ...fixArgs(args)]).then(
+      () => this.setContext({ isCommitted: true }),
+      err => {
+        this.debug(err);
+        if (/nothing (added )?to commit/.test(err) || /nichts zu committen/.test(err)) {
+          this.log.warn('No changes to commit. The latest commit will be tagged.');
+        } else {
+          throw new Error(err);
+        }
+      }
+    );
+  }
+
+  tag({ name, annotation = this.options.tagAnnotation, args = this.options.tagArgs } = {}) {
+    const message = format(annotation, this.config.getContext());
+    const tagName = name || this.config.getContext('tagName');
+    return this.exec(['git', 'tag', '--annotate', '--message', message, ...fixArgs(args), tagName])
+      .then(() => this.setContext({ isTagged: true }))
+      .catch(err => {
+        const { latestTag, tagName } = this.config.getContext();
+        if (/tag '.+' already exists/.test(err) && latestTag === tagName) {
+          this.log.warn(`Tag "${tagName}" already exists`);
+        } else {
+          throw err;
+        }
+      });
+  }
+
+  async push({ args = this.options.pushArgs } = {}) {
+    const { pushRepo } = this.options;
+    const upstreamArgs = await this.getUpstreamArgs(pushRepo);
+    const push = await this.exec(['git', 'push', ...fixArgs(args), ...upstreamArgs]);
+    this.disableRollback();
+    return push;
+  }
+
+  afterRelease() {
+    this.disableRollback();
+  }
+}
+
+export default Git;

package/lib/plugin/git/prompts.js

@@ -0,0 +1,19 @@
+import { format, truncateLines } from '../../util.js';
+
+export default {
+  commit: {
+    type: 'confirm',
+    message: context => `Commit (${truncateLines(format(context.git.commitMessage, context), 1, ' [...]')})?`,
+    default: true
+  },
+  tag: {
+    type: 'confirm',
+    message: context => `Tag (${format(context.tagName, context)})?`,
+    default: true
+  },
+  push: {
+    type: 'confirm',
+    message: () => 'Push?',
+    default: true
+  }
+};

package/lib/plugin/github/GitHub.js

@@ -0,0 +1,403 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import open from 'open';
+import { Octokit } from '@octokit/rest';
+import fetch from 'node-fetch';
+import { globby } from 'globby';
+import mime from 'mime-types';
+import _ from 'lodash';
+import retry from 'async-retry';
+import newGithubReleaseUrl from 'new-github-release-url';
+import { ProxyAgent } from 'proxy-agent';
+import { format, parseVersion, readJSON, e } from '../../util.js';
+import Release from '../GitRelease.js';
+import prompts from './prompts.js';
+import { getCommitsFromChangelog, getResolvedIssuesFromChangelog, searchQueries } from './util.js';
+
+const pkg = readJSON(new URL('../../../package.json', import.meta.url));
+
+const docs = 'https://git.io/release-it-github';
+
+const RETRY_CODES = [408, 413, 429, 500, 502, 503, 504, 521, 522, 524];
+
+const DEFAULT_RETRY_MIN_TIMEOUT = 1000;
+
+const parseErrormsg = err => {
+  let msg = err;
+  if (err instanceof Error) {
+    const { status, message } = err;
+    const headers = err.response ? err.response.headers : {};
+    msg = `${_.get(headers, 'status', status)} (${message})`;
+  }
+  return msg;
+};
+
+const truncateBody = body => {
+  // https://github.com/release-it/release-it/issues/965
+  if (body && body.length >= 124000) return body.substring(0, 124000) + '...';
+  return body;
+};
+
+class GitHub extends Release {
+  constructor(...args) {
+    super(...args);
+    this.registerPrompts(prompts);
+  }
+
+  async init() {
+    await super.init();
+
+    const { skipChecks, tokenRef, web, update, assets } = this.options;
+
+    if (!this.token || web) {
+      if (!web) {
+        this.log.warn(`Environment variable "${tokenRef}" is required for automated GitHub Releases.`);
+        this.log.warn('Falling back to web-based GitHub Release.');
+      }
+      this.setContext({ isWeb: true });
+      return;
+    }
+
+    if (web && assets) {
+      this.log.warn('Assets are not included in web-based releases.');
+    }
+
+    if (!skipChecks) {
+      // If we're running on GitHub Actions, we can skip the authentication and
+      // collaborator checks. Ref: https://bit.ly/2vsyRzu
+      if (process.env.GITHUB_ACTIONS) {
+        this.setContext({ username: process.env.GITHUB_ACTOR });
+      } else {
+        if (!(await this.isAuthenticated())) {
+          throw e(`Could not authenticate with GitHub using environment variable "${tokenRef}".`, docs);
+        }
+
+        if (!(await this.isCollaborator())) {
+          const { repository } = this.getContext('repo');
+          const { username } = this.getContext();
+          throw e(`User ${username} is not a collaborator for ${repository}.`, docs);
+        }
+      }
+    }
+
+    if (update) {
+      const { latestTag } = this.config.getContext();
+      try {
+        const { id, upload_url, tag_name } = await this.getLatestRelease();
+        if (latestTag === tag_name) {
+          this.setContext({ isUpdate: true, isReleased: true, releaseId: id, upload_url });
+        } else {
+          this.setContext({ isUpdate: false });
+        }
+      } catch (error) {
+        this.setContext({ isUpdate: false });
+      }
+      if (!this.getContext('isUpdate')) {
+        this.log.warn(`GitHub release for tag ${latestTag} was not found. Creating new release.`);
+      }
+    }
+  }
+
+  async isAuthenticated() {
+    if (this.config.isDryRun) return true;
+    try {
+      this.log.verbose('octokit users#getAuthenticated');
+      const { data } = await this.client.users.getAuthenticated();
+      this.setContext({ username: data.login });
+      return true;
+    } catch (error) {
+      this.debug(error);
+      return false;
+    }
+  }
+
+  async isCollaborator() {
+    if (this.config.isDryRun) return true;
+    const { owner, project: repo } = this.getContext('repo');
+    const { username } = this.getContext();
+    try {
+      const options = { owner, repo, username };
+      this.log.verbose(`octokit repos#checkCollaborator (${username})`);
+      await this.client.repos.checkCollaborator(options);
+      return true;
+    } catch (error) {
+      this.debug(error);
+      return false;
+    }
+  }
+
+  async release() {
+    const { assets } = this.options;
+    const { isWeb, isUpdate } = this.getContext();
+    const { isCI } = this.config;
+
+    const type = isUpdate ? 'update' : 'create';
+    const publishMethod = `${type}Release`;
+
+    if (isWeb) {
+      const task = () => this.createWebRelease();
+      return this.step({ task, label: 'Generating link to GitHub Release web interface', prompt: 'release' });
+    } else if (isCI) {
+      await this.step({ task: () => this[publishMethod](), label: `GitHub ${type} release` });
+      return this.step({ enabled: assets, task: () => this.uploadAssets(), label: 'GitHub upload assets' });
+    } else {
+      const release = async () => {
+        await this[publishMethod]();
+        await this.uploadAssets();
+        return isUpdate ? Promise.resolve() : this.commentOnResolvedItems();
+      };
+      return this.step({ task: release, label: `GitHub ${type} release`, prompt: 'release' });
+    }
+  }
+
+  handleError(err, bail) {
+    const message = parseErrormsg(err);
+    const githubError = new Error(message);
+    this.log.verbose(err.errors);
+    this.debug(err);
+    if (!_.includes(RETRY_CODES, err.status)) {
+      return bail(githubError);
+    }
+    throw githubError;
+  }
+
+  get client() {
+    if (this._client) return this._client;
+    const { proxy, timeout } = this.options;
+    const host = this.options.host || this.getContext('repo.host');
+    const isGitHub = host === 'github.com';
+    const baseUrl = `https://${isGitHub ? 'api.github.com' : host}${isGitHub ? '' : '/api/v3'}`;
+    const options = {
+      baseUrl,
+      auth: `token ${this.token}`,
+      userAgent: `release-it/${pkg.version}`,
+      log: this.config.isDebug ? console : null,
+      request: {
+        timeout,
+        fetch
+      }
+    };
+
+    if (proxy) {
+      options.request.agent = new ProxyAgent(proxy);
+    }
+
+    const client = new Octokit(options);
+
+    this._client = client;
+    return client;
+  }
+
+  async getLatestRelease() {
+    const { owner, project: repo } = this.getContext('repo');
+    try {
+      const options = { owner, repo };
+      this.debug(options);
+      const response = await this.client.repos.listReleases({ owner, repo, per_page: 1, page: 1 });
+      this.debug(response.data[0]);
+      return response.data[0];
+    } catch (err) {
+      return this.handleError(err, () => {});
+    }
+  }
+
+  getOctokitReleaseOptions(options = {}) {
+    const { owner, project: repo } = this.getContext('repo');
+    const { releaseName, draft = false, preRelease = false, autoGenerate = false } = this.options;
+    const { tagName } = this.config.getContext();
+    const { version, releaseNotes, isUpdate } = this.getContext();
+    const { isPreRelease } = parseVersion(version);
+    const name = format(releaseName, this.config.getContext());
+    const body = autoGenerate ? (isUpdate ? null : '') : truncateBody(releaseNotes);
+
+    return Object.assign(options, {
+      owner,
+      repo,
+      tag_name: tagName,
+      name,
+      body,
+      draft,
+      prerelease: isPreRelease || preRelease,
+      generate_release_notes: autoGenerate
+    });
+  }
+
+  retry(fn) {
+    const { retryMinTimeout } = this.options;
+    return retry(fn, {
+      retries: 2,
+      minTimeout: typeof retryMinTimeout === 'number' ? retryMinTimeout : DEFAULT_RETRY_MIN_TIMEOUT
+    });
+  }
+
+  async createRelease() {
+    const options = this.getOctokitReleaseOptions();
+    const { isDryRun } = this.config;
+
+    this.log.exec(`octokit repos.createRelease "${options.name}" (${options.tag_name})`, { isDryRun });
+
+    if (isDryRun) {
+      this.setContext({ isReleased: true, releaseUrl: this.getReleaseUrlFallback(options.tag_name) });
+      return true;
+    }
+
+    return this.retry(async bail => {
+      try {
+        this.debug(options);
+        const response = await this.client.repos.createRelease(options);
+        this.debug(response.data);
+        const { html_url, upload_url, id } = response.data;
+        this.setContext({ isReleased: true, releaseId: id, releaseUrl: html_url, upload_url });
+        this.config.setContext({ isReleased: true, releaseId: id, releaseUrl: html_url, upload_url });
+        this.log.verbose(`octokit repos.createRelease: done (${response.headers.location})`);
+        return response.data;
+      } catch (err) {
+        return this.handleError(err, bail);
+      }
+    });
+  }
+
+  uploadAsset(filePath) {
+    const url = this.getContext('upload_url');
+    const name = path.basename(filePath);
+    const contentType = mime.contentType(name) || 'application/octet-stream';
+    const contentLength = fs.statSync(filePath).size;
+
+    return this.retry(async bail => {
+      try {
+        const options = {
+          url,
+          data: fs.createReadStream(filePath),
+          name,
+          headers: {
+            'content-type': contentType,
+            'content-length': contentLength
+          }
+        };
+        this.debug(options);
+        const response = await this.client.repos.uploadReleaseAsset(options);
+        this.debug(response.data);
+        this.log.verbose(`octokit repos.uploadReleaseAsset: done (${response.data.browser_download_url})`);
+        return response.data;
+      } catch (err) {
+        return this.handleError(err, bail);
+      }
+    });
+  }
+
+  uploadAssets() {
+    const { assets } = this.options;
+    const { isReleased } = this.getContext();
+    const context = this.config.getContext();
+    const { isDryRun } = this.config;
+
+    const patterns = _.castArray(assets).map(pattern => format(pattern, context));
+
+    this.log.exec('octokit repos.uploadReleaseAssets', patterns, { isDryRun });
+
+    if (!assets || !isReleased) {
+      return true;
+    }
+
+    return globby(patterns).then(files => {
+      if (!files.length) {
+        this.log.warn(`octokit repos.uploadReleaseAssets: did not find "${assets}" relative to ${process.cwd()}`);
+      }
+
+      if (isDryRun) return Promise.resolve();
+
+      return Promise.all(files.map(filePath => this.uploadAsset(filePath)));
+    });
+  }
+
+  getReleaseUrlFallback(tagName) {
+    const { host, repository } = this.getContext('repo');
+    return `https://${host}/${repository}/releases/tag/${tagName}`;
+  }
+
+  generateWebUrl() {
+    const host = this.options.host || this.getContext('repo.host');
+    const isGitHub = host === 'github.com';
+
+    const options = this.getOctokitReleaseOptions();
+    const url = newGithubReleaseUrl({
+      user: options.owner,
+      repo: options.repo,
+      tag: options.tag_name,
+      isPrerelease: options.prerelease,
+      title: options.name,
+      body: options.body
+    });
+    return isGitHub ? url : url.replace('github.com', host);
+  }
+
+  async createWebRelease() {
+    const { isCI } = this.config;
+    const { tagName } = this.config.getContext();
+    const url = this.generateWebUrl();
+    if (isCI) {
+      this.setContext({ isReleased: true, releaseUrl: url });
+    } else {
+      const isWindows = process.platform === 'win32';
+      if (isWindows) this.log.info(`Opening ${url}`);
+      await open(url, { wait: isWindows });
+      this.setContext({ isReleased: true, releaseUrl: this.getReleaseUrlFallback(tagName) });
+    }
+  }
+
+  updateRelease() {
+    const { isDryRun } = this.config;
+    const release_id = this.getContext('releaseId');
+    const options = this.getOctokitReleaseOptions({ release_id });
+
+    this.log.exec(`octokit repos.updateRelease (${options.tag_name})`, { isDryRun });
+
+    if (isDryRun) return true;
+
+    return this.retry(async bail => {
+      try {
+        this.debug(options);
+        const response = await this.client.repos.updateRelease(options);
+        this.setContext({ releaseUrl: response.data.html_url });
+        this.debug(response.data);
+        this.log.verbose(`octokit repos.updateRelease: done (${response.headers.location})`);
+        return true;
+      } catch (err) {
+        return this.handleError(err, bail);
+      }
+    });
+  }
+
+  async commentOnResolvedItems() {
+    const { isDryRun } = this.config;
+    const { owner, project: repo } = this.getContext('repo');
+    const { changelog } = this.config.getContext();
+    const { comments } = this.options;
+    const { submit, issue, pr } = comments;
+    const context = this.getContext();
+
+    if (!submit || !changelog || isDryRun) return;
+
+    const shas = getCommitsFromChangelog(changelog);
+    const searchResults = await Promise.all(searchQueries(this.client, owner, repo, shas));
+    const mergedPullRequests = searchResults.flatMap(items => items.map(item => ({ type: 'pr', number: item.number })));
+
+    const host = 'https://' + (this.options.host || this.getContext('repo.host'));
+    const resolvedIssues = getResolvedIssuesFromChangelog(host, owner, repo, changelog);
+
+    for (const item of [...resolvedIssues, ...mergedPullRequests]) {
+      const { type, number } = item;
+      const comment = format(format(type === 'pr' ? pr : issue, context), context);
+      const url = `${host}/${owner}/${repo}/${type === 'pr' ? 'pull' : 'issues'}/${number}`;
+
+      try {
+        await this.client.issues.createComment({ owner, repo, issue_number: number, body: comment });
+        this.log.log(`● Commented on ${url}`);
+      } catch (error) {
+        this.log.log(`✕ Failed to comment on ${url}`);
+      }
+    }
+  }
+}
+
+export default GitHub;

package/lib/plugin/github/prompts.js

@@ -0,0 +1,16 @@
+import { format } from '../../util.js';
+
+const message = context => {
+  const { isPreRelease, github } = context;
+  const { releaseName, update } = github;
+  const name = format(releaseName, context);
+  return `${update ? 'Update' : 'Create a'} ${isPreRelease ? 'pre-' : ''}release on GitHub (${name})?`;
+};
+
+export default {
+  release: {
+    type: 'confirm',
+    message,
+    default: true
+  }
+};

package/lib/plugin/github/util.js

@@ -0,0 +1,39 @@
+// Totally much borrowed from https://github.com/semantic-release/github/blob/master/lib/success.js
+import issueParser from 'issue-parser';
+
+const getSearchQueries = (base, commits, separator = '+') => {
+  return commits.reduce((searches, commit) => {
+    const lastSearch = searches[searches.length - 1];
+    if (lastSearch && lastSearch.length + commit.length <= 256 - separator.length) {
+      searches[searches.length - 1] = `${lastSearch}${separator}${commit}`;
+    } else {
+      searches.push(`${base}${separator}${commit}`);
+    }
+
+    return searches;
+  }, []);
+};
+
+export const searchQueries = (client, owner, repo, shas) =>
+  getSearchQueries(`repo:${owner}/${repo}+type:pr+is:merged`, shas).map(
+    async q => (await client.search.issuesAndPullRequests({ q })).data.items
+  );
+
+export const getCommitsFromChangelog = changelog => {
+  const regex = /\(([a-f0-9]{7,})\)/i;
+  return changelog.split('\n').flatMap(message => {
+    const match = message.match(regex);
+    if (match) return match[1];
+    return [];
+  });
+};
+
+export const getResolvedIssuesFromChangelog = (host, owner, repo, changelog) => {
+  const parser = issueParser('github', { hosts: [host] });
+  return changelog
+    .split('\n')
+    .map(parser)
+    .flatMap(parsed => parsed.actions.close)
+    .filter(action => !action.slug || action.slug === `${owner}/${repo}`)
+    .map(action => ({ type: 'issue', number: parseInt(action.issue, 10) }));
+};