nx 19.5.5 → 19.6.0-beta.0

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.releaseVersionCLIHandler = exports.validReleaseVersionPrefixes = exports.deriveNewSemverVersion = void 0;
-exports.releaseVersion = releaseVersion;
+exports.createAPI = createAPI;
 const chalk = require("chalk");
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
@@ -17,11 +17,13 @@ const workspace_root_1 = require("../../utils/workspace-root");
 const generate_1 = require("../generate/generate");
 const generator_utils_1 = require("../generate/generator-utils");
 const config_1 = require("./config/config");
+const deep_merge_json_1 = require("./config/deep-merge-json");
 const filter_release_groups_1 = require("./config/filter-release-groups");
 const version_plans_1 = require("./config/version-plans");
 const batch_projects_by_generator_config_1 = require("./utils/batch-projects-by-generator-config");
 const git_1 = require("./utils/git");
 const print_changes_1 = require("./utils/print-changes");
+const print_config_1 = require("./utils/print-config");
 const resolve_nx_json_error_message_1 = require("./utils/resolve-nx-json-error-message");
 const shared_1 = require("./utils/shared");
 const LARGE_BUFFER = 1024 * 1000000;
@@ -29,78 +31,180 @@ const LARGE_BUFFER = 1024 * 1000000;
 var semver_1 = require("./utils/semver");
 Object.defineProperty(exports, "deriveNewSemverVersion", { enumerable: true, get: function () { return semver_1.deriveNewSemverVersion; } });
 exports.validReleaseVersionPrefixes = ['auto', '', '~', '^', '='];
-const releaseVersionCLIHandler = (args) => (0, params_1.handleErrors)(args.verbose, () => releaseVersion(args));
+const releaseVersionCLIHandler = (args) => (0, params_1.handleErrors)(args.verbose, () => createAPI({})(args));
 exports.releaseVersionCLIHandler = releaseVersionCLIHandler;
-/**
- * NOTE: This function is also exported for programmatic usage and forms part of the public API
- * of Nx. We intentionally do not wrap the implementation with handleErrors because users need
- * to have control over their own error handling when using the API.
- */
-async function releaseVersion(args) {
-    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
-    const { projects } = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
-    const nxJson = (0, nx_json_1.readNxJson)();
-    if (args.verbose) {
-        process.env.NX_VERBOSE_LOGGING = 'true';
-    }
-    // Apply default configuration to any optional user configuration
-    const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, await (0, file_map_utils_1.createProjectFileMapUsingProjectGraph)(projectGraph), nxJson.release);
-    if (configError) {
-        return await (0, config_1.handleNxReleaseConfigError)(configError);
-    }
-    // The nx release top level command will always override these three git args. This is how we can tell
-    // if the top level release command was used or if the user is using the changelog subcommand.
-    // If the user explicitly overrides these args, then it doesn't matter if the top level config is set,
-    // as all of the git options would be overridden anyway.
-    if ((args.gitCommit === undefined ||
-        args.gitTag === undefined ||
-        args.stageChanges === undefined) &&
-        nxJson.release?.git) {
-        const nxJsonMessage = await (0, resolve_nx_json_error_message_1.resolveNxJsonConfigErrorMessage)([
-            'release',
-            'git',
-        ]);
-        output_1.output.error({
-            title: `The "release.git" property in nx.json may not be used with the "nx release version" subcommand or programmatic API. Instead, configure git options for subcommands directly with "release.version.git" and "release.changelog.git".`,
-            bodyLines: [nxJsonMessage],
-        });
-        process.exit(1);
-    }
-    const { error: filterError, releaseGroups, releaseGroupToFilteredProjects, } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig, args.projects, args.groups);
-    if (filterError) {
-        output_1.output.error(filterError);
-        process.exit(1);
-    }
-    const rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
-    (0, version_plans_1.setVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes));
-    if (args.deleteVersionPlans === undefined) {
-        // default to not delete version plans after versioning as they may be needed for changelog generation
-        args.deleteVersionPlans = false;
-    }
-    runPreVersionCommand(nxReleaseConfig.version.preVersionCommand, {
-        dryRun: args.dryRun,
-        verbose: args.verbose,
-    });
-    const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, args.verbose);
-    const versionData = {};
-    const commitMessage = args.gitCommitMessage || nxReleaseConfig.version.git.commitMessage;
-    const generatorCallbacks = [];
+function createAPI(overrideReleaseConfig) {
     /**
-     * additionalChangedFiles are files which need to be updated as a side-effect of versioning (such as package manager lock files),
-     * and need to get staged and committed as part of the existing commit, if applicable.
+     * NOTE: This function is also exported for programmatic usage and forms part of the public API
+     * of Nx. We intentionally do not wrap the implementation with handleErrors because users need
+     * to have control over their own error handling when using the API.
      */
-    const additionalChangedFiles = new Set();
-    const additionalDeletedFiles = new Set();
-    if (args.projects?.length) {
+    return async function releaseVersion(args) {
+        const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+        const { projects } = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+        const nxJson = (0, nx_json_1.readNxJson)();
+        const userProvidedReleaseConfig = (0, deep_merge_json_1.deepMergeJson)(nxJson.release ?? {}, overrideReleaseConfig ?? {});
+        if (args.verbose) {
+            process.env.NX_VERBOSE_LOGGING = 'true';
+        }
+        // Apply default configuration to any optional user configuration
+        const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, await (0, file_map_utils_1.createProjectFileMapUsingProjectGraph)(projectGraph), userProvidedReleaseConfig);
+        if (configError) {
+            return await (0, config_1.handleNxReleaseConfigError)(configError);
+        }
+        // --print-config exits directly as it is not designed to be combined with any other programmatic operations
+        if (args.printConfig) {
+            return (0, print_config_1.printConfigAndExit)({
+                userProvidedReleaseConfig,
+                nxReleaseConfig,
+                isDebug: args.printConfig === 'debug',
+            });
+        }
+        // The nx release top level command will always override these three git args. This is how we can tell
+        // if the top level release command was used or if the user is using the changelog subcommand.
+        // If the user explicitly overrides these args, then it doesn't matter if the top level config is set,
+        // as all of the git options would be overridden anyway.
+        if ((args.gitCommit === undefined ||
+            args.gitTag === undefined ||
+            args.stageChanges === undefined) &&
+            userProvidedReleaseConfig.git) {
+            const nxJsonMessage = await (0, resolve_nx_json_error_message_1.resolveNxJsonConfigErrorMessage)([
+                'release',
+                'git',
+            ]);
+            output_1.output.error({
+                title: `The "release.git" property in nx.json may not be used with the "nx release version" subcommand or programmatic API. Instead, configure git options for subcommands directly with "release.version.git" and "release.changelog.git".`,
+                bodyLines: [nxJsonMessage],
+            });
+            process.exit(1);
+        }
+        const { error: filterError, releaseGroups, releaseGroupToFilteredProjects, } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig, args.projects, args.groups);
+        if (filterError) {
+            output_1.output.error(filterError);
+            process.exit(1);
+        }
+        const rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
+        (0, version_plans_1.setVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes));
+        if (args.deleteVersionPlans === undefined) {
+            // default to not delete version plans after versioning as they may be needed for changelog generation
+            args.deleteVersionPlans = false;
+        }
+        runPreVersionCommand(nxReleaseConfig.version.preVersionCommand, {
+            dryRun: args.dryRun,
+            verbose: args.verbose,
+        });
+        const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, args.verbose);
+        const versionData = {};
+        const commitMessage = args.gitCommitMessage || nxReleaseConfig.version.git.commitMessage;
+        const generatorCallbacks = [];
+        /**
+         * additionalChangedFiles are files which need to be updated as a side-effect of versioning (such as package manager lock files),
+         * and need to get staged and committed as part of the existing commit, if applicable.
+         */
+        const additionalChangedFiles = new Set();
+        const additionalDeletedFiles = new Set();
+        if (args.projects?.length) {
+            /**
+             * Run versioning for all remaining release groups and filtered projects within them
+             */
+            for (const releaseGroup of releaseGroups) {
+                const releaseGroupName = releaseGroup.name;
+                const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
+                const projectBatches = (0, batch_projects_by_generator_config_1.batchProjectsByGeneratorConfig)(projectGraph, releaseGroup, 
+                // Only batch based on the filtered projects within the release group
+                releaseGroupProjectNames);
+                for (const [generatorConfigString, projectNames,] of projectBatches.entries()) {
+                    const [generatorName, generatorOptions] = JSON.parse(generatorConfigString);
+                    // Resolve the generator for the batch and run versioning on the projects within the batch
+                    const generatorData = resolveGeneratorData({
+                        ...extractGeneratorCollectionAndName(`batch "${JSON.stringify(projectNames)}" for release-group "${releaseGroupName}"`, generatorName),
+                        configGeneratorOptions: generatorOptions,
+                        // all project data from the project graph (not to be confused with projectNamesToRunVersionOn)
+                        projects,
+                    });
+                    const generatorCallback = await runVersionOnProjects(projectGraph, nxJson, args, tree, generatorData, args.generatorOptionsOverrides, projectNames, releaseGroup, versionData, nxReleaseConfig.conventionalCommits);
+                    // Capture the callback so that we can run it after flushing the changes to disk
+                    generatorCallbacks.push(async () => {
+                        const result = await generatorCallback(tree, {
+                            dryRun: !!args.dryRun,
+                            verbose: !!args.verbose,
+                            generatorOptions: {
+                                ...generatorOptions,
+                                ...args.generatorOptionsOverrides,
+                            },
+                        });
+                        const { changedFiles, deletedFiles } = parseGeneratorCallbackResult(result);
+                        changedFiles.forEach((f) => additionalChangedFiles.add(f));
+                        deletedFiles.forEach((f) => additionalDeletedFiles.add(f));
+                    });
+                }
+            }
+            // Resolve any git tags as early as possible so that we can hard error in case of any duplicates before reaching the actual git command
+            const gitTagValues = args.gitTag ?? nxReleaseConfig.version.git.tag
+                ? (0, shared_1.createGitTagValues)(releaseGroups, releaseGroupToFilteredProjects, versionData)
+                : [];
+            (0, shared_1.handleDuplicateGitTags)(gitTagValues);
+            printAndFlushChanges(tree, !!args.dryRun);
+            for (const generatorCallback of generatorCallbacks) {
+                await generatorCallback();
+            }
+            const changedFiles = [
+                ...tree.listChanges().map((f) => f.path),
+                ...additionalChangedFiles,
+            ];
+            // No further actions are necessary in this scenario (e.g. if conventional commits detected no changes)
+            if (!changedFiles.length) {
+                return {
+                    // An overall workspace version cannot be relevant when filtering to independent projects
+                    workspaceVersion: undefined,
+                    projectsVersionData: versionData,
+                };
+            }
+            if (args.gitCommit ?? nxReleaseConfig.version.git.commit) {
+                await (0, shared_1.commitChanges)({
+                    changedFiles,
+                    deletedFiles: Array.from(additionalDeletedFiles),
+                    isDryRun: !!args.dryRun,
+                    isVerbose: !!args.verbose,
+                    gitCommitMessages: (0, shared_1.createCommitMessageValues)(releaseGroups, releaseGroupToFilteredProjects, versionData, commitMessage),
+                    gitCommitArgs: args.gitCommitArgs || nxReleaseConfig.version.git.commitArgs,
+                });
+            }
+            else if (args.stageChanges ??
+                nxReleaseConfig.version.git.stageChanges) {
+                output_1.output.logSingleLine(`Staging changed files with git`);
+                await (0, git_1.gitAdd)({
+                    changedFiles,
+                    dryRun: args.dryRun,
+                    verbose: args.verbose,
+                });
+            }
+            if (args.gitTag ?? nxReleaseConfig.version.git.tag) {
+                output_1.output.logSingleLine(`Tagging commit with git`);
+                for (const tag of gitTagValues) {
+                    await (0, git_1.gitTag)({
+                        tag,
+                        message: args.gitTagMessage || nxReleaseConfig.version.git.tagMessage,
+                        additionalArgs: args.gitTagArgs || nxReleaseConfig.version.git.tagArgs,
+                        dryRun: args.dryRun,
+                        verbose: args.verbose,
+                    });
+                }
+            }
+            return {
+                // An overall workspace version cannot be relevant when filtering to independent projects
+                workspaceVersion: undefined,
+                projectsVersionData: versionData,
+            };
+        }
         /**
-         * Run versioning for all remaining release groups and filtered projects within them
+         * Run versioning for all remaining release groups
          */
         for (const releaseGroup of releaseGroups) {
             const releaseGroupName = releaseGroup.name;
-            const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
             const projectBatches = (0, batch_projects_by_generator_config_1.batchProjectsByGeneratorConfig)(projectGraph, releaseGroup, 
-            // Only batch based on the filtered projects within the release group
-            releaseGroupProjectNames);
+            // Batch based on all projects within the release group
+            releaseGroup.projects);
             for (const [generatorConfigString, projectNames,] of projectBatches.entries()) {
                 const [generatorName, generatorOptions] = JSON.parse(generatorConfigString);
                 // Resolve the generator for the batch and run versioning on the projects within the batch
@@ -136,6 +240,15 @@ async function releaseVersion(args) {
         for (const generatorCallback of generatorCallbacks) {
             await generatorCallback();
         }
+        // Only applicable when there is a single release group with a fixed relationship
+        let workspaceVersion = undefined;
+        if (releaseGroups.length === 1) {
+            const releaseGroup = releaseGroups[0];
+            if (releaseGroup.projectsRelationship === 'fixed') {
+                const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
+                workspaceVersion = versionData[releaseGroupProjectNames[0]].newVersion; // all projects have the same version so we can just grab the first
+            }
+        }
         const changedFiles = [
             ...tree.listChanges().map((f) => f.path),
             ...additionalChangedFiles,
@@ -144,8 +257,7 @@ async function releaseVersion(args) {
         // No further actions are necessary in this scenario (e.g. if conventional commits detected no changes)
         if (!changedFiles.length && !deletedFiles.length) {
             return {
-                // An overall workspace version cannot be relevant when filtering to independent projects
-                workspaceVersion: undefined,
+                workspaceVersion,
                 projectsVersionData: versionData,
             };
         }
@@ -180,108 +292,10 @@ async function releaseVersion(args) {
                 });
             }
         }
-        return {
-            // An overall workspace version cannot be relevant when filtering to independent projects
-            workspaceVersion: undefined,
-            projectsVersionData: versionData,
-        };
-    }
-    /**
-     * Run versioning for all remaining release groups
-     */
-    for (const releaseGroup of releaseGroups) {
-        const releaseGroupName = releaseGroup.name;
-        const projectBatches = (0, batch_projects_by_generator_config_1.batchProjectsByGeneratorConfig)(projectGraph, releaseGroup, 
-        // Batch based on all projects within the release group
-        releaseGroup.projects);
-        for (const [generatorConfigString, projectNames,] of projectBatches.entries()) {
-            const [generatorName, generatorOptions] = JSON.parse(generatorConfigString);
-            // Resolve the generator for the batch and run versioning on the projects within the batch
-            const generatorData = resolveGeneratorData({
-                ...extractGeneratorCollectionAndName(`batch "${JSON.stringify(projectNames)}" for release-group "${releaseGroupName}"`, generatorName),
-                configGeneratorOptions: generatorOptions,
-                // all project data from the project graph (not to be confused with projectNamesToRunVersionOn)
-                projects,
-            });
-            const generatorCallback = await runVersionOnProjects(projectGraph, nxJson, args, tree, generatorData, args.generatorOptionsOverrides, projectNames, releaseGroup, versionData, nxReleaseConfig.conventionalCommits);
-            // Capture the callback so that we can run it after flushing the changes to disk
-            generatorCallbacks.push(async () => {
-                const result = await generatorCallback(tree, {
-                    dryRun: !!args.dryRun,
-                    verbose: !!args.verbose,
-                    generatorOptions: {
-                        ...generatorOptions,
-                        ...args.generatorOptionsOverrides,
-                    },
-                });
-                const { changedFiles, deletedFiles } = parseGeneratorCallbackResult(result);
-                changedFiles.forEach((f) => additionalChangedFiles.add(f));
-                deletedFiles.forEach((f) => additionalDeletedFiles.add(f));
-            });
-        }
-    }
-    // Resolve any git tags as early as possible so that we can hard error in case of any duplicates before reaching the actual git command
-    const gitTagValues = args.gitTag ?? nxReleaseConfig.version.git.tag
-        ? (0, shared_1.createGitTagValues)(releaseGroups, releaseGroupToFilteredProjects, versionData)
-        : [];
-    (0, shared_1.handleDuplicateGitTags)(gitTagValues);
-    printAndFlushChanges(tree, !!args.dryRun);
-    for (const generatorCallback of generatorCallbacks) {
-        await generatorCallback();
-    }
-    // Only applicable when there is a single release group with a fixed relationship
-    let workspaceVersion = undefined;
-    if (releaseGroups.length === 1) {
-        const releaseGroup = releaseGroups[0];
-        if (releaseGroup.projectsRelationship === 'fixed') {
-            const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
-            workspaceVersion = versionData[releaseGroupProjectNames[0]].newVersion; // all projects have the same version so we can just grab the first
-        }
-    }
-    const changedFiles = [
-        ...tree.listChanges().map((f) => f.path),
-        ...additionalChangedFiles,
-    ];
-    // No further actions are necessary in this scenario (e.g. if conventional commits detected no changes)
-    if (!changedFiles.length) {
         return {
             workspaceVersion,
             projectsVersionData: versionData,
         };
-    }
-    if (args.gitCommit ?? nxReleaseConfig.version.git.commit) {
-        await (0, shared_1.commitChanges)({
-            changedFiles,
-            deletedFiles: Array.from(additionalDeletedFiles),
-            isDryRun: !!args.dryRun,
-            isVerbose: !!args.verbose,
-            gitCommitMessages: (0, shared_1.createCommitMessageValues)(releaseGroups, releaseGroupToFilteredProjects, versionData, commitMessage),
-            gitCommitArgs: args.gitCommitArgs || nxReleaseConfig.version.git.commitArgs,
-        });
-    }
-    else if (args.stageChanges ?? nxReleaseConfig.version.git.stageChanges) {
-        output_1.output.logSingleLine(`Staging changed files with git`);
-        await (0, git_1.gitAdd)({
-            changedFiles,
-            dryRun: args.dryRun,
-            verbose: args.verbose,
-        });
-    }
-    if (args.gitTag ?? nxReleaseConfig.version.git.tag) {
-        output_1.output.logSingleLine(`Tagging commit with git`);
-        for (const tag of gitTagValues) {
-            await (0, git_1.gitTag)({
-                tag,
-                message: args.gitTagMessage || nxReleaseConfig.version.git.tagMessage,
-                additionalArgs: args.gitTagArgs || nxReleaseConfig.version.git.tagArgs,
-                dryRun: args.dryRun,
-                verbose: args.verbose,
-            });
-        }
-    }
-    return {
-        workspaceVersion,
-        projectsVersionData: versionData,
     };
 }
 function appendVersionData(existingVersionData, newVersionData) {

package/src/command-line/run/run-one.js

@@ -14,7 +14,7 @@ const calculate_default_project_name_1 = require("../../config/calculate-default
 const workspace_configuration_check_1 = require("../../utils/workspace-configuration-check");
 const graph_1 = require("../graph/graph");
 async function runOne(cwd, args, extraTargetDependencies = {}, extraOptions = {
-    excludeTaskDependencies: false,
+    excludeTaskDependencies: args.excludeTaskDependencies,
     loadDotEnvFiles: process.env.NX_LOAD_DOT_ENV_FILES !== 'false',
 }) {
     perf_hooks_1.performance.mark('code-loading:end');

package/src/command-line/run-many/run-many.js

@@ -15,7 +15,7 @@ const find_matching_projects_1 = require("../../utils/find-matching-projects");
 const workspace_configuration_check_1 = require("../../utils/workspace-configuration-check");
 const graph_1 = require("../graph/graph");
 async function runMany(args, extraTargetDependencies = {}, extraOptions = {
-    excludeTaskDependencies: false,
+    excludeTaskDependencies: args.excludeTaskDependencies,
     loadDotEnvFiles: process.env.NX_LOAD_DOT_ENV_FILES !== 'false',
 }) {
     perf_hooks_1.performance.mark('code-loading:end');

package/src/command-line/yargs-utils/shared-options.d.ts

@@ -18,6 +18,7 @@ export interface RunOptions {
     dte: boolean;
     batch: boolean;
     useAgents: boolean;
+    excludeTaskDependencies: boolean;
 }
 export declare function withRunOptions<T>(yargs: Argv<T>): Argv<T & RunOptions>;
 export declare function withTargetAndConfigurationOption(yargs: Argv, demandOption?: boolean): Argv<{

package/src/command-line/yargs-utils/shared-options.js

@@ -66,6 +66,11 @@ function withRunOptions(yargs) {
         describe: 'Rerun the tasks even when the results are available in the cache',
         type: 'boolean',
         default: false,
+    })
+        .options('excludeTaskDependencies', {
+        describe: 'Skips running dependent tasks first',
+        type: 'boolean',
+        default: false,
     })
         .options('cloud', {
         type: 'boolean',

package/src/commands-runner/create-command-graph.js

@@ -36,8 +36,10 @@ const recursiveResolveDeps = (projectGraph, projectName, resolved) => {
 };
 function createCommandGraph(projectGraph, projectNames, nxArgs) {
     const dependencies = {};
-    for (const projectName of projectNames) {
-        recursiveResolveDeps(projectGraph, projectName, dependencies);
+    if (!nxArgs.excludeTaskDependencies) {
+        for (const projectName of projectNames) {
+            recursiveResolveDeps(projectGraph, projectName, dependencies);
+        }
     }
     const roots = Object.keys(dependencies).filter((d) => dependencies[d].length === 0);
     const commandGraph = {

package/src/config/nx-json.d.ts

@@ -145,7 +145,7 @@ export interface NxReleaseConventionalCommitsConfiguration {
         } | boolean;
     } | boolean>;
 }
-interface NxReleaseConfiguration {
+export interface NxReleaseConfiguration {
     /**
      * Shorthand for amending the projects which will be included in the implicit default release group (all projects by default).
      * @note Only one of `projects` or `groups` can be specified, the cannot be used together.
@@ -379,6 +379,11 @@ export interface NxJsonConfiguration<T = '*' | string[]> {
      * To use a different runner that accepts an access token, define it in {@link tasksRunnerOptions}
      */
     nxCloudAccessToken?: string;
+    /**
+     * If specified Nx will use nx-cloud by default with the given cloud id.
+     * To use a different runner that accepts a cloud id, define it in {@link tasksRunnerOptions}
+     */
+    nxCloudId?: string;
     /**
      * Specifies the url pointing to an instance of nx cloud. Used for remote
      * caching and displaying run links.
@@ -404,6 +409,10 @@ export interface NxJsonConfiguration<T = '*' | string[]> {
      * Set this to false to disable adding inference plugins when generating new projects
      */
     useInferencePlugins?: boolean;
+    /**
+     * Set this to false to disable connection to Nx Cloud
+     */
+    neverConnectToCloud?: boolean;
 }
 export type PluginConfiguration = string | ExpandedPluginConfiguration;
 export type ExpandedPluginConfiguration<T = unknown> = {

package/src/devkit-internals.d.ts

@@ -9,7 +9,7 @@ export { readNxJson as readNxJsonFromDisk } from './config/nx-json';
 export { calculateDefaultProjectName } from './config/calculate-default-project-name';
 export { retrieveProjectConfigurationsWithAngularProjects } from './project-graph/utils/retrieve-workspace-files';
 export { mergeTargetConfigurations } from './project-graph/utils/project-configuration-utils';
-export { readProjectConfigurationsFromRootMap } from './project-graph/utils/project-configuration-utils';
+export { readProjectConfigurationsFromRootMap, findMatchingConfigFiles, } from './project-graph/utils/project-configuration-utils';
 export { splitTarget } from './utils/split-target';
 export { combineOptionsForExecutor } from './utils/params';
 export { sortObjectByKeys } from './utils/object-sort';

package/src/devkit-internals.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.interpolate = exports.registerTsProject = exports.LoadedNxPlugin = exports.retrieveProjectConfigurations = exports.findProjectForPath = exports.createProjectRootMappingsFromProjectConfigurations = exports.hashWithWorkspaceContext = exports.hashObject = exports.splitByColons = exports.readModulePackageJson = exports.stripIndent = exports.sortObjectByKeys = exports.combineOptionsForExecutor = exports.splitTarget = exports.readProjectConfigurationsFromRootMap = exports.mergeTargetConfigurations = exports.retrieveProjectConfigurationsWithAngularProjects = exports.calculateDefaultProjectName = exports.readNxJsonFromDisk = exports.getExecutorInformation = exports.createTempNpmDirectory = void 0;
+exports.interpolate = exports.registerTsProject = exports.LoadedNxPlugin = exports.retrieveProjectConfigurations = exports.findProjectForPath = exports.createProjectRootMappingsFromProjectConfigurations = exports.hashWithWorkspaceContext = exports.hashObject = exports.splitByColons = exports.readModulePackageJson = exports.stripIndent = exports.sortObjectByKeys = exports.combineOptionsForExecutor = exports.splitTarget = exports.findMatchingConfigFiles = exports.readProjectConfigurationsFromRootMap = exports.mergeTargetConfigurations = exports.retrieveProjectConfigurationsWithAngularProjects = exports.calculateDefaultProjectName = exports.readNxJsonFromDisk = exports.getExecutorInformation = exports.createTempNpmDirectory = void 0;
 const tslib_1 = require("tslib");
 /**
  * Note to developers: STOP! These exports are available via requireNx in @nx/devkit.
@@ -21,6 +21,7 @@ var project_configuration_utils_1 = require("./project-graph/utils/project-confi
 Object.defineProperty(exports, "mergeTargetConfigurations", { enumerable: true, get: function () { return project_configuration_utils_1.mergeTargetConfigurations; } });
 var project_configuration_utils_2 = require("./project-graph/utils/project-configuration-utils");
 Object.defineProperty(exports, "readProjectConfigurationsFromRootMap", { enumerable: true, get: function () { return project_configuration_utils_2.readProjectConfigurationsFromRootMap; } });
+Object.defineProperty(exports, "findMatchingConfigFiles", { enumerable: true, get: function () { return project_configuration_utils_2.findMatchingConfigFiles; } });
 var split_target_1 = require("./utils/split-target");
 Object.defineProperty(exports, "splitTarget", { enumerable: true, get: function () { return split_target_1.splitTarget; } });
 var params_1 = require("./utils/params");

package/src/generators/utils/project-configuration.js

@@ -17,10 +17,10 @@ const workspace_context_1 = require("../../utils/workspace-context");
 const output_1 = require("../../utils/output");
 const path_2 = require("../../utils/path");
 const json_1 = require("./json");
-const nx_json_1 = require("./nx-json");
-var nx_json_2 = require("./nx-json");
-Object.defineProperty(exports, "readNxJson", { enumerable: true, get: function () { return nx_json_2.readNxJson; } });
-Object.defineProperty(exports, "updateNxJson", { enumerable: true, get: function () { return nx_json_2.updateNxJson; } });
+const to_project_name_1 = require("../../config/to-project-name");
+var nx_json_1 = require("./nx-json");
+Object.defineProperty(exports, "readNxJson", { enumerable: true, get: function () { return nx_json_1.readNxJson; } });
+Object.defineProperty(exports, "updateNxJson", { enumerable: true, get: function () { return nx_json_1.updateNxJson; } });
 /**
  * Adds project configuration to the Nx workspace.
  *
@@ -56,10 +56,35 @@ function addProjectConfiguration(tree, projectName, projectConfiguration, standa
  * @param projectConfiguration - project configuration
  */
 function updateProjectConfiguration(tree, projectName, projectConfiguration) {
-    const projectConfigFile = (0, path_2.joinPathFragments)(projectConfiguration.root, 'project.json');
-    if (!tree.exists(projectConfigFile)) {
+    if (tree.exists((0, path_2.joinPathFragments)(projectConfiguration.root, 'project.json'))) {
+        updateProjectConfigurationInProjectJson(tree, projectName, projectConfiguration);
+    }
+    else if (tree.exists((0, path_2.joinPathFragments)(projectConfiguration.root, 'package.json'))) {
+        updateProjectConfigurationInPackageJson(tree, projectName, projectConfiguration);
+    }
+    else {
         throw new Error(`Cannot update Project ${projectName} at ${projectConfiguration.root}. It either doesn't exist yet, or may not use project.json for configuration. Use \`addProjectConfiguration()\` instead if you want to create a new project.`);
     }
+}
+function updateProjectConfigurationInPackageJson(tree, projectName, projectConfiguration) {
+    const packageJsonFile = (0, path_2.joinPathFragments)(projectConfiguration.root, 'package.json');
+    const packageJson = (0, json_1.readJson)(tree, packageJsonFile);
+    if (packageJson.name === projectConfiguration.name ?? projectName) {
+        delete projectConfiguration.name;
+    }
+    if (projectConfiguration.targets &&
+        !Object.keys(projectConfiguration.targets).length) {
+        delete projectConfiguration.targets;
+    }
+    packageJson.nx = {
+        ...packageJson.nx,
+        ...projectConfiguration,
+        root: undefined,
+    };
+    (0, json_1.writeJson)(tree, packageJsonFile, packageJson);
+}
+function updateProjectConfigurationInProjectJson(tree, projectName, projectConfiguration) {
+    const projectConfigFile = (0, path_2.joinPathFragments)(projectConfiguration.root, 'project.json');
     handleEmptyTargets(projectName, projectConfiguration);
     (0, json_1.writeJson)(tree, projectConfigFile, {
         name: projectConfiguration.name ?? projectName,
@@ -147,15 +172,20 @@ function readAndCombineAllProjectConfigurations(tree) {
         }
         else if ((0, path_1.basename)(projectFile) === 'package.json') {
             const packageJson = (0, json_1.readJson)(tree, projectFile);
-            const config = (0, package_json_1.buildProjectConfigurationFromPackageJson)(packageJson, tree.root, projectFile, (0, nx_json_1.readNxJson)(tree));
+            // We don't want to have all of the extra inferred stuff in here, as
+            // when generators update the project they shouldn't inline that stuff.
+            // so rather than using `buildProjectFromPackageJson` and stripping it out
+            // we are going to build the config manually.
+            const config = {
+                root: (0, path_1.dirname)(projectFile),
+                name: packageJson.name ?? (0, to_project_name_1.toProjectName)(projectFile),
+                ...packageJson.nx,
+            };
             if (!rootMap[config.root]) {
                 (0, project_configuration_utils_1.mergeProjectConfigurationIntoRootMap)(rootMap, 
                 // Inferred targets, tags, etc don't show up when running generators
                 // This is to help avoid running into issues when trying to update the workspace
-                {
-                    name: config.name,
-                    root: config.root,
-                }, undefined, undefined, true);
+                config, undefined, undefined, true);
             }
         }
     }

package/src/nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud.d.ts

@@ -1,4 +1,5 @@
 import { Tree } from '../../../generators/tree';
+import { NxJsonConfiguration } from '../../../config/nx-json';
 export declare function printSuccessMessage(token: string | undefined, installationSource: string, usesGithub: boolean): Promise<string>;
 export interface ConnectToNxCloudOptions {
     analytics?: boolean;
@@ -7,5 +8,6 @@ export interface ConnectToNxCloudOptions {
     github?: boolean;
     directory?: string;
 }
-export declare function connectToNxCloud(tree: Tree, schema: ConnectToNxCloudOptions): Promise<string>;
-export default connectToNxCloud;
+export declare function connectToNxCloud(tree: Tree, schema: ConnectToNxCloudOptions, nxJson?: NxJsonConfiguration<string[] | "*">): Promise<string>;
+declare function connectToNxCloudGenerator(tree: Tree, options: ConnectToNxCloudOptions): Promise<void>;
+export default connectToNxCloudGenerator;