release-it 0.0.0-pl.0

package/lib/plugin/gitlab/GitLab.js

@@ -0,0 +1,277 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import got from 'got';
+import { globby } from 'globby';
+import { FormData, fileFromSync } from 'node-fetch';
+import allSettled from 'promise.allsettled';
+import _ from 'lodash';
+import Release from '../GitRelease.js';
+import { format, e } from '../../util.js';
+import prompts from './prompts.js';
+
+const docs = 'https://git.io/release-it-gitlab';
+
+const noop = Promise.resolve();
+
+class GitLab extends Release {
+  constructor(...args) {
+    super(...args);
+    this.registerPrompts(prompts);
+    this.assets = [];
+    const { certificateAuthorityFile } = this.options;
+    this.certificateAuthorityOption = certificateAuthorityFile
+      ? { https: { certificateAuthority: fs.readFileSync(certificateAuthorityFile) } }
+      : {};
+  }
+
+  get client() {
+    if (this._client) return this._client;
+    const { tokenHeader } = this.options;
+    const { baseUrl } = this.getContext();
+    this._client = got.extend({
+      prefixUrl: baseUrl,
+      method: 'POST',
+      headers: {
+        'user-agent': 'webpro/release-it',
+        [tokenHeader]: this.token
+      },
+      ...this.certificateAuthorityOption
+    });
+    return this._client;
+  }
+
+  async init() {
+    await super.init();
+
+    const { skipChecks, tokenRef, tokenHeader } = this.options;
+    const { repo } = this.getContext();
+    const hasJobToken = (tokenHeader || '').toLowerCase() === 'job-token';
+    const origin = this.options.origin || `https://${repo.host}`;
+    this.setContext({
+      id: encodeURIComponent(repo.repository),
+      origin,
+      baseUrl: `${origin}/api/v4`
+    });
+
+    if (skipChecks) return;
+
+    if (!this.token) {
+      throw e(`Environment variable "${tokenRef}" is required for GitLab releases.`, docs);
+    }
+
+    if (!hasJobToken) {
+      if (!(await this.isAuthenticated())) {
+        throw e(`Could not authenticate with GitLab using environment variable "${tokenRef}".`, docs);
+      }
+      if (!(await this.isCollaborator())) {
+        const { user, repo } = this.getContext();
+        throw e(`User ${user.username} is not a collaborator for ${repo.repository}.`, docs);
+      }
+    }
+  }
+
+  async isAuthenticated() {
+    if (this.config.isDryRun) return true;
+    const endpoint = `user`;
+    try {
+      const { id, username } = await this.request(endpoint, { method: 'GET' });
+      this.setContext({ user: { id, username } });
+      return true;
+    } catch (err) {
+      this.debug(err);
+      return false;
+    }
+  }
+
+  async isCollaborator() {
+    if (this.config.isDryRun) return true;
+    const { id, user } = this.getContext();
+    const endpoint = `projects/${id}/members/all/${user.id}`;
+    try {
+      const { access_level } = await this.request(endpoint, { method: 'GET' });
+      return access_level && access_level >= 30;
+    } catch (err) {
+      this.debug(err);
+      return false;
+    }
+  }
+
+  async beforeRelease() {
+    await super.beforeRelease();
+    await this.checkReleaseMilestones();
+  }
+
+  async checkReleaseMilestones() {
+    if (this.options.skipChecks) return;
+
+    const releaseMilestones = this.getReleaseMilestones();
+    if (releaseMilestones.length < 1) {
+      return;
+    }
+
+    this.log.exec(`gitlab releases#checkReleaseMilestones`);
+
+    const { id } = this.getContext();
+    const endpoint = `projects/${id}/milestones`;
+    const requests = releaseMilestones.map(milestone => {
+      const options = {
+        method: 'GET',
+        searchParams: {
+          title: milestone,
+          include_parent_milestones: true
+        }
+      };
+      return this.request(endpoint, options).then(response => {
+        if (!Array.isArray(response)) {
+          const { baseUrl } = this.getContext();
+          throw new Error(
+            `Unexpected response from ${baseUrl}/${endpoint}. Expected an array but got: ${JSON.stringify(response)}`
+          );
+        }
+        if (response.length === 0) {
+          const error = new Error(`Milestone '${milestone}' does not exist.`);
+          this.log.warn(error.message);
+          throw error;
+        }
+        this.log.verbose(`gitlab releases#checkReleaseMilestones: milestone '${milestone}' exists`);
+      });
+    });
+    try {
+      await allSettled(requests).then(results => {
+        for (const result of results) {
+          if (result.status === 'rejected') {
+            throw e('Missing one or more milestones in GitLab. Creating a GitLab release will fail.', docs);
+          }
+        }
+      });
+    } catch (err) {
+      this.debug(err);
+      throw err;
+    }
+    this.log.verbose('gitlab releases#checkReleaseMilestones: done');
+  }
+
+  getReleaseMilestones() {
+    const { milestones } = this.options;
+    return (milestones || []).map(milestone => format(milestone, this.config.getContext()));
+  }
+
+  async release() {
+    const glRelease = () => this.createRelease();
+    const glUploadAssets = () => this.uploadAssets();
+
+    if (this.config.isCI) {
+      await this.step({ enabled: this.options.assets, task: glUploadAssets, label: 'GitLab upload assets' });
+      return await this.step({ task: glRelease, label: 'GitLab release' });
+    } else {
+      const release = () => glUploadAssets().then(() => glRelease());
+      return await this.step({ task: release, label: 'GitLab release', prompt: 'release' });
+    }
+  }
+
+  async request(endpoint, options) {
+    const { baseUrl } = this.getContext();
+    this.debug(Object.assign({ url: `${baseUrl}/${endpoint}` }, options));
+    const method = (options.method || 'POST').toLowerCase();
+    const response = await this.client[method](endpoint, options);
+    const body = typeof response.body === 'string' ? JSON.parse(response.body) : response.body || {};
+    this.debug(body);
+    return body;
+  }
+
+  async createRelease() {
+    const { releaseName } = this.options;
+    const { tagName } = this.config.getContext();
+    const { id, releaseNotes, repo, origin } = this.getContext();
+    const { isDryRun } = this.config;
+    const name = format(releaseName, this.config.getContext());
+    const description = releaseNotes || '-';
+    const releaseUrl = `${origin}/${repo.repository}/-/releases`;
+    const releaseMilestones = this.getReleaseMilestones();
+
+    this.log.exec(`gitlab releases#createRelease "${name}" (${tagName})`, { isDryRun });
+
+    if (isDryRun) {
+      this.setContext({ isReleased: true, releaseUrl });
+      return true;
+    }
+
+    const endpoint = `projects/${id}/releases`;
+    const options = {
+      json: {
+        name,
+        tag_name: tagName,
+        description
+      }
+    };
+
+    if (this.assets.length) {
+      options.json.assets = {
+        links: this.assets
+      };
+    }
+
+    if (releaseMilestones.length) {
+      options.json.milestones = releaseMilestones;
+    }
+
+    try {
+      await this.request(endpoint, options);
+      this.log.verbose('gitlab releases#createRelease: done');
+      this.setContext({ isReleased: true, releaseUrl });
+      this.config.setContext({ isReleased: true, releaseUrl });
+      return true;
+    } catch (err) {
+      this.debug(err);
+      throw err;
+    }
+  }
+
+  async uploadAsset(filePath) {
+    const name = path.basename(filePath);
+    const { id, origin, repo } = this.getContext();
+    const endpoint = `projects/${id}/uploads`;
+
+    const body = new FormData();
+    body.set('file', fileFromSync(filePath));
+    const options = { body };
+
+    try {
+      const body = await this.request(endpoint, options);
+      this.log.verbose(`gitlab releases#uploadAsset: done (${body.url})`);
+      this.assets.push({
+        name,
+        url: `${origin}/${repo.repository}${body.url}`
+      });
+    } catch (err) {
+      this.debug(err);
+      throw err;
+    }
+  }
+
+  uploadAssets() {
+    const { assets } = this.options;
+    const { isDryRun } = this.config;
+    const context = this.config.getContext();
+
+    const patterns = _.castArray(assets).map(pattern => format(pattern, context));
+
+    this.log.exec('gitlab releases#uploadAssets', patterns, { isDryRun });
+
+    if (!assets) {
+      return noop;
+    }
+
+    return globby(patterns).then(files => {
+      if (!files.length) {
+        this.log.warn(`gitlab releases#uploadAssets: could not find "${assets}" relative to ${process.cwd()}`);
+      }
+
+      if (isDryRun) return Promise.resolve();
+
+      return Promise.all(files.map(filePath => this.uploadAsset(filePath)));
+    });
+  }
+}
+
+export default GitLab;

package/lib/plugin/gitlab/prompts.js

@@ -0,0 +1,9 @@
+import { format } from '../../util.js';
+
+export default {
+  release: {
+    type: 'confirm',
+    message: context => `Create a release on GitLab (${format(context.gitlab.releaseName, context)})?`,
+    default: true
+  }
+};

package/lib/plugin/npm/npm.js

@@ -0,0 +1,281 @@
+import path from 'node:path';
+import semver from 'semver';
+import urlJoin from 'url-join';
+import Plugin from '../Plugin.js';
+import { hasAccess, rejectAfter, parseVersion, readJSON, e } from '../../util.js';
+import prompts from './prompts.js';
+
+const docs = 'https://git.io/release-it-npm';
+
+const options = { write: false };
+
+const MANIFEST_PATH = './package.json';
+const DEFAULT_TAG = 'latest';
+const DEFAULT_TAG_PRERELEASE = 'next';
+const NPM_BASE_URL = 'https://www.npmjs.com';
+const NPM_PUBLIC_PATH = '/package';
+
+const fixArgs = args => (args ? (typeof args === 'string' ? args.split(' ') : args) : []);
+
+class npm extends Plugin {
+  static isEnabled(options) {
+    return hasAccess(MANIFEST_PATH) && options !== false;
+  }
+
+  constructor(...args) {
+    super(...args);
+    this.registerPrompts(prompts);
+  }
+
+  async init() {
+    const { name, version: latestVersion, private: isPrivate, publishConfig } = readJSON(path.resolve(MANIFEST_PATH));
+    this.setContext({ name, latestVersion, private: isPrivate, publishConfig });
+    this.config.setContext({ npm: { name } });
+
+    const { publish, skipChecks } = this.options;
+
+    const timeout = Number(this.options.timeout) * 1000;
+
+    if (publish === false || isPrivate) return;
+
+    if (skipChecks) return;
+
+    const validations = Promise.all([this.isRegistryUp(), this.isAuthenticated(), this.getLatestRegistryVersion()]);
+
+    await Promise.race([validations, rejectAfter(timeout, e(`Timed out after ${timeout}ms.`, docs))]);
+
+    const [isRegistryUp, isAuthenticated, latestVersionInRegistry] = await validations;
+
+    if (!isRegistryUp) {
+      throw e(`Unable to reach npm registry (timed out after ${timeout}ms).`, docs);
+    }
+
+    if (!isAuthenticated) {
+      throw e('Not authenticated with npm. Please `npm login` and try again.', docs);
+    }
+
+    if (!(await this.isCollaborator())) {
+      const { username } = this.getContext();
+      throw e(`User ${username} is not a collaborator for ${name}.`, docs);
+    }
+
+    if (!latestVersionInRegistry) {
+      this.log.warn('No version found in npm registry. Assuming new package.');
+    } else {
+      if (!semver.eq(latestVersion, latestVersionInRegistry)) {
+        this.log.warn(
+          `Latest version in registry (${latestVersionInRegistry}) does not match package.json (${latestVersion}).`
+        );
+      }
+    }
+  }
+
+  getName() {
+    return this.getContext('name');
+  }
+
+  getLatestVersion() {
+    return this.options.ignoreVersion ? null : this.getContext('latestVersion');
+  }
+
+  async bump(version) {
+    const tag = this.options.tag || (await this.resolveTag(version));
+    this.setContext({ version, tag });
+
+    if (!this.config.isIncrement) return false;
+
+    const { versionArgs, allowSameVersion } = this.options;
+    const args = [version, '--no-git-tag-version', allowSameVersion && '--allow-same-version', ...fixArgs(versionArgs)];
+    const task = () => this.exec(`npm version ${args.filter(Boolean).join(' ')}`);
+    return this.spinner.show({ task, label: 'npm version' });
+  }
+
+  release() {
+    if (this.options.publish === false) return false;
+    if (this.getContext('private')) return false;
+    const publish = () => this.publish({ otpCallback });
+    const otpCallback =
+      this.config.isCI && !this.config.isPromptOnlyVersion ? null : task => this.step({ prompt: 'otp', task });
+    return this.step({ task: publish, label: 'npm publish', prompt: 'publish' });
+  }
+
+  isRegistryUp() {
+    const registry = this.getRegistry();
+    const registryArg = registry ? ` --registry ${registry}` : '';
+    return this.exec(`npm ping${registryArg}`, { options }).then(
+      () => true,
+      err => {
+        if (/code E40[04]|404.*(ping not found|No content for path)/.test(err)) {
+          this.log.warn('Ignoring response from unsupported `npm ping` command.');
+          return true;
+        }
+        return false;
+      }
+    );
+  }
+
+  isAuthenticated() {
+    const registry = this.getRegistry();
+    const registryArg = registry ? ` --registry ${registry}` : '';
+    return this.exec(`npm whoami${registryArg}`, { options }).then(
+      output => {
+        const username = output ? output.trim() : null;
+        this.setContext({ username });
+        return true;
+      },
+      err => {
+        this.debug(err);
+        if (/code E40[04]/.test(err)) {
+          this.log.warn('Ignoring response from unsupported `npm whoami` command.');
+          return true;
+        }
+        return false;
+      }
+    );
+  }
+
+  async isCollaborator() {
+    const registry = this.getRegistry();
+    const registryArg = registry ? ` --registry ${registry}` : '';
+    const name = this.getName();
+    const { username } = this.getContext();
+    if (username === undefined) return true;
+    if (username === null) return false;
+
+    try {
+      let npmVersion = await this.exec('npm --version', { options });
+
+      let accessCommand;
+      if (semver.gt(npmVersion, '9.0.0')) {
+        accessCommand = 'npm access list collaborators --json';
+      } else {
+        accessCommand = 'npm access ls-collaborators';
+      }
+
+      const output = await this.exec(`${accessCommand} ${name}${registryArg}`, { options });
+
+      try {
+        const collaborators = JSON.parse(output);
+        const permissions = collaborators[username];
+        return permissions && permissions.includes('write');
+      } catch (err) {
+        this.debug(err);
+        return false;
+      }
+    } catch (err) {
+      this.debug(err);
+      if (/code E400/.test(err)) {
+        this.log.warn('Ignoring response from unsupported `npm access` command.');
+      } else {
+        this.log.warn(`Unable to verify if user ${username} is a collaborator for ${name}.`);
+      }
+      return true;
+    }
+  }
+
+  async getLatestRegistryVersion() {
+    const registry = this.getRegistry();
+    const registryArg = registry ? ` --registry ${registry}` : '';
+    const name = this.getName();
+    const latestVersion = this.getLatestVersion();
+    const tag = await this.resolveTag(latestVersion);
+    return this.exec(`npm show ${name}@${tag} version${registryArg}`, { options }).catch(() => null);
+  }
+
+  getRegistryPreReleaseTags() {
+    return this.exec(`npm view ${this.getName()} dist-tags --json`, { options }).then(
+      output => {
+        try {
+          const tags = JSON.parse(output);
+          return Object.keys(tags).filter(tag => tag !== DEFAULT_TAG);
+        } catch (err) {
+          this.debug(err);
+          return [];
+        }
+      },
+      () => []
+    );
+  }
+
+  getPackageUrl() {
+    const baseUrl = this.getRegistry() || NPM_BASE_URL;
+    const publicPath = this.getPublicPath() || NPM_PUBLIC_PATH;
+    return urlJoin(baseUrl, publicPath, this.getName());
+  }
+
+  getRegistry() {
+    const { publishConfig } = this.getContext();
+    const registries = publishConfig
+      ? publishConfig.registry
+        ? [publishConfig.registry]
+        : Object.keys(publishConfig)
+            .filter(key => key.endsWith('registry'))
+            .map(key => publishConfig[key])
+      : [];
+    return registries[0];
+  }
+
+  getPublicPath() {
+    const { publishConfig } = this.getContext();
+    return (publishConfig && publishConfig.publicPath) ?? '';
+  }
+
+  async guessPreReleaseTag() {
+    const [tag] = await this.getRegistryPreReleaseTags();
+    if (tag) {
+      return tag;
+    } else {
+      this.log.warn(`Unable to get pre-release tag(s) from npm registry. Using "${DEFAULT_TAG_PRERELEASE}".`);
+      return DEFAULT_TAG_PRERELEASE;
+    }
+  }
+
+  async resolveTag(version) {
+    const { tag } = this.options;
+    const { isPreRelease, preReleaseId } = parseVersion(version);
+    if (!isPreRelease) {
+      return DEFAULT_TAG;
+    } else {
+      return tag || preReleaseId || (await this.guessPreReleaseTag());
+    }
+  }
+
+  async publish({ otp = this.options.otp, otpCallback } = {}) {
+    const { publishPath = '.', publishArgs } = this.options;
+    const { private: isPrivate, tag = DEFAULT_TAG } = this.getContext();
+    const otpArg = otp ? `--otp ${otp}` : '';
+    const dryRunArg = this.config.isDryRun ? '--dry-run' : '';
+    const registry = this.getRegistry();
+    const registryArg = registry ? `--registry ${registry}` : '';
+    if (isPrivate) {
+      this.log.warn('Skip publish: package is private.');
+      return false;
+    }
+    const args = [publishPath, `--tag ${tag}`, otpArg, dryRunArg, registryArg, ...fixArgs(publishArgs)].filter(Boolean);
+    return this.exec(`npm publish ${args.join(' ')}`, { options })
+      .then(() => {
+        this.setContext({ isReleased: true });
+      })
+      .catch(err => {
+        this.debug(err);
+        if (/one-time pass/.test(err)) {
+          if (otp != null) {
+            this.log.warn('The provided OTP is incorrect or has expired.');
+          }
+          if (otpCallback) {
+            return otpCallback(otp => this.publish({ otp, otpCallback }));
+          }
+        }
+        throw err;
+      });
+  }
+
+  afterRelease() {
+    const { isReleased } = this.getContext();
+    if (isReleased) {
+      this.log.log(`🔗 ${this.getPackageUrl()}`);
+    }
+  }
+}
+
+export default npm;

package/lib/plugin/npm/prompts.js

@@ -0,0 +1,12 @@
+export default {
+  publish: {
+    type: 'confirm',
+    message: context =>
+      `Publish ${context.npm.name}${context.npm.tag === 'latest' ? '' : `@${context.npm.tag}`} to npm?`,
+    default: true
+  },
+  otp: {
+    type: 'input',
+    message: () => `Please enter OTP for npm:`
+  }
+};

package/lib/plugin/version/Version.js

@@ -0,0 +1,129 @@
+import semver from 'semver';
+import chalk from 'chalk';
+import Plugin from '../Plugin.js';
+
+const { green, red, redBright } = chalk;
+
+const RELEASE_TYPES = ['patch', 'minor', 'major'];
+const PRERELEASE_TYPES = ['prepatch', 'preminor', 'premajor'];
+const CONTINUATION_TYPES = ['prerelease', 'pre'];
+const ALL_RELEASE_TYPES = [...RELEASE_TYPES, ...PRERELEASE_TYPES, ...CONTINUATION_TYPES];
+
+const CHOICES = {
+  latestIsPreRelease: [...RELEASE_TYPES, CONTINUATION_TYPES[0]],
+  preRelease: PRERELEASE_TYPES,
+  default: [...RELEASE_TYPES, ...PRERELEASE_TYPES]
+};
+
+const getIncrementChoices = context => {
+  const { latestIsPreRelease, isPreRelease, preReleaseId } = context.version;
+  const types = latestIsPreRelease ? CHOICES.latestIsPreRelease : isPreRelease ? CHOICES.preRelease : CHOICES.default;
+  const choices = types.map(increment => ({
+    name: `${increment} (${semver.inc(context.latestVersion, increment, preReleaseId)})`,
+    value: increment
+  }));
+  const otherChoice = {
+    name: 'Other, please specify...',
+    value: null
+  };
+  return [...choices, otherChoice];
+};
+
+const versionTransformer = context => input =>
+  semver.valid(input) ? (semver.gt(input, context.latestVersion) ? green(input) : red(input)) : redBright(input);
+
+const prompts = {
+  incrementList: {
+    type: 'list',
+    message: () => 'Select increment (next version):',
+    choices: context => getIncrementChoices(context),
+    pageSize: 9
+  },
+  version: {
+    type: 'input',
+    message: () => `Please enter a valid version:`,
+    transformer: context => versionTransformer(context),
+    validate: input => !!semver.valid(input) || 'The version must follow the semver standard.'
+  }
+};
+
+class Version extends Plugin {
+  constructor(...args) {
+    super(...args);
+    this.registerPrompts(prompts);
+  }
+
+  getIncrement(options) {
+    return options.increment;
+  }
+
+  getIncrementedVersionCI(options) {
+    return this.incrementVersion(options);
+  }
+
+  async getIncrementedVersion(options) {
+    const { isCI } = this.config;
+    const version = this.incrementVersion(options);
+    return version || (isCI ? null : await this.promptIncrementVersion(options));
+  }
+
+  promptIncrementVersion(options) {
+    return new Promise(resolve => {
+      this.step({
+        prompt: 'incrementList',
+        task: increment =>
+          increment
+            ? resolve(this.incrementVersion(Object.assign({}, options, { increment })))
+            : this.step({ prompt: 'version', task: resolve })
+      });
+    });
+  }
+
+  isPreRelease(version) {
+    return Boolean(semver.prerelease(version));
+  }
+
+  isValid(version) {
+    return Boolean(semver.valid(version));
+  }
+
+  incrementVersion({ latestVersion, increment, isPreRelease, preReleaseId }) {
+    if (increment === false) return latestVersion;
+
+    const latestIsPreRelease = this.isPreRelease(latestVersion);
+    const isValidVersion = this.isValid(increment);
+
+    if (latestVersion) {
+      this.setContext({ latestIsPreRelease });
+    }
+
+    if (isValidVersion && semver.gte(increment, latestVersion)) {
+      return increment;
+    }
+
+    if (isPreRelease && !increment && latestIsPreRelease) {
+      return semver.inc(latestVersion, 'prerelease', preReleaseId);
+    }
+
+    if (this.config.isCI && !increment) {
+      if (isPreRelease) {
+        return semver.inc(latestVersion, 'prepatch', preReleaseId);
+      } else {
+        return semver.inc(latestVersion, 'patch');
+      }
+    }
+
+    const normalizedType = RELEASE_TYPES.includes(increment) && isPreRelease ? `pre${increment}` : increment;
+    if (ALL_RELEASE_TYPES.includes(normalizedType)) {
+      return semver.inc(latestVersion, normalizedType, preReleaseId);
+    }
+
+    const coercedVersion = !isValidVersion && semver.coerce(increment);
+    if (coercedVersion) {
+      this.log.warn(`Coerced invalid semver version "${increment}" into "${coercedVersion}".`);
+      return coercedVersion.toString();
+    }
+  }
+}
+
+export default Version;