@ckeditor/ckeditor5-dev-release-tools 37.0.1 → 38.0.0-alpha.0

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/executeinparallel.js

@@ -0,0 +1,167 @@
+/**
+ * @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 crypto = require( 'crypto' );
+const upath = require( 'upath' );
+const fs = require( 'fs/promises' );
+const { Worker } = require( 'worker_threads' );
+const { glob } = require( 'glob' );
+
+const WORKER_SCRIPT = upath.join( __dirname, 'parallelworker.js' );
+
+/**
+ * This util allows executing a specified task in parallel using Workers. It can be helpful when executing a not resource-consuming
+ * task in all packages specified in a path.
+ *
+ * If the callback loads dependencies, they must be specified directly in the function due to the worker's limitations.
+ * Functions cannot be passed to workers. Hence, we store the callback as a Node.js file loaded by workers.
+ *
+ * @see https://nodejs.org/api/worker_threads.html
+ * @param {Object} options
+ * @param {String} options.packagesDirectory Relative path to a location of packages to execute a task.
+ * @param {Function} options.taskToExecute A callback that is executed on all found packages.
+ * It receives an absolute path to a package as an argument. It can be synchronous or may return a promise.
+ * @param {AbortSignal} options.signal Signal to abort the asynchronous process.
+ * @param {ListrTaskObject} options.listrTask An instance of `ListrTask`.
+ * @param {Function} [options.packagesDirectoryFilter] A function that is executed for each found package directory to filter out those
+ * that do not require executing a task. It should return a truthy value to keep the package and a falsy value to skip the package from
+ * processing.
+ * @param {String} [options.cwd=process.cwd()] Current working directory from which all paths will be resolved.
+ * @param {Number} [options.concurrency=require( 'os' ).cpus().length / 2] Number of CPUs that will execute the task.
+ * @returns {Promise}
+ */
+module.exports = async function executeInParallel( options ) {
+	const {
+		packagesDirectory,
+		signal,
+		taskToExecute,
+		listrTask,
+		packagesDirectoryFilter = null,
+		cwd = process.cwd(),
+		concurrency = require( 'os' ).cpus().length / 2
+	} = options;
+
+	const normalizedCwd = upath.toUnix( cwd );
+	const packages = await glob( `${ packagesDirectory }/*/`, {
+		cwd: normalizedCwd,
+		absolute: true
+	} );
+
+	const packagesToProcess = packagesDirectoryFilter ?
+		packages.filter( packagesDirectoryFilter ) :
+		packages;
+
+	const packagesInThreads = getPackagesGroupedByThreads( packagesToProcess, concurrency );
+
+	const callbackModule = upath.join( cwd, crypto.randomUUID() + '.js' );
+	await fs.writeFile( callbackModule, `'use strict';\nmodule.exports = ${ taskToExecute };`, 'utf-8' );
+
+	const onPackageDone = progressFactory( listrTask, packagesToProcess.length );
+
+	const workers = packagesInThreads.map( packages => {
+		return createWorker( {
+			signal,
+			onPackageDone,
+			workerData: { packages, callbackModule }
+		} );
+	} );
+
+	return Promise.all( workers )
+		.catch( err => {
+			// `err` can be `undefined` if a process was aborted.
+			if ( !err ) {
+				return Promise.resolve();
+			}
+
+			return Promise.reject( err );
+		} )
+		.finally( async () => {
+			await fs.unlink( callbackModule );
+		} );
+};
+
+/**
+ * @param {ListrTaskObject} listrTask
+ * @param {Number} total
+ * @returns {Function}
+ */
+function progressFactory( listrTask, total ) {
+	let done = 0;
+
+	return () => {
+		done += 1;
+		listrTask.output = `Status: ${ done }/${ total }.`;
+	};
+}
+
+/**
+ * @param {Object} options
+ * @param {AbortSignal} options.signal
+ * @param {Function} options.onPackageDone
+ * @param {Object} options.workerData
+ * @returns {Promise}
+ */
+function createWorker( { signal, onPackageDone, workerData } ) {
+	return new Promise( ( resolve, reject ) => {
+		const worker = new Worker( WORKER_SCRIPT, { workerData } );
+
+		signal.addEventListener( 'abort', () => {
+			worker.terminate();
+		}, { once: true } );
+
+		worker.on( 'error', err => {
+			reject( err );
+		} );
+
+		worker.on( 'message', msg => {
+			if ( msg === 'done:package' ) {
+				onPackageDone();
+			}
+		} );
+
+		worker.on( 'exit', code => {
+			return code ? reject() : resolve();
+		} );
+
+		return worker;
+	} );
+}
+
+/**
+ * Split the collection of packages into smaller chunks to process a task using threads.
+ *
+ * To avoid having packages with a common prefix in a single thread, use a loop for attaching packages to threads.
+ *
+ * @param {Array.<String>} packages An array of absolute paths to packages.
+ * @param {Number} concurrency A number of threads.
+ * @returns {Array.<Array.<String>>}
+ */
+function getPackagesGroupedByThreads( packages, concurrency ) {
+	return packages.reduce( ( collection, packageItem, index ) => {
+		const arrayIndex = index % concurrency;
+
+		if ( !collection[ arrayIndex ] ) {
+			collection.push( [] );
+		}
+
+		collection[ arrayIndex ].push( packageItem );
+
+		return collection;
+	}, [] );
+}
+
+/**
+ * @typedef {Object} ListrTaskObject
+ *
+ * @see https://listr2.kilic.dev/api/classes/ListrTaskObject.html
+ *
+ * @property {String} title Title of the task.
+ *
+ * @property {String} output Update the current output of the task.
+ */

package/lib/utils/getpackagejson.js

@@ -6,7 +6,7 @@
 'use strict';
 
 const fs = require( 'fs' );
-const path = require( 'path' );
+const upath = require( 'upath' );
 
 /**
  * Returns object from `package.json`.
@@ -18,7 +18,11 @@ const path = require( 'path' );
  * @returns {Object}
  */
 module.exports = function getPackageJson( cwd = process.cwd() ) {
-	return JSON.parse(
-		fs.readFileSync( path.join( cwd, 'package.json' ), 'utf-8' )
-	);
+	let pkgJsonPath = cwd;
+
+	if ( !pkgJsonPath.endsWith( 'package.json' ) ) {
+		pkgJsonPath = upath.join( cwd, 'package.json' );
+	}
+
+	return JSON.parse( fs.readFileSync( pkgJsonPath, 'utf-8' ) );
 };

package/lib/utils/parallelworker.js

@@ -0,0 +1,25 @@
+/**
+ * @license Copyright (c) 2003-2023, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+
+'use strict';
+
+// This file is covered by the "executeInParallel() - integration" test cases.
+
+// Required due to top-level await.
+( async () => {
+	/**
+	 * @param {String} callbackModule
+	 * @param {Array.<String>} packages
+	 */
+	const { parentPort, workerData } = require( 'worker_threads' );
+	const callback = require( workerData.callbackModule );
+
+	for ( const packagePath of workerData.packages ) {
+		await callback( packagePath );
+
+		// To increase the status log.
+		parentPort.postMessage( 'done:package' );
+	}
+} )();

package/lib/utils/publishpackagesonnpm.js

@@ -0,0 +1,35 @@
+/**
+ * @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 { tools } = require( '@ckeditor/ckeditor5-dev-utils' );
+
+/**
+ * Calls the npm command to publish all packages. When a package is successfully published, it is removed from the filesystem.
+ *
+ * @param {Array.<String>} packagePaths
+ * @param {String} npmTag
+ * @param {ListrTaskObject} listrTask
+ * @returns {Promise}
+ */
+module.exports = async function publishPackagesOnNpm( packagePaths, npmTag, listrTask ) {
+	let index = 0;
+
+	for ( const packagePath of packagePaths ) {
+		listrTask.output = `Status: ${ ++index }/${ packagePaths.length }. Processing the "${ upath.basename( packagePath ) }" directory.`;
+
+		await tools.shExec( `npm publish --access=public --tag ${ npmTag }`, { cwd: packagePath, async: true, verbosity: 'error' } )
+			.catch( () => {
+				const packageName = upath.basename( packagePath );
+
+				throw new Error( `Unable to publish "${ packageName }" package.` );
+			} );
+
+		await fs.remove( packagePath );
+	}
+};