nx 16.9.0-beta.0 → 16.9.0-beta.2

package/bin/nx.js

@@ -15,6 +15,8 @@ const child_process_1 = require("child_process");
 const path_1 = require("path");
 const assert_supported_platform_1 = require("../src/native/assert-supported-platform");
 const perf_hooks_1 = require("perf_hooks");
+const workspace_context_1 = require("../src/utils/workspace-context");
+const client_1 = require("../src/daemon/client/client");
 function main() {
     if (process.argv[2] !== 'report' &&
         process.argv[2] !== '--version' &&
@@ -42,9 +44,12 @@ function main() {
         // Angular CLI, and prettier both use ESM so we need to disable it in these cases.
         if (workspace &&
             workspace.type === 'nx' &&
-            !['format', 'format:check', 'format:write', 'g', 'generate'].some((cmd) => process.argv[3] === cmd)) {
+            !['format', 'format:check', 'format:write', 'g', 'generate'].some((cmd) => process.argv[2] === cmd)) {
             require('v8-compile-cache');
         }
+        if (!client_1.daemonClient.enabled() && workspace !== null) {
+            (0, workspace_context_1.setupWorkspaceContext)(workspace.dir);
+        }
         // polyfill rxjs observable to avoid issues with multiple version of Observable installed in node_modules
         // https://twitter.com/BenLesh/status/1192478226385428483?s=20
         if (!Symbol.observable)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "16.9.0-beta.0",
+  "version": "16.9.0-beta.2",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -32,7 +32,7 @@
   },
   "homepage": "https://nx.dev",
   "dependencies": {
-    "@nrwl/tao": "16.9.0-beta.0",
+    "@nrwl/tao": "16.9.0-beta.2",
     "@parcel/watcher": "2.0.4",
     "@yarnpkg/lockfile": "^1.1.0",
     "@yarnpkg/parsers": "3.0.0-rc.46",
@@ -50,6 +50,7 @@
     "fs-extra": "^11.1.0",
     "glob": "7.1.4",
     "ignore": "^5.0.4",
+    "jest-diff": "^29.4.1",
     "js-yaml": "4.1.0",
     "jsonc-parser": "3.2.0",
     "lines-and-columns": "~2.0.3",
@@ -81,16 +82,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "16.9.0-beta.0",
-    "@nx/nx-darwin-x64": "16.9.0-beta.0",
-    "@nx/nx-freebsd-x64": "16.9.0-beta.0",
-    "@nx/nx-linux-arm-gnueabihf": "16.9.0-beta.0",
-    "@nx/nx-linux-arm64-gnu": "16.9.0-beta.0",
-    "@nx/nx-linux-arm64-musl": "16.9.0-beta.0",
-    "@nx/nx-linux-x64-gnu": "16.9.0-beta.0",
-    "@nx/nx-linux-x64-musl": "16.9.0-beta.0",
-    "@nx/nx-win32-arm64-msvc": "16.9.0-beta.0",
-    "@nx/nx-win32-x64-msvc": "16.9.0-beta.0"
+    "@nx/nx-darwin-arm64": "16.9.0-beta.2",
+    "@nx/nx-darwin-x64": "16.9.0-beta.2",
+    "@nx/nx-freebsd-x64": "16.9.0-beta.2",
+    "@nx/nx-linux-arm-gnueabihf": "16.9.0-beta.2",
+    "@nx/nx-linux-arm64-gnu": "16.9.0-beta.2",
+    "@nx/nx-linux-arm64-musl": "16.9.0-beta.2",
+    "@nx/nx-linux-x64-gnu": "16.9.0-beta.2",
+    "@nx/nx-linux-x64-musl": "16.9.0-beta.2",
+    "@nx/nx-win32-arm64-msvc": "16.9.0-beta.2",
+    "@nx/nx-win32-x64-msvc": "16.9.0-beta.2"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",
@@ -177,5 +178,5 @@
   },
   "main": "./bin/nx.js",
   "type": "commonjs",
-  "gitHead": "822fb12c3f0bbaeb6d4a6fbc6cb1064a291e907f"
+  "gitHead": "e11d538fa2c7266066d554d9405abab8e0a65040"
 }

package/src/command-line/affected/affected.js

@@ -62,7 +62,11 @@ async function affected(command, args, extraTargetDependencies = {}) {
                     }, projectNames);
                 }
                 else {
-                    await (0, run_command_1.runCommand)(projectsWithTarget, projectGraph, { nxJson }, nxArgs, overrides, null, extraTargetDependencies, { excludeTaskDependencies: false, loadDotEnvFiles: true });
+                    const status = await (0, run_command_1.runCommand)(projectsWithTarget, projectGraph, { nxJson }, nxArgs, overrides, null, extraTargetDependencies, { excludeTaskDependencies: false, loadDotEnvFiles: true });
+                    // fix for https://github.com/nrwl/nx/issues/1666
+                    if (process.stdin['unref'])
+                        process.stdin.unref();
+                    process.exit(status);
                 }
                 break;
             }

package/src/command-line/affected/print-affected.js

@@ -6,7 +6,6 @@ const create_task_graph_1 = require("../../tasks-runner/create-task-graph");
 const task_hasher_1 = require("../../hasher/task-hasher");
 const hash_task_1 = require("../../hasher/hash-task");
 const package_manager_1 = require("../../utils/package-manager");
-const file_hasher_1 = require("../../hasher/file-hasher");
 const command_object_1 = require("./command-object");
 const logger_1 = require("../../utils/logger");
 /**
@@ -35,7 +34,7 @@ exports.printAffected = printAffected;
 async function createTasks(affectedProjectsWithTargetAndConfig, projectGraph, nxArgs, nxJson, overrides) {
     const defaultDependencyConfigs = (0, create_task_graph_1.mapTargetDefaultsToDependencies)(nxJson.targetDefaults);
     const taskGraph = (0, create_task_graph_1.createTaskGraph)(projectGraph, defaultDependencyConfigs, affectedProjectsWithTargetAndConfig.map((p) => p.name), nxArgs.targets, nxArgs.configuration, overrides);
-    const hasher = new task_hasher_1.InProcessTaskHasher({}, [], projectGraph, nxJson, {}, file_hasher_1.fileHasher);
+    const hasher = new task_hasher_1.InProcessTaskHasher({}, [], projectGraph, nxJson, {});
     const execCommand = (0, package_manager_1.getPackageManagerCommand)().exec;
     const tasks = Object.values(taskGraph.tasks);
     await Promise.all(tasks.map((t) => (0, hash_task_1.hashTask)(hasher, projectGraph, taskGraph, t)));

package/src/command-line/generate/generate.d.ts

@@ -12,6 +12,10 @@ export interface GenerateOptions {
     quiet: boolean;
 }
 export declare function printChanges(fileChanges: FileChange[]): void;
+export declare function parseGeneratorString(value: string): {
+    collection?: string;
+    generator: string;
+};
 export declare function printGenHelp(opts: GenerateOptions, schema: Schema, normalizedGeneratorName: string, aliases: string[]): void;
 export declare function generate(cwd: string, args: {
     [k: string]: any;

package/src/command-line/generate/generate.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.workspaceGenerators = exports.generate = exports.printGenHelp = exports.printChanges = void 0;
+exports.workspaceGenerators = exports.generate = exports.printGenHelp = exports.parseGeneratorString = exports.printChanges = void 0;
 const chalk = require("chalk");
 const enquirer_1 = require("enquirer");
 const path_1 = require("path");
@@ -145,6 +145,7 @@ function parseGeneratorString(value) {
         };
     }
 }
+exports.parseGeneratorString = parseGeneratorString;
 async function convertToGenerateOptions(generatorOptions, defaultCollectionName, mode, projectsConfiguration) {
     let collectionName = null;
     let generatorName = null;

package/src/command-line/graph/graph.js

@@ -18,7 +18,6 @@ const project_graph_1 = require("../../project-graph/project-graph");
 const create_task_graph_1 = require("../../tasks-runner/create-task-graph");
 const client_1 = require("../../daemon/client/client");
 const nx_deps_cache_1 = require("../../project-graph/nx-deps-cache");
-const file_hasher_1 = require("../../hasher/file-hasher");
 const affected_1 = require("../affected/affected");
 const command_line_utils_1 = require("../../utils/command-line-utils");
 // maps file extention to MIME types
@@ -381,7 +380,6 @@ function createFileWatcher() {
 }
 async function createDepGraphClientResponse(affected = []) {
     perf_hooks_1.performance.mark('project graph watch calculation:start');
-    await file_hasher_1.fileHasher.init();
     let graph = (0, operators_1.pruneExternalNodes)(await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true }));
     let fileMap = (0, nx_deps_cache_1.readProjectFileMapCache)().projectFileMap;
     perf_hooks_1.performance.mark('project graph watch calculation:end');

package/src/command-line/nx-commands.js

@@ -22,6 +22,7 @@ const command_object_16 = require("./show/command-object");
 const command_object_17 = require("./watch/command-object");
 const command_object_18 = require("./workspace-lint/command-object");
 const command_object_19 = require("./reset/command-object");
+const command_object_20 = require("./release/command-object");
 // Ensure that the output takes up the available width of the terminal.
 yargs.wrap(yargs.terminalWidth());
 exports.parserConfiguration = {
@@ -57,6 +58,7 @@ exports.commandsObject = yargs
     .command(command_object_10.yargsMigrateCommand)
     .command(command_object_11.yargsNewCommand)
     .command(command_object_1.yargsPrintAffectedCommand)
+    .command(command_object_20.yargsReleaseCommand)
     .command(command_object_12.yargsRepairCommand)
     .command(command_object_13.yargsReportCommand)
     .command(command_object_19.yargsResetCommand)

package/src/command-line/release/changelog.d.ts

@@ -0,0 +1,2 @@
+import { ChangelogOptions } from './command-object';
+export declare function changelogHandler(args: ChangelogOptions): Promise<void>;

package/src/command-line/release/changelog.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changelogHandler = void 0;
+const chalk = require("chalk");
+const node_fs_1 = require("node:fs");
+const tmp_1 = require("tmp");
+const devkit_exports_1 = require("../../devkit-exports");
+const git_1 = require("./utils/git");
+const github_1 = require("./utils/github");
+const launch_editor_1 = require("./utils/launch-editor");
+const print_diff_1 = require("./utils/print-diff");
+async function changelogHandler(args) {
+    /**
+     * TODO: allow the prefix and version to be controllable via config as well once we flesh out
+     * changelog customization, and how it will interact with independently released projects.
+     */
+    const tagVersionPrefix = args.tagVersionPrefix ?? 'v';
+    const releaseVersion = `${tagVersionPrefix}${args.version}`;
+    const githubRemote = (0, github_1.getGitHubRemote)(args.gitRemote);
+    const token = await (0, github_1.resolveGithubToken)();
+    const githubRequestConfig = {
+        repo: githubRemote,
+        token,
+    };
+    const from = args.from || (await (0, git_1.getLastGitTag)());
+    if (!from) {
+        throw new Error(`Could not determine the previous git tag, please provide and explicit reference using --from`);
+    }
+    const to = args.to;
+    const rawCommits = await (0, git_1.getGitDiff)(from, args.to);
+    // Parse as conventional commits
+    const commits = (0, git_1.parseCommits)(rawCommits).filter((c) => {
+        const type = c.type;
+        // Always ignore non user-facing commits for now
+        // TODO: allow this filter to be configurable via config in a future release
+        if (type === 'feat' || type === 'fix' || type === 'perf') {
+            return true;
+        }
+        return false;
+    });
+    const initialMarkdown = await (0, github_1.generateMarkdown)(commits, releaseVersion, githubRequestConfig);
+    let finalMarkdown = initialMarkdown;
+    /**
+     * If interactive mode, make the markdown available for the user to modify in their editor of choice,
+     * in a similar style to git interactive rebases/merges.
+     */
+    if (args.interactive) {
+        const tmpDir = (0, tmp_1.dirSync)().name;
+        const changelogPath = (0, devkit_exports_1.joinPathFragments)(tmpDir, 'c.md');
+        (0, node_fs_1.writeFileSync)(changelogPath, initialMarkdown);
+        await (0, launch_editor_1.launchEditor)(changelogPath);
+        finalMarkdown = (0, node_fs_1.readFileSync)(changelogPath, 'utf-8');
+    }
+    let existingGithubReleaseForVersion;
+    try {
+        existingGithubReleaseForVersion = await (0, github_1.getGithubReleaseByTag)(githubRequestConfig, releaseVersion);
+    }
+    catch (err) {
+        if (err.response?.status === 401) {
+            devkit_exports_1.output.error({
+                title: `Unable to resolve data via the Github API. You can use any of the following options to resolve this:`,
+                bodyLines: [
+                    '- Set the `GITHUB_TOKEN` or `GH_TOKEN` environment variable to a valid Github token with `repo` scope',
+                    '- Have an active session via the official gh CLI tool (https://cli.github.com) in your current terminal',
+                ],
+            });
+            process.exit(1);
+        }
+        if (err.response?.status === 404) {
+            // No existing release found, this is fine
+        }
+        else {
+            // Rethrow unknown errors for now
+            throw err;
+        }
+    }
+    const changesRangeText = to === 'HEAD' ? `since ${from}` : `between ${from} and ${to}`;
+    if (existingGithubReleaseForVersion) {
+        devkit_exports_1.output.log({
+            title: `Found existing Github release for ${chalk.white(releaseVersion)}, regenerating with changes ${chalk.cyan(changesRangeText)}`,
+        });
+    }
+    else {
+        devkit_exports_1.output.log({
+            title: `Creating a new Github release for ${chalk.white(releaseVersion)}, including changes ${chalk.cyan(changesRangeText)}`,
+        });
+    }
+    printReleaseLog(releaseVersion, githubRemote, args.dryRun, finalMarkdown, existingGithubReleaseForVersion);
+    if (args.dryRun) {
+        devkit_exports_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
+    }
+    else {
+        await (0, github_1.createOrUpdateGithubRelease)(githubRequestConfig, {
+            version: releaseVersion,
+            body: finalMarkdown,
+        }, existingGithubReleaseForVersion);
+    }
+    process.exit(0);
+}
+exports.changelogHandler = changelogHandler;
+function printReleaseLog(releaseVersion, githubRemote, isDryRun, finalMarkdown, existingGithubReleaseForVersion) {
+    const logTitle = `https://github.com/${githubRemote}/releases/tag/${releaseVersion}`;
+    if (existingGithubReleaseForVersion) {
+        console.error(`${chalk.white('UPDATE')} ${logTitle}${isDryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
+    }
+    else {
+        console.error(`${chalk.green('CREATE')} ${logTitle}${isDryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
+    }
+    console.log('');
+    (0, print_diff_1.printDiff)('', finalMarkdown);
+}

package/src/command-line/release/command-object.d.ts

@@ -0,0 +1,25 @@
+import { CommandModule } from 'yargs';
+import { RunManyOptions } from '../yargs-utils/shared-options';
+export interface NxReleaseArgs {
+    groups?: string[];
+    projects?: string[];
+    dryRun?: boolean;
+    verbose?: boolean;
+}
+export type VersionOptions = NxReleaseArgs & {
+    specifier?: string;
+    preid?: string;
+};
+export type ChangelogOptions = NxReleaseArgs & {
+    version: string;
+    to: string;
+    from?: string;
+    interactive?: boolean;
+    gitRemote?: string;
+    tagVersionPrefix?: string;
+};
+export type PublishOptions = NxReleaseArgs & RunManyOptions & {
+    registry?: string;
+    tag?: string;
+};
+export declare const yargsReleaseCommand: CommandModule<Record<string, unknown>, NxReleaseArgs>;

package/src/command-line/release/command-object.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsReleaseCommand = void 0;
+const yargs_1 = require("yargs");
+const file_utils_1 = require("../../project-graph/file-utils");
+const shared_options_1 = require("../yargs-utils/shared-options");
+exports.yargsReleaseCommand = {
+    command: 'release',
+    describe: '**ALPHA**: Orchestrate versioning and publishing of applications and libraries',
+    builder: (yargs) => yargs
+        .command(versionCommand)
+        .command(changelogCommand)
+        .command(publishCommand)
+        .demandCommand()
+        .option('groups', {
+        description: 'One or more release groups to target with the current command.',
+        type: 'string',
+        coerce: shared_options_1.parseCSV,
+        alias: ['group', 'g'],
+    })
+        .option('projects', {
+        type: 'string',
+        alias: 'p',
+        coerce: shared_options_1.parseCSV,
+        describe: 'Projects to run. (comma/space delimited project names and/or patterns)',
+    })
+        .option('dryRun', {
+        describe: 'Preview the changes without updating files/creating releases',
+        alias: 'd',
+        type: 'boolean',
+        default: false,
+    })
+        .option('verbose', {
+        type: 'boolean',
+        describe: 'Prints additional information about the commands (e.g., stack traces)',
+    })
+        .check((argv) => {
+        if (argv.groups && argv.projects) {
+            throw new Error('The --projects and --groups options are mutually exclusive, please use one or the other.');
+        }
+        const nxJson = (0, file_utils_1.readNxJson)();
+        if (argv.groups?.length) {
+            for (const group of argv.groups) {
+                if (!nxJson.release?.groups?.[group]) {
+                    throw new Error(`The specified release group "${group}" was not found in nx.json`);
+                }
+            }
+        }
+        return true;
+    }),
+    handler: async () => {
+        (0, yargs_1.showHelp)();
+        process.exit(1);
+    },
+};
+const versionCommand = {
+    command: 'version [specifier]',
+    aliases: ['v'],
+    describe: 'Create a version and release for one or more applications and libraries',
+    builder: (yargs) => yargs
+        .positional('specifier', {
+        type: 'string',
+        describe: 'Exact version or semver keyword to apply to the selected release group.',
+    })
+        .option('preid', {
+        type: 'string',
+        describe: 'The optional prerelease identifier to apply to the version, in the case that specifier has been set to prerelease.',
+        default: '',
+    }),
+    handler: (args) => Promise.resolve().then(() => require('./version')).then((m) => m.versionHandler(args)),
+};
+const changelogCommand = {
+    command: 'changelog [version]',
+    aliases: ['c'],
+    describe: 'Generate a changelog for one or more projects, and optionally push to Github',
+    builder: (yargs) => yargs
+        // Disable default meaning of yargs version for this command
+        .version(false)
+        .positional('version', {
+        type: 'string',
+        description: 'The version to create a Github release and changelog for',
+    })
+        .option('from', {
+        type: 'string',
+        description: 'The git reference to use as the start of the changelog. If not set it will attempt to resolve the latest tag and use that',
+    })
+        .option('to', {
+        type: 'string',
+        description: 'The git reference to use as the end of the changelog',
+        default: 'HEAD',
+    })
+        .option('interactive', {
+        alias: 'i',
+        type: 'boolean',
+    })
+        .option('gitRemote', {
+        type: 'string',
+        description: 'Alternate git remote in the form {user}/{repo} on which to create the Github release (useful for testing)',
+        default: 'origin',
+    })
+        .option('tagVersionPrefix', {
+        type: 'string',
+        description: 'Prefix to apply to the version when creating the Github release tag',
+        default: 'v',
+    })
+        .check((argv) => {
+        if (!argv.version) {
+            throw new Error('A target version must be specified');
+        }
+        return true;
+    }),
+    handler: (args) => Promise.resolve().then(() => require('./changelog')).then((m) => m.changelogHandler(args)),
+};
+const publishCommand = {
+    command: 'publish',
+    aliases: ['p'],
+    describe: 'Publish a versioned project to a registry',
+    builder: (yargs) => (0, shared_options_1.withRunManyOptions)(yargs)
+        .option('registry', {
+        type: 'string',
+        description: 'The registry to publish to',
+    })
+        .option('tag', {
+        type: 'string',
+        description: 'The distribution tag to apply to the published package',
+    }),
+    handler: (args) => Promise.resolve().then(() => require('./publish')).then((m) => m.publishHandler((0, shared_options_1.withOverrides)(args, 2))),
+};

package/src/command-line/release/config/config.d.ts

@@ -0,0 +1,2 @@
+import { NxJsonConfiguration } from '../../../config/nx-json';
+export declare function createNxReleaseConfig(userConfig?: NxJsonConfiguration['release']): Required<NxJsonConfiguration['release']>;

package/src/command-line/release/config/config.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNxReleaseConfig = void 0;
+// Apply default configuration to any optional user configuration
+function createNxReleaseConfig(userConfig = {}) {
+    const nxReleaseConfig = {
+        ...userConfig,
+        groups: userConfig.groups || {},
+    };
+    return nxReleaseConfig;
+}
+exports.createNxReleaseConfig = createNxReleaseConfig;

package/src/command-line/release/config/create-release-groups.d.ts

@@ -0,0 +1,25 @@
+import type { NxJsonConfiguration } from '../../../config/nx-json';
+import { type ProjectGraph } from '../../../devkit-exports';
+export interface ReleaseGroup {
+    name: string;
+    projects: string[];
+    version: {
+        generator: string;
+        generatorOptions: Record<string, unknown>;
+    };
+}
+interface CreateReleaseGroupsError {
+    code: 'RELEASE_GROUP_MATCHES_NO_PROJECTS' | 'PROJECT_MATCHES_MULTIPLE_GROUPS' | 'PROJECTS_MISSING_TARGET';
+    data: Record<string, string | string[]>;
+}
+export declare const CATCH_ALL_RELEASE_GROUP = "__default__";
+/**
+ * Create a set of release groups based on the relevant user specified config ready
+ * to be consumed by the release commands.
+ */
+export declare function createReleaseGroups(projectGraph: ProjectGraph, userSpecifiedGroups?: NxJsonConfiguration['release']['groups'], requiredTargetName?: 'nx-release-publish'): Promise<{
+    error: null | CreateReleaseGroupsError;
+    releaseGroups: ReleaseGroup[];
+}>;
+export declare function handleCreateReleaseGroupsError(error: CreateReleaseGroupsError): Promise<void>;
+export {};

package/src/command-line/release/config/create-release-groups.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleCreateReleaseGroupsError = exports.createReleaseGroups = exports.CATCH_ALL_RELEASE_GROUP = void 0;
+const devkit_exports_1 = require("../../../devkit-exports");
+const find_matching_projects_1 = require("../../../utils/find-matching-projects");
+const project_graph_utils_1 = require("../../../utils/project-graph-utils");
+const resolve_nx_json_error_message_1 = require("../utils/resolve-nx-json-error-message");
+exports.CATCH_ALL_RELEASE_GROUP = '__default__';
+/**
+ * Create a set of release groups based on the relevant user specified config ready
+ * to be consumed by the release commands.
+ */
+async function createReleaseGroups(projectGraph, userSpecifiedGroups = {}, requiredTargetName) {
+    const DEFAULT_VERSION_GENERATOR = '@nx/js:release-version';
+    const DEFAULT_VERSION_GENERATOR_OPTIONS = {};
+    const allProjects = (0, find_matching_projects_1.findMatchingProjects)(['*'], projectGraph.nodes);
+    /**
+     * No user specified release groups, so we treat all projects as being in one release group
+     * together in which all projects are released in lock step.
+     */
+    if (Object.keys(userSpecifiedGroups).length === 0) {
+        // Ensure all projects have the relevant target available, if applicable
+        if (requiredTargetName) {
+            const error = ensureProjectsHaveTarget(allProjects, projectGraph, requiredTargetName);
+            if (error) {
+                return {
+                    error,
+                    releaseGroups: [],
+                };
+            }
+        }
+        return {
+            error: null,
+            releaseGroups: [
+                {
+                    name: exports.CATCH_ALL_RELEASE_GROUP,
+                    projects: allProjects,
+                    version: {
+                        generator: DEFAULT_VERSION_GENERATOR,
+                        generatorOptions: DEFAULT_VERSION_GENERATOR_OPTIONS,
+                    },
+                },
+            ],
+        };
+    }
+    /**
+     * The user has specified at least one release group.
+     *
+     * Resolve all the project names into their release groups, and check
+     * that individual projects are not found in multiple groups.
+     */
+    const releaseGroups = [];
+    const alreadyMatchedProjects = new Set();
+    for (const [releaseGroupName, userSpecifiedGroup] of Object.entries(userSpecifiedGroups)) {
+        // Ensure that the user config for the release group can resolve at least one project
+        const matchingProjects = (0, find_matching_projects_1.findMatchingProjects)(Array.isArray(userSpecifiedGroup.projects)
+            ? userSpecifiedGroup.projects
+            : [userSpecifiedGroup.projects], projectGraph.nodes);
+        if (!matchingProjects.length) {
+            return {
+                error: {
+                    code: 'RELEASE_GROUP_MATCHES_NO_PROJECTS',
+                    data: {
+                        releaseGroupName: releaseGroupName,
+                    },
+                },
+                releaseGroups: [],
+            };
+        }
+        // Ensure all matching projects have the relevant target available, if applicable
+        if (requiredTargetName) {
+            const error = ensureProjectsHaveTarget(matchingProjects, projectGraph, requiredTargetName);
+            if (error) {
+                return {
+                    error,
+                    releaseGroups: [],
+                };
+            }
+        }
+        for (const project of matchingProjects) {
+            if (alreadyMatchedProjects.has(project)) {
+                return {
+                    error: {
+                        code: 'PROJECT_MATCHES_MULTIPLE_GROUPS',
+                        data: {
+                            project,
+                        },
+                    },
+                    releaseGroups: [],
+                };
+            }
+            alreadyMatchedProjects.add(project);
+        }
+        releaseGroups.push({
+            name: releaseGroupName,
+            projects: matchingProjects,
+            version: userSpecifiedGroup.version
+                ? {
+                    generator: userSpecifiedGroup.version.generator || DEFAULT_VERSION_GENERATOR,
+                    generatorOptions: userSpecifiedGroup.version.generatorOptions ||
+                        DEFAULT_VERSION_GENERATOR_OPTIONS,
+                }
+                : {
+                    generator: DEFAULT_VERSION_GENERATOR,
+                    generatorOptions: DEFAULT_VERSION_GENERATOR_OPTIONS,
+                },
+        });
+    }
+    return {
+        error: null,
+        releaseGroups,
+    };
+}
+exports.createReleaseGroups = createReleaseGroups;
+async function handleCreateReleaseGroupsError(error) {
+    switch (error.code) {
+        case 'RELEASE_GROUP_MATCHES_NO_PROJECTS':
+            {
+                const nxJsonMessage = await (0, resolve_nx_json_error_message_1.resolveNxJsonConfigErrorMessage)([
+                    'release',
+                    'groups',
+                ]);
+                devkit_exports_1.output.error({
+                    title: `Release group "${error.data.releaseGroupName}" matches no projects. Please ensure all release groups match at least one project:`,
+                    bodyLines: [nxJsonMessage],
+                });
+            }
+            break;
+        case 'PROJECT_MATCHES_MULTIPLE_GROUPS':
+            {
+                const nxJsonMessage = await (0, resolve_nx_json_error_message_1.resolveNxJsonConfigErrorMessage)([
+                    'release',
+                    'groups',
+                ]);
+                devkit_exports_1.output.error({
+                    title: `Project "${error.data.project}" matches multiple release groups. Please ensure all projects are part of only one release group:`,
+                    bodyLines: [nxJsonMessage],
+                });
+            }
+            break;
+        case 'PROJECTS_MISSING_TARGET':
+            {
+                devkit_exports_1.output.error({
+                    title: `Based on your config, the following projects were matched for release but do not have a "${error.data.targetName}" target specified. Please ensure you have an appropriate plugin such as @nx/js installed, or have configured the target manually, or exclude the projects using release groups config in nx.json:`,
+                    bodyLines: Array.from(error.data.projects).map((name) => `- ${name}`),
+                });
+            }
+            break;
+        default:
+            throw new Error(`Unhandled error code: ${error.code}`);
+    }
+    process.exit(1);
+}
+exports.handleCreateReleaseGroupsError = handleCreateReleaseGroupsError;
+function ensureProjectsHaveTarget(projects, projectGraph, requiredTargetName) {
+    const missingTargetProjects = projects.filter((project) => !(0, project_graph_utils_1.projectHasTarget)(projectGraph.nodes[project], requiredTargetName));
+    if (missingTargetProjects.length) {
+        return {
+            code: 'PROJECTS_MISSING_TARGET',
+            data: {
+                targetName: requiredTargetName,
+                projects: missingTargetProjects,
+            },
+        };
+    }
+    return null;
+}

package/src/command-line/release/publish.d.ts

@@ -0,0 +1,4 @@
+import { PublishOptions } from './command-object';
+export declare function publishHandler(args: PublishOptions & {
+    __overrides_unparsed__: string[];
+}): Promise<void>;