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

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 );
+	}
+};

package/lib/utils/{validatepackagetorelease.js → validaterepositorytorelease.js}

@@ -9,23 +9,28 @@ const { tools } = require( '@ckeditor/ckeditor5-dev-utils' );
 
 /**
  * @param {Object} options
- * @param {String} options.version Version of the current release.
+ * @param {String|null} options.version Version of the current release.
  * @param {String} options.changes Changelog entries for the current release.
  * @param {Boolean} [options.ignoreBranchCheck=false] If set on true, branch checking will be skipped.
  * @param {String} [options.branch='master'] A name of the branch that should be used for releasing packages.
- * @returns {Array.<String>}
+ * @returns {Promise.<Array.<String>>}
  */
-module.exports = function validatePackageToRelease( options ) {
+module.exports = async function validateRepositoryToRelease( options ) {
+	const {
+		version,
+		changes,
+		ignoreBranchCheck = false,
+		branch = 'master'
+	} = options;
 	const errors = [];
-	const branch = options.branch || 'master';
 
 	// Check whether the repository is ready for the release.
-	const status = exec( 'git status -sb', { verbosity: 'error' } ).trim();
+	const status = ( await exec( 'git status -sb' ) ).trim();
 
-	if ( !options.ignoreBranchCheck ) {
+	if ( !ignoreBranchCheck ) {
 		// Check whether current branch is "master".
-		if ( !status.startsWith( `## ${ branch }...origin/${ branch }` ) ) {
-			errors.push( `Not on ${ branch } branch.` );
+		if ( !status.startsWith( `## ${ branch }` ) ) {
+			errors.push( `Not on the "#${ branch }" branch.` );
 		}
 	}
 
@@ -42,13 +47,13 @@ module.exports = function validatePackageToRelease( options ) {
 	}
 
 	// Check whether the changelog entries are correct.
-	if ( !options.changes ) {
-		errors.push( `Cannot find changelog entries for version "${ options.version }".` );
+	if ( !changes ) {
+		errors.push( `Cannot find changelog entries for version "${ version }".` );
 	}
 
 	return errors;
 
-	function exec( command ) {
-		return tools.shExec( command, { verbosity: 'error' } );
+	async function exec( command ) {
+		return tools.shExec( command, { verbosity: 'error', async: true } );
 	}
 };

package/package.json

@@ -1,38 +1,31 @@
 {
   "name": "@ckeditor/ckeditor5-dev-release-tools",
-  "version": "37.0.1",
+  "version": "38.0.0",
   "description": "Tools used for releasing CKEditor 5 and related packages.",
   "keywords": [],
   "main": "lib/index.js",
   "dependencies": {
-    "@ckeditor/ckeditor5-dev-utils": "^37.0.1",
+    "@ckeditor/ckeditor5-dev-utils": "^38.0.0",
     "@octokit/rest": "^17.9.2",
     "chalk": "^4.0.0",
     "cli-table": "^0.3.1",
+    "cli-columns": "^4.0.0",
     "compare-func": "^2.0.0",
     "concat-stream": "^2.0.0",
     "conventional-changelog-writer": "^4.0.16",
     "conventional-commits-filter": "^2.0.6",
     "conventional-commits-parser": "^3.1.0",
-    "fs-extra": "^9.1.0",
     "diff": "^5.0.0",
+    "fs-extra": "^9.1.0",
     "git-raw-commits": "^2.0.7",
-    "glob": "^7.1.6",
+    "glob": "^10.2.5",
     "inquirer": "^7.1.0",
     "lodash": "^4.17.15",
     "minimatch": "^3.0.4",
     "mkdirp": "^1.0.4",
     "parse-github-url": "^1.0.2",
-    "semver": "^7.3.2"
-  },
-  "devDependencies": {
-    "chai": "^4.2.0",
-    "handlebars": "^4.7.6",
-    "mockery": "^2.1.0",
-    "mock-fs": "^5.1.2",
-    "proxyquire": "^2.1.3",
-    "sinon": "^9.2.4",
-    "strip-ansi": "^6.0.0"
+    "semver": "^7.3.2",
+    "upath": "^2.0.1"
   },
   "engines": {
     "node": ">=16.0.0",