@ckeditor/ckeditor5-dev-release-tools 37.0.1 → 38.0.0

package/lib/tasks/reassignnpmtags.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+/* eslint-env node */
+
+'use strict';
+
+const chalk = require( 'chalk' );
+const columns = require( 'cli-columns' );
+const { tools } = require( '@ckeditor/ckeditor5-dev-utils' );
+const assertNpmAuthorization = require( '../utils/assertnpmauthorization' );
+
+/**
+ * Used to switch the tags from `staging` to `latest` for specified array of packages.
+ *
+ * @param {Object} options
+ * @param {String} options.npmOwner User that is authorized to release packages.
+ * @param {String} options.version Specifies the version of packages to reassign the tags for.
+ * @param {Array.<String>} options.packages Array of packages' names to reassign tags for.
+ * @returns {Promise}
+ */
+module.exports = async function reassignNpmTags( { npmOwner, version, packages } ) {
+	const errors = [];
+	const packagesSkipped = [];
+	const packagesUpdated = [];
+
+	await assertNpmAuthorization( npmOwner );
+
+	const counter = tools.createSpinner( 'Reassigning npm tags...', { total: packages.length } );
+	counter.start();
+
+	for ( const packageName of packages ) {
+		const latestVersion = await exec( `npm show ${ packageName }@latest version` )
+			.then( version => version.trim() )
+			.catch( error => {
+				errors.push( trimErrorMessage( error.message ) );
+			} );
+
+		if ( latestVersion === version ) {
+			packagesSkipped.push( packageName );
+
+			continue;
+		}
+
+		await exec( `npm dist-tag add ${ packageName }@${ version } latest` )
+			.then( () => {
+				packagesUpdated.push( packageName );
+			} )
+			.catch( error => {
+				errors.push( trimErrorMessage( error.message ) );
+			} )
+			.finally( () => {
+				counter.increase();
+			} );
+	}
+
+	counter.finish();
+
+	if ( packagesUpdated.length ) {
+		console.log( chalk.bold.green( '✨ Tags updated:' ) );
+		console.log( columns( packagesUpdated ) );
+	}
+
+	if ( packagesSkipped.length ) {
+		console.log( chalk.bold.yellow( '⬇️ Packages skipped:' ) );
+		console.log( columns( packagesSkipped ) );
+	}
+
+	if ( errors.length ) {
+		console.log( chalk.bold.red( '🐛 Errors found:' ) );
+		errors.forEach( msg => console.log( `* ${ msg }` ) );
+	}
+};
+
+/**
+ * @param {String} message
+ * @returns {String}
+ */
+function trimErrorMessage( message ) {
+	return message.replace( /npm ERR!.*\n/g, '' ).trim();
+}
+
+/**
+ * @param {String} command
+ * @returns {Promise.<String>}
+ */
+async function exec( command ) {
+	return tools.shExec( command, { verbosity: 'silent', async: true } );
+}

package/lib/tasks/updatedependencies.js

@@ -0,0 +1,84 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const fs = require( 'fs-extra' );
+const { glob } = require( 'glob' );
+const upath = require( 'upath' );
+
+/**
+ * The purpose of this script is to update all eligible dependencies to a version specified in the `options.version`. The following packages
+ * are taken into consideration:
+ *
+ * - The root package located in `options.cwd` path.
+ * - All packages located in the `options.packagesDirectory` path relative to `options.cwd`.
+ *
+ * The eligible dependencies are distinguished by the return value from the `options.shouldUpdateVersionCallback` function. Only if this
+ * callback returns a truthy value for a given dependency, its version will be updated.
+ *
+ * @param {Object} options
+ * @param {String} options.version Target version or a range version to which all eligible dependencies will be updated.
+ * Examples: `1.0.0`, `^1.0.0`, etc.
+ * @param {Function} options.shouldUpdateVersionCallback Callback function that decides whether to update a version for a dependency.
+ * It receives a package name as an argument and should return a boolean value.
+ * @param {String} [options.packagesDirectory] Relative path to a location of packages to update their dependencies. If not specified,
+ * only the root package is checked.
+ * @param {String} [options.cwd=process.cwd()] Current working directory from which all paths will be resolved.
+ * @returns {Promise}
+ */
+module.exports = async function updateDependencies( options ) {
+	const {
+		version,
+		packagesDirectory,
+		shouldUpdateVersionCallback,
+		cwd = process.cwd()
+	} = options;
+
+	const globOptions = {
+		cwd,
+		nodir: true,
+		absolute: true
+	};
+
+	const globPatterns = [ 'package.json' ];
+
+	if ( packagesDirectory ) {
+		const packagesDirectoryPattern = upath.join( packagesDirectory, '*', 'package.json' );
+
+		globPatterns.push( packagesDirectoryPattern );
+	}
+
+	const pkgJsonPaths = await glob( globPatterns, globOptions );
+
+	for ( const pkgJsonPath of pkgJsonPaths ) {
+		const pkgJson = await fs.readJson( pkgJsonPath );
+
+		updateVersion( version, shouldUpdateVersionCallback, pkgJson.dependencies );
+		updateVersion( version, shouldUpdateVersionCallback, pkgJson.devDependencies );
+		updateVersion( version, shouldUpdateVersionCallback, pkgJson.peerDependencies );
+
+		await fs.writeJson( pkgJsonPath, pkgJson, { spaces: 2 } );
+	}
+};
+
+/**
+ * Updates the version for each eligible dependency.
+ *
+ * @param {String} version
+ * @param {Function} callback
+ * @param {Object} [dependencies]
+ */
+function updateVersion( version, callback, dependencies ) {
+	if ( !dependencies ) {
+		return;
+	}
+
+	for ( const packageName of Object.keys( dependencies ) ) {
+		if ( callback( packageName ) ) {
+			dependencies[ packageName ] = version;
+		}
+	}
+}

package/lib/tasks/updateversions.js

@@ -0,0 +1,117 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const { glob } = require( 'glob' );
+const fs = require( 'fs-extra' );
+const semver = require( 'semver' );
+const { normalizeTrim, toUnix, dirname, join } = require( 'upath' );
+const { tools } = require( '@ckeditor/ckeditor5-dev-utils' );
+
+/**
+ * The purpose of the script is to update the version of a root package found in the current working
+ * directory and packages if the `options.packagesDirectory` path is provided.
+ *
+ * Before updating phase, the specified version must meet the following conditions:
+ *
+ * * It must not be in use in the npm registry.
+ * * It must be higher than the version specified in the root package (found in the `cwd` directory).
+ *   Exception: passing a version starting with the `0.0.0-nightly` string. It is used for publishing
+ *   a nightly release.
+ *
+ * @param {Object} options
+ * @param {String} options.version Version to store in a `package.json` file under the `version` key.
+ * @param {String} [options.packagesDirectory] Relative path to a location of packages to update. If not specified,
+ * only the root package is checked.
+ * @param {String} [options.cwd=process.cwd()] Current working directory from which all paths will be resolved.
+ * @returns {Promise}
+ */
+module.exports = async function updateVersions( { packagesDirectory, version, cwd = process.cwd() } ) {
+	const normalizedCwd = toUnix( cwd );
+	const normalizedPackagesDir = packagesDirectory ? normalizeTrim( packagesDirectory ) : null;
+
+	const globPatterns = getGlobPatterns( normalizedPackagesDir );
+	const pkgJsonPaths = await glob( globPatterns, { cwd: normalizedCwd, absolute: true, nodir: true } );
+	const randomPackagePath = getRandomPackagePath( pkgJsonPaths, normalizedPackagesDir );
+
+	const rootPackageJson = join( normalizedCwd, 'package.json' );
+	const randomPackageJson = join( randomPackagePath, 'package.json' );
+
+	checkIfVersionIsValid( version, ( await fs.readJson( rootPackageJson ) ).version );
+	await checkVersionAvailability( version, ( await fs.readJson( randomPackageJson ) ).name );
+
+	for ( const pkgJsonPath of pkgJsonPaths ) {
+		const pkgJson = await fs.readJson( pkgJsonPath );
+
+		pkgJson.version = version;
+		await fs.writeJson( pkgJsonPath, pkgJson, { spaces: 2 } );
+	}
+};
+
+/**
+ * @param {String|null} packagesDirectory
+ * @returns {Array.<String>}
+ */
+function getGlobPatterns( packagesDirectory ) {
+	const patterns = [ 'package.json' ];
+
+	if ( packagesDirectory ) {
+		patterns.push( packagesDirectory + '/*/package.json' );
+	}
+
+	return patterns;
+}
+
+/**
+ * @param {Array.<String>} pkgJsonPaths
+ * @param {String|null} packagesDirectory
+ * @returns {Object}
+ */
+function getRandomPackagePath( pkgJsonPaths, packagesDirectory ) {
+	const randomPkgJsonPaths = packagesDirectory ?
+		pkgJsonPaths.filter( packagePath => packagePath.includes( packagesDirectory ) ) :
+		pkgJsonPaths;
+	const randomPkgJsonPath = randomPkgJsonPaths[ Math.floor( Math.random() * randomPkgJsonPaths.length ) ];
+
+	return dirname( randomPkgJsonPath );
+}
+
+/**
+ * Checks if the specified version is greater than the current one.
+ *
+ * A nightly version is always considered as valid.
+ *
+ * @param {String} newVersion
+ * @param {String} currentVersion
+ */
+function checkIfVersionIsValid( newVersion, currentVersion ) {
+	if ( newVersion.startsWith( '0.0.0-nightly' ) ) {
+		return;
+	}
+
+	if ( !semver.gt( newVersion, currentVersion ) ) {
+		throw new Error( `Provided version ${ newVersion } must be greater than ${ currentVersion } or match pattern 0.0.0-nightly.` );
+	}
+}
+
+/**
+ * Checks if the provided version is not used in npm and there will be no errors when calling publish.
+ *
+ * @param {String} version
+ * @param {String} packageName
+ * @returns {Promise}
+ */
+async function checkVersionAvailability( version, packageName ) {
+	return tools.shExec( `npm show ${ packageName }@${ version } version`, { verbosity: 'silent', async: true } )
+		.then( () => {
+			throw new Error( `Provided version ${ version } is already used in npm by ${ packageName }.` );
+		} )
+		.catch( err => {
+			if ( !err.toString().includes( 'is not in this registry' ) ) {
+				throw err;
+			}
+		} );
+}

package/lib/utils/assertfilestopublish.js

@@ -0,0 +1,88 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const fs = require( 'fs-extra' );
+const upath = require( 'upath' );
+const { glob } = require( 'glob' );
+
+/**
+ * Checks if all files expected to be released actually exist in the package directory. Verification takes place for all packages.
+ *
+ * @param {String} packagePaths
+ * @param {Object.<String, Array.<String>>|null} optionalEntries
+ * @returns {Promise}
+ */
+module.exports = async function assertFilesToPublish( packagePaths, optionalEntries ) {
+	const errors = [];
+
+	for ( const packagePath of packagePaths ) {
+		const requiredEntries = [];
+		const packageJsonPath = upath.join( packagePath, 'package.json' );
+		const packageJson = await fs.readJson( packageJsonPath );
+
+		if ( packageJson.main ) {
+			requiredEntries.push( packageJson.main );
+		}
+
+		if ( packageJson.types ) {
+			requiredEntries.push( packageJson.types );
+		}
+
+		if ( packageJson.files ) {
+			requiredEntries.push( ...getRequiredEntries( packageJson.files, packageJson.name, optionalEntries ) );
+		}
+
+		const unmatchedEntries = [];
+
+		for ( const requiredEntry of requiredEntries ) {
+			// To match a directory or a file using a single `requiredEntry` pattern.
+			const foundFiles = await glob( [ requiredEntry, requiredEntry + '/**' ], {
+				cwd: packagePath,
+				dot: true,
+				nodir: true
+			} );
+
+			if ( foundFiles.length === 0 ) {
+				unmatchedEntries.push( requiredEntry );
+			}
+		}
+
+		if ( unmatchedEntries.length ) {
+			errors.push( `Missing files in "${ packageJson.name }" package for entries: "${ unmatchedEntries.join( '", "' ) }"` );
+		}
+	}
+
+	if ( errors.length ) {
+		throw new Error( errors.join( '\n' ) );
+	}
+};
+
+/**
+ * Filters out the optional entries from the `files` field and returns only the required ones.
+ *
+ * @param {Array.<String>} entries
+ * @param {String} packageName
+ * @param {Object.<String, Array.<String>>|null} optionalEntries
+ * @returns {Array.<String>}
+ */
+function getRequiredEntries( entries, packageName, optionalEntries ) {
+	if ( !optionalEntries ) {
+		return entries;
+	}
+
+	return entries.filter( entry => {
+		if ( optionalEntries[ packageName ] ) {
+			return !optionalEntries[ packageName ].includes( entry );
+		}
+
+		if ( optionalEntries.default ) {
+			return !optionalEntries.default.includes( entry );
+		}
+
+		return true;
+	} );
+}

package/lib/utils/assertnpmauthorization.js

@@ -0,0 +1,26 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const { tools } = require( '@ckeditor/ckeditor5-dev-utils' );
+
+/**
+ * Checks whether a user is logged to npm as the provided account name.
+ *
+ * @param {String} npmOwner Expected npm account name that should be logged into npm.
+ * @returns {Promise}
+ */
+module.exports = async function assertNpmAuthorization( npmOwner ) {
+	return tools.shExec( 'npm whoami', { verbosity: 'error', async: true } )
+		.then( npmCurrentUser => {
+			if ( npmOwner !== npmCurrentUser.trim() ) {
+				return Promise.reject();
+			}
+		} )
+		.catch( () => {
+			throw new Error( `You must be logged to npm as "${ npmOwner }" to execute this release step.` );
+		} );
+};

package/lib/utils/assertnpmtag.js

@@ -0,0 +1,60 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const fs = require( 'fs-extra' );
+const upath = require( 'upath' );
+const semver = require( 'semver' );
+
+/**
+ * Checks if the npm tag matches the tag calculated from the package version. Verification takes place for all packages.
+ *
+ * @param {Array.<String>} packagePaths
+ * @param {String} npmTag
+ * @returns {Promise}
+ */
+module.exports = async function assertNpmTag( packagePaths, npmTag ) {
+	const errors = [];
+
+	for ( const packagePath of packagePaths ) {
+		const packageJsonPath = upath.join( packagePath, 'package.json' );
+		const packageJson = await fs.readJson( packageJsonPath );
+		const versionTag = getVersionTag( packageJson.version );
+
+		if ( versionTag === npmTag ) {
+			continue;
+		}
+
+		if ( versionTag === 'latest' && npmTag === 'staging' ) {
+			continue;
+		}
+
+		errors.push( `The version tag "${ versionTag }" from "${ packageJson.name }" package does not match the npm tag "${ npmTag }".` );
+	}
+
+	if ( errors.length ) {
+		throw new Error( errors.join( '\n' ) );
+	}
+};
+
+/**
+ * Returns the version tag for the package.
+ *
+ * For the official release, returns the "latest" tag. For a non-official release (pre-release), returns the version tag extracted from
+ * the package version.
+ *
+ * @param {String} version
+ * @returns {String}
+ */
+function getVersionTag( version ) {
+	const [ versionTag ] = semver.prerelease( version ) || [ 'latest' ];
+
+	if ( versionTag.startsWith( 'nightly' ) ) {
+		return 'nightly';
+	}
+
+	return versionTag;
+}

package/lib/utils/assertpackages.js

@@ -0,0 +1,34 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+const fs = require( 'fs-extra' );
+const upath = require( 'upath' );
+
+/**
+ * Checks if all packages in the provided directories contain the `package.json` file.
+ *
+ * @param {Array.<String>} packagePaths
+ * @returns {Promise}
+ */
+module.exports = async function assertPackages( packagePaths ) {
+	const errors = [];
+
+	for ( const packagePath of packagePaths ) {
+		const packageName = upath.basename( packagePath );
+		const packageJsonPath = upath.join( packagePath, 'package.json' );
+
+		if ( await fs.pathExists( packageJsonPath ) ) {
+			continue;
+		}
+
+		errors.push( `The "package.json" file is missing in the "${ packageName }" package.` );
+	}
+
+	if ( errors.length ) {
+		throw new Error( errors.join( '\n' ) );
+	}
+};

package/lib/utils/changelog.js

@@ -7,6 +7,7 @@
 
 const fs = require( 'fs' );
 const path = require( 'path' );
+const { getRepositoryUrl } = require( './transformcommitutils' );
 
 const utils = {
 	/**
@@ -61,6 +62,39 @@ const utils = {
 		const changelogFile = path.join( cwd, utils.changelogFile );
 
 		fs.writeFileSync( changelogFile, content, 'utf-8' );
+	},
+
+	/**
+	 * @param {Number} length
+	 * @param {String} [cwd=process.cwd()] Where to look for the changelog file.
+	 */
+	truncateChangelog( length, cwd = process.cwd() ) {
+		const changelog = utils.getChangelog( cwd );
+
+		if ( !changelog ) {
+			return;
+		}
+
+		const entryHeader = '## [\\s\\S]+?';
+		const entryHeaderRegexp = new RegExp( `\\n(${ entryHeader })(?=\\n${ entryHeader }|$)`, 'g' );
+
+		const entries = [ ...changelog.matchAll( entryHeaderRegexp ) ]
+			.filter( match => match && match[ 1 ] )
+			.map( match => match[ 1 ] );
+
+		if ( !entries.length ) {
+			return;
+		}
+
+		const truncatedEntries = entries.slice( 0, length );
+
+		const changelogFooter = entries.length > truncatedEntries.length ?
+			`\n\n---\n\nTo see all releases, visit the [release page](${ getRepositoryUrl( cwd ) }/releases).\n` :
+			'\n';
+
+		const truncatedChangelog = utils.changelogHeader + truncatedEntries.join( '\n' ).trim() + changelogFooter;
+
+		utils.saveChangelog( truncatedChangelog, cwd );
 	}
 };